diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index 633910a5f0298c4e90c88bd941379e2d365ccb1e..25d3590f3b8ebd029eeb7792f1433658d980958b 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -20,16 +20,163 @@
"ImportPath": "github.com/ayufan/golang-kardianos-service",
"Rev": "0c8eb6d8fff2e2fb884a7bfd23e183fb63c0eff3"
},
+ {
+ "ImportPath": "github.com/beorn7/perks/quantile",
+ "Rev": "4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9"
+ },
+ {
+ "ImportPath": "github.com/blang/semver",
+ "Comment": "v3.3.0",
+ "Rev": "60ec3488bfea7cca02b021d106d9911120d25fe9"
+ },
{
"ImportPath": "github.com/codegangsta/cli",
"Comment": "v1.8.0-4-g142e6cd",
"Rev": "142e6cd241a4dfbf7f07a018f1f8225180018da4"
},
+ {
+ "ImportPath": "github.com/coreos/go-oidc/http",
+ "Rev": "1efe0e1303a62da553fcb6beb8bd2aa9250c0ca8"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-oidc/jose",
+ "Rev": "1efe0e1303a62da553fcb6beb8bd2aa9250c0ca8"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-oidc/key",
+ "Rev": "1efe0e1303a62da553fcb6beb8bd2aa9250c0ca8"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-oidc/oauth2",
+ "Rev": "1efe0e1303a62da553fcb6beb8bd2aa9250c0ca8"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-oidc/oidc",
+ "Rev": "1efe0e1303a62da553fcb6beb8bd2aa9250c0ca8"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-systemd/journal",
+ "Comment": "v11-10-g5c49e48",
+ "Rev": "5c49e4850c879a0ddc061e8f4adcf307de8a8bc2"
+ },
+ {
+ "ImportPath": "github.com/coreos/pkg/capnslog",
+ "Comment": "v3",
+ "Rev": "3ac0863d7acf3bc44daf49afef8919af12f704ef"
+ },
+ {
+ "ImportPath": "github.com/coreos/pkg/health",
+ "Comment": "v3",
+ "Rev": "3ac0863d7acf3bc44daf49afef8919af12f704ef"
+ },
+ {
+ "ImportPath": "github.com/coreos/pkg/httputil",
+ "Comment": "v3",
+ "Rev": "3ac0863d7acf3bc44daf49afef8919af12f704ef"
+ },
+ {
+ "ImportPath": "github.com/coreos/pkg/timeutil",
+ "Comment": "v3",
+ "Rev": "3ac0863d7acf3bc44daf49afef8919af12f704ef"
+ },
+ {
+ "ImportPath": "github.com/davecgh/go-spew/spew",
+ "Comment": "v1.0.0",
+ "Rev": "6cf5744a041a0022271cefed95ba843f6d87fd51"
+ },
+ {
+ "ImportPath": "github.com/docker/distribution/digest",
+ "Comment": "docs-v2.4.1-2016-06-28-74-g010e063",
+ "Rev": "010e063270be37cfa8547ccfb9717e5d874c88a8"
+ },
+ {
+ "ImportPath": "github.com/docker/distribution/reference",
+ "Comment": "docs-v2.4.1-2016-06-28-74-g010e063",
+ "Rev": "010e063270be37cfa8547ccfb9717e5d874c88a8"
+ },
{
"ImportPath": "github.com/docker/docker/pkg/homedir",
"Comment": "v1.4.1-5743-g7ead74d",
"Rev": "7ead74d903de625eef9dc0ec83ba5bcedd0bc0dc"
},
+ {
+ "ImportPath": "github.com/docker/docker/pkg/mount",
+ "Comment": "v1.4.1-5743-g7ead74d",
+ "Rev": "7ead74d903de625eef9dc0ec83ba5bcedd0bc0dc"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/blkiodev",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/container",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/filters",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/network",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/registry",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/strslice",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/engine-api/types/versions",
+ "Comment": "v0.4.0-42-gc9fd33c",
+ "Rev": "c9fd33c91008b9c558a6ed1cb11a68dbe4db0493"
+ },
+ {
+ "ImportPath": "github.com/docker/go-connections/nat",
+ "Comment": "v0.2.1-2-g0bad1a3",
+ "Rev": "0bad1a3951398f88ef4dd75fdb42af374430be89"
+ },
+ {
+ "ImportPath": "github.com/docker/go-units",
+ "Comment": "v0.3.1-2-geb879ae",
+ "Rev": "eb879ae3e2b84e2a142af415b679ddeda47ec71c"
+ },
+ {
+ "ImportPath": "github.com/docker/spdystream",
+ "Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+ },
+ {
+ "ImportPath": "github.com/docker/spdystream/spdy",
+ "Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+ },
+ {
+ "ImportPath": "github.com/emicklei/go-restful",
+ "Comment": "v1.2-79-g89ef8af",
+ "Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+ },
+ {
+ "ImportPath": "github.com/emicklei/go-restful/log",
+ "Comment": "v1.2-79-g89ef8af",
+ "Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+ },
+ {
+ "ImportPath": "github.com/emicklei/go-restful/swagger",
+ "Comment": "v1.2-79-g89ef8af",
+ "Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+ },
{
"ImportPath": "github.com/fsouza/go-dockerclient",
"Rev": "0099401a7342ad77e71ca9f9a57c5e72fb80f6b2"
@@ -106,24 +253,131 @@
"ImportPath": "github.com/getsentry/raven-go",
"Rev": "dffeb57df75d6a911f00232155194e43d79d38d7"
},
+ {
+ "ImportPath": "github.com/ghodss/yaml",
+ "Rev": "aa0c862057666179de291b67d9f093d12b5a8473"
+ },
+ {
+ "ImportPath": "github.com/gogo/protobuf/proto",
+ "Comment": "v0.2-61-gf20a144",
+ "Rev": "f20a1444730c7d9949b880a0309e737d007def25"
+ },
+ {
+ "ImportPath": "github.com/golang/glog",
+ "Rev": "23def4e6c14b4da8ac2ed8007337bc5eb5007998"
+ },
+ {
+ "ImportPath": "github.com/golang/groupcache/lru",
+ "Rev": "a6b377e3400b08991b80d6805d627f347f983866"
+ },
{
"ImportPath": "github.com/golang/mock/gomock",
"Rev": "06883d979f10cc178f2716846215c8cf90f9e363"
},
+ {
+ "ImportPath": "github.com/golang/protobuf/proto",
+ "Rev": "f592bd283e9ef86337a432eb50e592278c3d534d"
+ },
+ {
+ "ImportPath": "github.com/google/cadvisor/info/v1",
+ "Comment": "v0.23.2-89-g2ed7198",
+ "Rev": "2ed7198f77395ee9a172878a0a7ab92ab59a2cfd"
+ },
+ {
+ "ImportPath": "github.com/google/gofuzz",
+ "Rev": "fd52762d25a41827db7ef64c43756fd4b9f7e382"
+ },
+ {
+ "ImportPath": "github.com/inconshreveable/mousetrap",
+ "Rev": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+ },
+ {
+ "ImportPath": "github.com/jonboulle/clockwork",
+ "Comment": "v0.1.0-2-ge3653ac",
+ "Rev": "e3653ace2d63753697e0e5b07b9393971c0bba9d"
+ },
+ {
+ "ImportPath": "github.com/juju/ratelimit",
+ "Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
+ },
{
"ImportPath": "github.com/kardianos/osext",
"Rev": "efacde03154693404c65e7aa7d461ac9014acd0c"
},
+ {
+ "ImportPath": "github.com/matttproud/golang_protobuf_extensions/pbutil",
+ "Comment": "v1.0.0-2-gc12348c",
+ "Rev": "c12348ce28de40eed0136aa2b644d0ee0650e56c"
+ },
{
"ImportPath": "github.com/minio/minio-go",
"Comment": "v1.0.0-94-ge9fd7b8",
"Rev": "e9fd7b820d9a87122e159439ca034472040a43ce"
},
+ {
+ "ImportPath": "github.com/opencontainers/runc/libcontainer/cgroups",
+ "Comment": "v0.0.7-31-g4f60120",
+ "Rev": "4f601205d475e1995472d81b3787b197008c5dd7"
+ },
+ {
+ "ImportPath": "github.com/opencontainers/runc/libcontainer/cgroups/fs",
+ "Comment": "v0.0.7-31-g4f60120",
+ "Rev": "4f601205d475e1995472d81b3787b197008c5dd7"
+ },
+ {
+ "ImportPath": "github.com/opencontainers/runc/libcontainer/configs",
+ "Comment": "v0.0.7-31-g4f60120",
+ "Rev": "4f601205d475e1995472d81b3787b197008c5dd7"
+ },
+ {
+ "ImportPath": "github.com/opencontainers/runc/libcontainer/system",
+ "Comment": "v0.0.7-31-g4f60120",
+ "Rev": "4f601205d475e1995472d81b3787b197008c5dd7"
+ },
{
"ImportPath": "github.com/opencontainers/runc/libcontainer/user",
"Comment": "v0.0.7-31-g4f60120",
"Rev": "4f601205d475e1995472d81b3787b197008c5dd7"
},
+ {
+ "ImportPath": "github.com/pborman/uuid",
+ "Comment": "v1.0-11-gc55201b",
+ "Rev": "c55201b036063326c5b1b89ccfe45a184973d073"
+ },
+ {
+ "ImportPath": "github.com/prometheus/client_golang/prometheus",
+ "Comment": "v0.8.0",
+ "Rev": "c5b7fccd204277076155f10851dad72b76a49317"
+ },
+ {
+ "ImportPath": "github.com/prometheus/client_model/go",
+ "Comment": "model-0.0.2-12-gfa8ad6f",
+ "Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6"
+ },
+ {
+ "ImportPath": "github.com/prometheus/common/expfmt",
+ "Rev": "ebdfc6da46522d58825777cf1f90490a5b1ef1d8"
+ },
+ {
+ "ImportPath": "github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg",
+ "Rev": "ebdfc6da46522d58825777cf1f90490a5b1ef1d8"
+ },
+ {
+ "ImportPath": "github.com/prometheus/common/model",
+ "Rev": "ebdfc6da46522d58825777cf1f90490a5b1ef1d8"
+ },
+ {
+ "ImportPath": "github.com/prometheus/procfs",
+ "Rev": "abf152e5f3e97f2fafac028d2cc06c1feb87ffa5"
+ },
+ {
+ "ImportPath": "github.com/spf13/cobra",
+ "Rev": "7c674d9e72017ed25f6d2b5e497a1368086b6a6f"
+ },
+ {
+ "ImportPath": "github.com/spf13/pflag",
+ "Rev": "4f9190456aed1c2113ca51ea9b89219747458dc1"
+ },
{
"ImportPath": "github.com/stretchr/objx",
"Rev": "cbeaeb16a013161a98496fad62933b1d21786672"
@@ -140,6 +394,10 @@
"ImportPath": "github.com/stretchr/testify/require",
"Rev": "1297dc01ed0a819ff634c89707081a4df43baf6b"
},
+ {
+ "ImportPath": "github.com/ugorji/go/codec",
+ "Rev": "4a1cb5252a6951f715a85d0e4be334c2a2dbf2a2"
+ },
{
"ImportPath": "gitlab.com/ayufan/golang-cli-helpers",
"Rev": "0a14b63a7466ee44de4a90f998fad73afa8482bf"
@@ -152,6 +410,46 @@
"ImportPath": "golang.org/x/crypto/ssh",
"Rev": "1f22c0103821b9390939b6776727195525381532"
},
+ {
+ "ImportPath": "golang.org/x/net/context",
+ "Rev": "07b51741c1d6423d4a6abab1c49940ec09cb1aaf"
+ },
+ {
+ "ImportPath": "golang.org/x/net/context/ctxhttp",
+ "Rev": "07b51741c1d6423d4a6abab1c49940ec09cb1aaf"
+ },
+ {
+ "ImportPath": "golang.org/x/net/http2",
+ "Rev": "07b51741c1d6423d4a6abab1c49940ec09cb1aaf"
+ },
+ {
+ "ImportPath": "golang.org/x/net/http2/hpack",
+ "Rev": "07b51741c1d6423d4a6abab1c49940ec09cb1aaf"
+ },
+ {
+ "ImportPath": "golang.org/x/net/websocket",
+ "Rev": "07b51741c1d6423d4a6abab1c49940ec09cb1aaf"
+ },
+ {
+ "ImportPath": "golang.org/x/oauth2",
+ "Rev": "3b966c7f301c0c71c53d94dc632a62df0a682cd7"
+ },
+ {
+ "ImportPath": "golang.org/x/oauth2/google",
+ "Rev": "3b966c7f301c0c71c53d94dc632a62df0a682cd7"
+ },
+ {
+ "ImportPath": "golang.org/x/oauth2/internal",
+ "Rev": "3b966c7f301c0c71c53d94dc632a62df0a682cd7"
+ },
+ {
+ "ImportPath": "golang.org/x/oauth2/jws",
+ "Rev": "3b966c7f301c0c71c53d94dc632a62df0a682cd7"
+ },
+ {
+ "ImportPath": "golang.org/x/oauth2/jwt",
+ "Rev": "3b966c7f301c0c71c53d94dc632a62df0a682cd7"
+ },
{
"ImportPath": "golang.org/x/sys/windows",
"Rev": "98fc11432b951eb53c62602ba4ae99d03c1fb7e2"
@@ -172,9 +470,721 @@
"ImportPath": "golang.org/x/sys/windows/svc/mgr",
"Rev": "98fc11432b951eb53c62602ba4ae99d03c1fb7e2"
},
+ {
+ "ImportPath": "google.golang.org/cloud/compute/metadata",
+ "Rev": "12aa462581208c155e498dc13e14cabe6da24dc3"
+ },
+ {
+ "ImportPath": "google.golang.org/cloud/internal",
+ "Rev": "12aa462581208c155e498dc13e14cabe6da24dc3"
+ },
+ {
+ "ImportPath": "gopkg.in/inf.v0",
+ "Comment": "v0.9.0",
+ "Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
+ },
{
"ImportPath": "gopkg.in/yaml.v1",
"Rev": "9f9df34309c04878acc86042b16630b0f696e1de"
+ },
+ {
+ "ImportPath": "gopkg.in/yaml.v2",
+ "Rev": "e4d366fc3c7938e2958e662b4258c7a89e1f0e3e"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/apis/federation",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/apis/federation/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/apis/federation/v1beta1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/annotations",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/endpoints",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/errors",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/meta",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/meta/metatypes",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/pod",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/resource",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/rest",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/service",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/testapi",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/unversioned/validation",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/util",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/v1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/api/validation",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apimachinery",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apimachinery/registered",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/apps",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/apps/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/apps/v1alpha1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authentication.k8s.io",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authentication.k8s.io/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authorization",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authorization/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/authorization/v1beta1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/autoscaling",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/autoscaling/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/autoscaling/v1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/batch",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/batch/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/batch/v1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/batch/v2alpha1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/componentconfig",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/componentconfig/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/extensions",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/extensions/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/extensions/v1beta1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/extensions/validation",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/policy",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/policy/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/policy/v1alpha1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/rbac",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/rbac/install",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/apis/rbac/v1alpha1",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/auth/user",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/capabilities",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/cache",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/metrics",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/record",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/restclient",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/transport",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/typed/discovery",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/unversioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/unversioned/fake",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/client/unversioned/remotecommand",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/controller",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/controller/framework",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/conversion",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/conversion/queryparams",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/credentialprovider",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/fieldpath",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/fields",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/httplog",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/kubectl",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/kubectl/resource",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/kubelet/qos",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/kubelet/qos/util",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/kubelet/server/remotecommand",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/labels",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/master/ports",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/registry/generic",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer/json",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer/protobuf",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer/recognizer",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer/streaming",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/runtime/serializer/versioning",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/security/podsecuritypolicy/util",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/storage",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/types",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/crypto",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/deployment",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/errors",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/flowcontrol",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/framer",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/hash",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/httpstream",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/httpstream/spdy",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/integer",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/intstr",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/json",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/jsonpath",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/labels",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/net",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/net/sets",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/parsers",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/pod",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/rand",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/replicaset",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/runtime",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/sets",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/slice",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/strategicpatch",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/validation",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/validation/field",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/wait",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/wsstream",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/util/yaml",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/version",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/watch",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/pkg/watch/versioned",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/plugin/pkg/client/auth",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/plugin/pkg/client/auth/gcp",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/plugin/pkg/client/auth/oidc",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/third_party/forked/json",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/third_party/forked/reflect",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/third_party/golang/netutil",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
+ },
+ {
+ "ImportPath": "k8s.io/kubernetes/third_party/golang/template",
+ "Comment": "v1.3.0",
+ "Rev": "283137936a498aed572ee22af6774b6fb6e9fd94"
}
]
}
diff --git a/Godeps/_workspace/src/bitbucket.org/ww/goautoneg/Makefile b/Godeps/_workspace/src/bitbucket.org/ww/goautoneg/Makefile
deleted file mode 100644
index e33ee17303671cec7644a623648642b4f08dc6bd..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/bitbucket.org/ww/goautoneg/Makefile
+++ /dev/null
@@ -1,13 +0,0 @@
-include $(GOROOT)/src/Make.inc
-
-TARG=bitbucket.org/ww/goautoneg
-GOFILES=autoneg.go
-
-include $(GOROOT)/src/Make.pkg
-
-format:
- gofmt -w *.go
-
-docs:
- gomake clean
- godoc ${TARG} > README.txt
diff --git a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/LICENSE.md b/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/LICENSE.md
deleted file mode 100644
index 1cade6cef6a1cb8efdf8549d709a99734c454630..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/LICENSE.md
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Brian Goff
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/md2man.go b/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/md2man.go
deleted file mode 100644
index 8f44fa155064a5518c18fa2cd0a9db687ef9cb43..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/md2man.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package md2man
-
-import (
- "github.com/russross/blackfriday"
-)
-
-func Render(doc []byte) []byte {
- renderer := RoffRenderer(0)
- extensions := 0
- extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
- extensions |= blackfriday.EXTENSION_TABLES
- extensions |= blackfriday.EXTENSION_FENCED_CODE
- extensions |= blackfriday.EXTENSION_AUTOLINK
- extensions |= blackfriday.EXTENSION_SPACE_HEADERS
- extensions |= blackfriday.EXTENSION_FOOTNOTES
- extensions |= blackfriday.EXTENSION_TITLEBLOCK
-
- return blackfriday.Markdown(doc, renderer, extensions)
-}
diff --git a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/roff.go b/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/roff.go
deleted file mode 100644
index 4478786b7b6d80d50a22d35a622090078f4de78e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/cpuguy83/go-md2man/md2man/roff.go
+++ /dev/null
@@ -1,269 +0,0 @@
-package md2man
-
-import (
- "bytes"
- "fmt"
- "html"
- "strings"
-
- "github.com/russross/blackfriday"
-)
-
-type roffRenderer struct{}
-
-func RoffRenderer(flags int) blackfriday.Renderer {
- return &roffRenderer{}
-}
-
-func (r *roffRenderer) GetFlags() int {
- return 0
-}
-
-func (r *roffRenderer) TitleBlock(out *bytes.Buffer, text []byte) {
- out.WriteString(".TH ")
-
- splitText := bytes.Split(text, []byte("\n"))
- for i, line := range splitText {
- line = bytes.TrimPrefix(line, []byte("% "))
- if i == 0 {
- line = bytes.Replace(line, []byte("("), []byte("\" \""), 1)
- line = bytes.Replace(line, []byte(")"), []byte("\" \""), 1)
- }
- line = append([]byte("\""), line...)
- line = append(line, []byte("\" ")...)
- out.Write(line)
- }
-
- out.WriteString(" \"\"\n")
-}
-
-func (r *roffRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string) {
- out.WriteString("\n.PP\n.RS\n\n.nf\n")
- escapeSpecialChars(out, text)
- out.WriteString("\n.fi\n.RE\n")
-}
-
-func (r *roffRenderer) BlockQuote(out *bytes.Buffer, text []byte) {
- out.WriteString("\n.PP\n.RS\n")
- out.Write(text)
- out.WriteString("\n.RE\n")
-}
-
-func (r *roffRenderer) BlockHtml(out *bytes.Buffer, text []byte) {
- out.Write(text)
-}
-
-func (r *roffRenderer) Header(out *bytes.Buffer, text func() bool, level int, id string) {
- marker := out.Len()
-
- switch {
- case marker == 0:
- // This is the doc header
- out.WriteString(".TH ")
- case level == 1:
- out.WriteString("\n\n.SH ")
- case level == 2:
- out.WriteString("\n.SH ")
- default:
- out.WriteString("\n.SS ")
- }
-
- if !text() {
- out.Truncate(marker)
- return
- }
-}
-
-func (r *roffRenderer) HRule(out *bytes.Buffer) {
- out.WriteString("\n.ti 0\n\\l'\\n(.lu'\n")
-}
-
-func (r *roffRenderer) List(out *bytes.Buffer, text func() bool, flags int) {
- marker := out.Len()
- out.WriteString(".IP ")
- if flags&blackfriday.LIST_TYPE_ORDERED != 0 {
- out.WriteString("\\(bu 2")
- } else {
- out.WriteString("\\n+[step" + string(flags) + "]")
- }
- out.WriteString("\n")
- if !text() {
- out.Truncate(marker)
- return
- }
-
-}
-
-func (r *roffRenderer) ListItem(out *bytes.Buffer, text []byte, flags int) {
- out.WriteString("\n\\item ")
- out.Write(text)
-}
-
-func (r *roffRenderer) Paragraph(out *bytes.Buffer, text func() bool) {
- marker := out.Len()
- out.WriteString("\n.PP\n")
- if !text() {
- out.Truncate(marker)
- return
- }
- if marker != 0 {
- out.WriteString("\n")
- }
-}
-
-// TODO: This might now work
-func (r *roffRenderer) Table(out *bytes.Buffer, header []byte, body []byte, columnData []int) {
- out.WriteString(".TS\nallbox;\n")
-
- out.Write(header)
- out.Write(body)
- out.WriteString("\n.TE\n")
-}
-
-func (r *roffRenderer) TableRow(out *bytes.Buffer, text []byte) {
- if out.Len() > 0 {
- out.WriteString("\n")
- }
- out.Write(text)
- out.WriteString("\n")
-}
-
-func (r *roffRenderer) TableHeaderCell(out *bytes.Buffer, text []byte, align int) {
- if out.Len() > 0 {
- out.WriteString(" ")
- }
- out.Write(text)
- out.WriteString(" ")
-}
-
-// TODO: This is probably broken
-func (r *roffRenderer) TableCell(out *bytes.Buffer, text []byte, align int) {
- if out.Len() > 0 {
- out.WriteString("\t")
- }
- out.Write(text)
- out.WriteString("\t")
-}
-
-func (r *roffRenderer) Footnotes(out *bytes.Buffer, text func() bool) {
-
-}
-
-func (r *roffRenderer) FootnoteItem(out *bytes.Buffer, name, text []byte, flags int) {
-
-}
-
-func (r *roffRenderer) AutoLink(out *bytes.Buffer, link []byte, kind int) {
- out.WriteString("\n\\[la]")
- out.Write(link)
- out.WriteString("\\[ra]")
-}
-
-func (r *roffRenderer) CodeSpan(out *bytes.Buffer, text []byte) {
- out.WriteString("\\fB\\fC")
- escapeSpecialChars(out, text)
- out.WriteString("\\fR")
-}
-
-func (r *roffRenderer) DoubleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\fB")
- out.Write(text)
- out.WriteString("\\fP")
-}
-
-func (r *roffRenderer) Emphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\fI")
- out.Write(text)
- out.WriteString("\\fP")
-}
-
-func (r *roffRenderer) Image(out *bytes.Buffer, link []byte, title []byte, alt []byte) {
-}
-
-func (r *roffRenderer) LineBreak(out *bytes.Buffer) {
- out.WriteString("\n.br\n")
-}
-
-func (r *roffRenderer) Link(out *bytes.Buffer, link []byte, title []byte, content []byte) {
- r.AutoLink(out, link, 0)
-}
-
-func (r *roffRenderer) RawHtmlTag(out *bytes.Buffer, tag []byte) {
- out.Write(tag)
-}
-
-func (r *roffRenderer) TripleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\s+2")
- out.Write(text)
- out.WriteString("\\s-2")
-}
-
-func (r *roffRenderer) StrikeThrough(out *bytes.Buffer, text []byte) {
-}
-
-func (r *roffRenderer) FootnoteRef(out *bytes.Buffer, ref []byte, id int) {
-
-}
-
-func (r *roffRenderer) Entity(out *bytes.Buffer, entity []byte) {
- out.WriteString(html.UnescapeString(string(entity)))
-}
-
-func processFooterText(text []byte) []byte {
- text = bytes.TrimPrefix(text, []byte("% "))
- newText := []byte{}
- textArr := strings.Split(string(text), ") ")
-
- for i, w := range textArr {
- if i == 0 {
- w = strings.Replace(w, "(", "\" \"", 1)
- w = fmt.Sprintf("\"%s\"", w)
- } else {
- w = fmt.Sprintf(" \"%s\"", w)
- }
- newText = append(newText, []byte(w)...)
- }
- newText = append(newText, []byte(" \"\"")...)
-
- return newText
-}
-
-func (r *roffRenderer) NormalText(out *bytes.Buffer, text []byte) {
- escapeSpecialChars(out, text)
-}
-
-func (r *roffRenderer) DocumentHeader(out *bytes.Buffer) {
-}
-
-func (r *roffRenderer) DocumentFooter(out *bytes.Buffer) {
-}
-
-func needsBackslash(c byte) bool {
- for _, r := range []byte("-_&\\~") {
- if c == r {
- return true
- }
- }
- return false
-}
-
-func escapeSpecialChars(out *bytes.Buffer, text []byte) {
- for i := 0; i < len(text); i++ {
- // directly copy normal characters
- org := i
-
- for i < len(text) && !needsBackslash(text[i]) {
- i++
- }
- if i > org {
- out.Write(text[org:i])
- }
-
- // escape a character
- if i >= len(text) {
- break
- }
- out.WriteByte('\\')
- out.WriteByte(text[i])
- }
-}
diff --git a/Godeps/_workspace/src/github.com/docker/docker/NOTICE b/Godeps/_workspace/src/github.com/docker/docker/NOTICE
deleted file mode 100644
index 6e6f469ab9b280ff337ae8a074884a2eca44cc8b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/docker/docker/NOTICE
+++ /dev/null
@@ -1,19 +0,0 @@
-Docker
-Copyright 2012-2015 Docker, Inc.
-
-This product includes software developed at Docker, Inc. (https://www.docker.com).
-
-This product contains software (https://github.com/kr/pty) developed
-by Keith Rarick, licensed under the MIT License.
-
-The following is courtesy of our legal counsel:
-
-
-Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.
-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
-
-For more information, please see https://www.bis.doc.gov
-
-See also https://www.apache.org/dev/crypto.html and/or seek legal counsel.
diff --git a/Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/parsers.go b/Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/parsers.go
deleted file mode 100644
index e326a11911818fda485375db0159baa557e16b2e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/docker/docker/pkg/parsers/parsers.go
+++ /dev/null
@@ -1,187 +0,0 @@
-// Package parsers provides helper functions to parse and validate different type
-// of string. It can be hosts, unix addresses, tcp addresses, filters, kernel
-// operating system versions.
-package parsers
-
-import (
- "fmt"
- "net/url"
- "path"
- "runtime"
- "strconv"
- "strings"
-)
-
-// ParseHost parses the specified address and returns an address that will be used as the host.
-// Depending of the address specified, will use the defaultTCPAddr or defaultUnixAddr
-// FIXME: Change this not to receive default value as parameter
-func ParseHost(defaultTCPAddr, defaultUnixAddr, addr string) (string, error) {
- addr = strings.TrimSpace(addr)
- if addr == "" {
- if runtime.GOOS != "windows" {
- addr = fmt.Sprintf("unix://%s", defaultUnixAddr)
- } else {
- // Note - defaultTCPAddr already includes tcp:// prefix
- addr = defaultTCPAddr
- }
- }
- addrParts := strings.Split(addr, "://")
- if len(addrParts) == 1 {
- addrParts = []string{"tcp", addrParts[0]}
- }
-
- switch addrParts[0] {
- case "tcp":
- return ParseTCPAddr(addrParts[1], defaultTCPAddr)
- case "unix":
- return ParseUnixAddr(addrParts[1], defaultUnixAddr)
- case "fd":
- return addr, nil
- default:
- return "", fmt.Errorf("Invalid bind address format: %s", addr)
- }
-}
-
-// ParseUnixAddr parses and validates that the specified address is a valid UNIX
-// socket address. It returns a formatted UNIX socket address, either using the
-// address parsed from addr, or the contents of defaultAddr if addr is a blank
-// string.
-func ParseUnixAddr(addr string, defaultAddr string) (string, error) {
- addr = strings.TrimPrefix(addr, "unix://")
- if strings.Contains(addr, "://") {
- return "", fmt.Errorf("Invalid proto, expected unix: %s", addr)
- }
- if addr == "" {
- addr = defaultAddr
- }
- return fmt.Sprintf("unix://%s", addr), nil
-}
-
-// ParseTCPAddr parses and validates that the specified address is a valid TCP
-// address. It returns a formatted TCP address, either using the address parsed
-// from addr, or the contents of defaultAddr if addr is a blank string.
-func ParseTCPAddr(addr string, defaultAddr string) (string, error) {
- addr = strings.TrimPrefix(addr, "tcp://")
- if strings.Contains(addr, "://") || addr == "" {
- return "", fmt.Errorf("Invalid proto, expected tcp: %s", addr)
- }
-
- u, err := url.Parse("tcp://" + addr)
- if err != nil {
- return "", err
- }
- hostParts := strings.Split(u.Host, ":")
- if len(hostParts) != 2 {
- return "", fmt.Errorf("Invalid bind address format: %s", addr)
- }
- host := hostParts[0]
- if host == "" {
- host = defaultAddr
- }
-
- p, err := strconv.Atoi(hostParts[1])
- if err != nil && p == 0 {
- return "", fmt.Errorf("Invalid bind address format: %s", addr)
- }
- return fmt.Sprintf("tcp://%s:%d%s", host, p, u.Path), nil
-}
-
-// ParseRepositoryTag gets a repos name and returns the right reposName + tag|digest
-// The tag can be confusing because of a port in a repository name.
-// Ex: localhost.localdomain:5000/samalba/hipache:latest
-// Digest ex: localhost:5000/foo/bar@sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb
-func ParseRepositoryTag(repos string) (string, string) {
- n := strings.Index(repos, "@")
- if n >= 0 {
- parts := strings.Split(repos, "@")
- return parts[0], parts[1]
- }
- n = strings.LastIndex(repos, ":")
- if n < 0 {
- return repos, ""
- }
- if tag := repos[n+1:]; !strings.Contains(tag, "/") {
- return repos[:n], tag
- }
- return repos, ""
-}
-
-// PartParser parses and validates the specified string (data) using the specified template
-// e.g. ip:public:private -> 192.168.0.1:80:8000
-func PartParser(template, data string) (map[string]string, error) {
- // ip:public:private
- var (
- templateParts = strings.Split(template, ":")
- parts = strings.Split(data, ":")
- out = make(map[string]string, len(templateParts))
- )
- if len(parts) != len(templateParts) {
- return nil, fmt.Errorf("Invalid format to parse. %s should match template %s", data, template)
- }
-
- for i, t := range templateParts {
- value := ""
- if len(parts) > i {
- value = parts[i]
- }
- out[t] = value
- }
- return out, nil
-}
-
-// ParseKeyValueOpt parses and validates the specified string as a key/value pair (key=value)
-func ParseKeyValueOpt(opt string) (string, string, error) {
- parts := strings.SplitN(opt, "=", 2)
- if len(parts) != 2 {
- return "", "", fmt.Errorf("Unable to parse key/value option: %s", opt)
- }
- return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]), nil
-}
-
-// ParsePortRange parses and validates the specified string as a port-range (8000-9000)
-func ParsePortRange(ports string) (uint64, uint64, error) {
- if ports == "" {
- return 0, 0, fmt.Errorf("Empty string specified for ports.")
- }
- if !strings.Contains(ports, "-") {
- start, err := strconv.ParseUint(ports, 10, 16)
- end := start
- return start, end, err
- }
-
- parts := strings.Split(ports, "-")
- start, err := strconv.ParseUint(parts[0], 10, 16)
- if err != nil {
- return 0, 0, err
- }
- end, err := strconv.ParseUint(parts[1], 10, 16)
- if err != nil {
- return 0, 0, err
- }
- if end < start {
- return 0, 0, fmt.Errorf("Invalid range specified for the Port: %s", ports)
- }
- return start, end, nil
-}
-
-// ParseLink parses and validates the specified string as a link format (name:alias)
-func ParseLink(val string) (string, string, error) {
- if val == "" {
- return "", "", fmt.Errorf("empty string specified for links")
- }
- arr := strings.Split(val, ":")
- if len(arr) > 2 {
- return "", "", fmt.Errorf("bad format for links: %s", val)
- }
- if len(arr) == 1 {
- return val, val, nil
- }
- // This is kept because we can actually get an HostConfig with links
- // from an already created container and the format is not `foo:bar`
- // but `/foo:/c1/bar`
- if strings.HasPrefix(arr[0], "/") {
- _, alias := path.Split(arr[1])
- return arr[0][1:], alias, nil
- }
- return arr[0], arr[1], nil
-}
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/README.md b/Godeps/_workspace/src/github.com/docker/go-units/README.md
deleted file mode 100644
index 3ce4d79daca6d4c6123a16c0d4e78b1ffb8a4d69..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/docker/go-units/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-[](https://godoc.org/github.com/docker/go-units)
-
-# Introduction
-
-go-units is a library to transform human friendly measurements into machine friendly values.
-
-## Usage
-
-See the [docs in godoc](https://godoc.org/github.com/docker/go-units) for examples and documentation.
-
-## Copyright and license
-
-Copyright © 2015 Docker, Inc. All rights reserved, except as follows. Code
-is released under the Apache 2.0 license. The README.md file, and files in the
-"docs" folder are licensed under the Creative Commons Attribution 4.0
-International License under the terms and conditions set forth in the file
-"LICENSE.docs". You may obtain a duplicate copy of the same license, titled
-CC-BY-SA-4.0, at http://creativecommons.org/licenses/by/4.0/.
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/MAINTAINERS b/Godeps/_workspace/src/github.com/docker/spdystream/MAINTAINERS
deleted file mode 100644
index 4eb44dcf4374d8d5c31ed0672eecd516044fd94d..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/docker/spdystream/MAINTAINERS
+++ /dev/null
@@ -1 +0,0 @@
-Derek McGowan <derek@docker.com> (@dmcg)
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/NOTICE b/Godeps/_workspace/src/github.com/opencontainers/runc/NOTICE
deleted file mode 100644
index 5c97abce4b9d461afe36ffcc9fc1a91ae98aa72c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/opencontainers/runc/NOTICE
+++ /dev/null
@@ -1,17 +0,0 @@
-runc
-
-Copyright 2012-2015 Docker, Inc.
-
-This product includes software developed at Docker, Inc. (http://www.docker.com).
-
-The following is courtesy of our legal counsel:
-
-
-Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.
-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
-
-For more information, please see http://www.bis.doc.gov
-
-See also http://www.apache.org/dev/crypto.html and/or seek legal counsel.
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/README.md b/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/README.md
deleted file mode 100644
index 81032bed886bda5311be18ff05898ff219998cfc..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/README.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# Overview
-This is the [Prometheus](http://www.prometheus.io) telemetric
-instrumentation client [Go](http://golang.org) client library. It
-enable authors to define process-space metrics for their servers and
-expose them through a web service interface for extraction,
-aggregation, and a whole slew of other post processing techniques.
-
-# Installing
- $ go get github.com/prometheus/client_golang/prometheus
-
-# Example
-```go
-package main
-
-import (
- "net/http"
-
- "github.com/prometheus/client_golang/prometheus"
-)
-
-var (
- indexed = prometheus.NewCounter(prometheus.CounterOpts{
- Namespace: "my_company",
- Subsystem: "indexer",
- Name: "documents_indexed",
- Help: "The number of documents indexed.",
- })
- size = prometheus.NewGauge(prometheus.GaugeOpts{
- Namespace: "my_company",
- Subsystem: "storage",
- Name: "documents_total_size_bytes",
- Help: "The total size of all documents in the storage.",
- })
-)
-
-func main() {
- http.Handle("/metrics", prometheus.Handler())
-
- indexed.Inc()
- size.Set(5)
-
- http.ListenAndServe(":8080", nil)
-}
-
-func init() {
- prometheus.MustRegister(indexed)
- prometheus.MustRegister(size)
-}
-```
-
-# Documentation
-
-[](https://godoc.org/github.com/prometheus/client_golang)
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/doc.go b/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/doc.go
deleted file mode 100644
index 425fe8793cd82710aa7034734835a7aaab3974ca..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/doc.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2014 The Prometheus 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 prometheus provides embeddable metric primitives for servers and
-// standardized exposition of telemetry through a web services interface.
-//
-// All exported functions and methods are safe to be used concurrently unless
-// specified otherwise.
-//
-// To expose metrics registered with the Prometheus registry, an HTTP server
-// needs to know about the Prometheus handler. The usual endpoint is "/metrics".
-//
-// http.Handle("/metrics", prometheus.Handler())
-//
-// As a starting point a very basic usage example:
-//
-// package main
-//
-// import (
-// "net/http"
-//
-// "github.com/prometheus/client_golang/prometheus"
-// )
-//
-// var (
-// cpuTemp = prometheus.NewGauge(prometheus.GaugeOpts{
-// Name: "cpu_temperature_celsius",
-// Help: "Current temperature of the CPU.",
-// })
-// hdFailures = prometheus.NewCounter(prometheus.CounterOpts{
-// Name: "hd_errors_total",
-// Help: "Number of hard-disk errors.",
-// })
-// )
-//
-// func init() {
-// prometheus.MustRegister(cpuTemp)
-// prometheus.MustRegister(hdFailures)
-// }
-//
-// func main() {
-// cpuTemp.Set(65.3)
-// hdFailures.Inc()
-//
-// http.Handle("/metrics", prometheus.Handler())
-// http.ListenAndServe(":8080", nil)
-// }
-//
-//
-// This is a complete program that exports two metrics, a Gauge and a Counter.
-// It also exports some stats about the HTTP usage of the /metrics
-// endpoint. (See the Handler function for more detail.)
-//
-// Two more advanced metric types are the Summary and Histogram.
-//
-// In addition to the fundamental metric types Gauge, Counter, Summary, and
-// Histogram, a very important part of the Prometheus data model is the
-// partitioning of samples along dimensions called labels, which results in
-// metric vectors. The fundamental types are GaugeVec, CounterVec, SummaryVec,
-// and HistogramVec.
-//
-// Those are all the parts needed for basic usage. Detailed documentation and
-// examples are provided below.
-//
-// Everything else this package offers is essentially for "power users" only. A
-// few pointers to "power user features":
-//
-// All the various ...Opts structs have a ConstLabels field for labels that
-// never change their value (which is only useful under special circumstances,
-// see documentation of the Opts type).
-//
-// The Untyped metric behaves like a Gauge, but signals the Prometheus server
-// not to assume anything about its type.
-//
-// Functions to fine-tune how the metric registry works: EnableCollectChecks,
-// PanicOnCollectError, Register, Unregister, SetMetricFamilyInjectionHook.
-//
-// For custom metric collection, there are two entry points: Custom Metric
-// implementations and custom Collector implementations. A Metric is the
-// fundamental unit in the Prometheus data model: a sample at a point in time
-// together with its meta-data (like its fully-qualified name and any number of
-// pairs of label name and label value) that knows how to marshal itself into a
-// data transfer object (aka DTO, implemented as a protocol buffer). A Collector
-// gets registered with the Prometheus registry and manages the collection of
-// one or more Metrics. Many parts of this package are building blocks for
-// Metrics and Collectors. Desc is the metric descriptor, actually used by all
-// metrics under the hood, and by Collectors to describe the Metrics to be
-// collected, but only to be dealt with by users if they implement their own
-// Metrics or Collectors. To create a Desc, the BuildFQName function will come
-// in handy. Other useful components for Metric and Collector implementation
-// include: LabelPairSorter to sort the DTO version of label pairs,
-// NewConstMetric and MustNewConstMetric to create "throw away" Metrics at
-// collection time, MetricVec to bundle custom Metrics into a metric vector
-// Collector, SelfCollector to make a custom Metric collect itself.
-//
-// A good example for a custom Collector is the ExpVarCollector included in this
-// package, which exports variables exported via the "expvar" package as
-// Prometheus metrics.
-package prometheus
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/go_collector.go b/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/go_collector.go
deleted file mode 100644
index 85fa20be4559574fad9c392f03723e2eaed2d322..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/go_collector.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package prometheus
-
-import (
- "runtime"
- "runtime/debug"
- "time"
-)
-
-type goCollector struct {
- goroutines Gauge
- gcDesc *Desc
-}
-
-// NewGoCollector returns a collector which exports metrics about the current
-// go process.
-func NewGoCollector() *goCollector {
- return &goCollector{
- goroutines: NewGauge(GaugeOpts{
- Name: "go_goroutines",
- Help: "Number of goroutines that currently exist.",
- }),
- gcDesc: NewDesc(
- "go_gc_duration_seconds",
- "A summary of the GC invocation durations.",
- nil, nil),
- }
-}
-
-// Describe returns all descriptions of the collector.
-func (c *goCollector) Describe(ch chan<- *Desc) {
- ch <- c.goroutines.Desc()
- ch <- c.gcDesc
-}
-
-// Collect returns the current state of all metrics of the collector.
-func (c *goCollector) Collect(ch chan<- Metric) {
- c.goroutines.Set(float64(runtime.NumGoroutine()))
- ch <- c.goroutines
-
- var stats debug.GCStats
- stats.PauseQuantiles = make([]time.Duration, 5)
- debug.ReadGCStats(&stats)
-
- quantiles := make(map[float64]float64)
- for idx, pq := range stats.PauseQuantiles[1:] {
- quantiles[float64(idx+1)/float64(len(stats.PauseQuantiles)-1)] = pq.Seconds()
- }
- quantiles[0.0] = stats.PauseQuantiles[0].Seconds()
- ch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), float64(stats.PauseTotal.Seconds()), quantiles)
-}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/push.go b/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/push.go
deleted file mode 100644
index 1c33848a3538369f0e11618804dc9eb77135c2d2..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/push.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2015 The Prometheus 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.
-
-// Copyright (c) 2013, The Prometheus Authors
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be found
-// in the LICENSE file.
-
-package prometheus
-
-// Push triggers a metric collection by the default registry and pushes all
-// collected metrics to the Pushgateway specified by addr. See the Pushgateway
-// documentation for detailed implications of the job and instance
-// parameter. instance can be left empty. You can use just host:port or ip:port
-// as url, in which case 'http://' is added automatically. You can also include
-// the schema in the URL. However, do not include the '/metrics/jobs/...' part.
-//
-// Note that all previously pushed metrics with the same job and instance will
-// be replaced with the metrics pushed by this call. (It uses HTTP method 'PUT'
-// to push to the Pushgateway.)
-func Push(job, instance, url string) error {
- return defRegistry.Push(job, instance, url, "PUT")
-}
-
-// PushAdd works like Push, but only previously pushed metrics with the same
-// name (and the same job and instance) will be replaced. (It uses HTTP method
-// 'POST' to push to the Pushgateway.)
-func PushAdd(job, instance, url string) error {
- return defRegistry.Push(job, instance, url, "POST")
-}
-
-// PushCollectors works like Push, but it does not collect from the default
-// registry. Instead, it collects from the provided collectors. It is a
-// convenient way to push only a few metrics.
-func PushCollectors(job, instance, url string, collectors ...Collector) error {
- return pushCollectors(job, instance, url, "PUT", collectors...)
-}
-
-// PushAddCollectors works like PushAdd, but it does not collect from the
-// default registry. Instead, it collects from the provided collectors. It is a
-// convenient way to push only a few metrics.
-func PushAddCollectors(job, instance, url string, collectors ...Collector) error {
- return pushCollectors(job, instance, url, "POST", collectors...)
-}
-
-func pushCollectors(job, instance, url, method string, collectors ...Collector) error {
- r := newRegistry()
- for _, collector := range collectors {
- if _, err := r.Register(collector); err != nil {
- return err
- }
- }
- return r.Push(job, instance, url, method)
-}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/registry.go b/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/registry.go
deleted file mode 100644
index 5970aaeeba95278fd8f85140fe6e74800e756373..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/registry.go
+++ /dev/null
@@ -1,726 +0,0 @@
-// Copyright 2014 The Prometheus 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.
-
-// Copyright (c) 2013, The Prometheus Authors
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be found
-// in the LICENSE file.
-
-package prometheus
-
-import (
- "bytes"
- "compress/gzip"
- "errors"
- "fmt"
- "hash/fnv"
- "io"
- "net/http"
- "net/url"
- "os"
- "sort"
- "strings"
- "sync"
-
- "github.com/golang/protobuf/proto"
- "github.com/prometheus/common/expfmt"
-
- dto "github.com/prometheus/client_model/go"
-)
-
-var (
- defRegistry = newDefaultRegistry()
- errAlreadyReg = errors.New("duplicate metrics collector registration attempted")
-)
-
-// Constants relevant to the HTTP interface.
-const (
- // APIVersion is the version of the format of the exported data. This
- // will match this library's version, which subscribes to the Semantic
- // Versioning scheme.
- APIVersion = "0.0.4"
-
- // DelimitedTelemetryContentType is the content type set on telemetry
- // data responses in delimited protobuf format.
- DelimitedTelemetryContentType = `application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited`
- // TextTelemetryContentType is the content type set on telemetry data
- // responses in text format.
- TextTelemetryContentType = `text/plain; version=` + APIVersion
- // ProtoTextTelemetryContentType is the content type set on telemetry
- // data responses in protobuf text format. (Only used for debugging.)
- ProtoTextTelemetryContentType = `application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=text`
- // ProtoCompactTextTelemetryContentType is the content type set on
- // telemetry data responses in protobuf compact text format. (Only used
- // for debugging.)
- ProtoCompactTextTelemetryContentType = `application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text`
-
- // Constants for object pools.
- numBufs = 4
- numMetricFamilies = 1000
- numMetrics = 10000
-
- // Capacity for the channel to collect metrics and descriptors.
- capMetricChan = 1000
- capDescChan = 10
-
- contentTypeHeader = "Content-Type"
- contentLengthHeader = "Content-Length"
- contentEncodingHeader = "Content-Encoding"
-
- acceptEncodingHeader = "Accept-Encoding"
- acceptHeader = "Accept"
-)
-
-// Handler returns the HTTP handler for the global Prometheus registry. It is
-// already instrumented with InstrumentHandler (using "prometheus" as handler
-// name). Usually the handler is used to handle the "/metrics" endpoint.
-func Handler() http.Handler {
- return InstrumentHandler("prometheus", defRegistry)
-}
-
-// UninstrumentedHandler works in the same way as Handler, but the returned HTTP
-// handler is not instrumented. This is useful if no instrumentation is desired
-// (for whatever reason) or if the instrumentation has to happen with a
-// different handler name (or with a different instrumentation approach
-// altogether). See the InstrumentHandler example.
-func UninstrumentedHandler() http.Handler {
- return defRegistry
-}
-
-// Register registers a new Collector to be included in metrics collection. It
-// returns an error if the descriptors provided by the Collector are invalid or
-// if they - in combination with descriptors of already registered Collectors -
-// do not fulfill the consistency and uniqueness criteria described in the Desc
-// documentation.
-//
-// Do not register the same Collector multiple times concurrently. (Registering
-// the same Collector twice would result in an error anyway, but on top of that,
-// it is not safe to do so concurrently.)
-func Register(m Collector) error {
- _, err := defRegistry.Register(m)
- return err
-}
-
-// MustRegister works like Register but panics where Register would have
-// returned an error.
-func MustRegister(m Collector) {
- err := Register(m)
- if err != nil {
- panic(err)
- }
-}
-
-// RegisterOrGet works like Register but does not return an error if a Collector
-// is registered that equals a previously registered Collector. (Two Collectors
-// are considered equal if their Describe method yields the same set of
-// descriptors.) Instead, the previously registered Collector is returned (which
-// is helpful if the new and previously registered Collectors are equal but not
-// identical, i.e. not pointers to the same object).
-//
-// As for Register, it is still not safe to call RegisterOrGet with the same
-// Collector multiple times concurrently.
-func RegisterOrGet(m Collector) (Collector, error) {
- return defRegistry.RegisterOrGet(m)
-}
-
-// MustRegisterOrGet works like Register but panics where RegisterOrGet would
-// have returned an error.
-func MustRegisterOrGet(m Collector) Collector {
- existing, err := RegisterOrGet(m)
- if err != nil {
- panic(err)
- }
- return existing
-}
-
-// Unregister unregisters the Collector that equals the Collector passed in as
-// an argument. (Two Collectors are considered equal if their Describe method
-// yields the same set of descriptors.) The function returns whether a Collector
-// was unregistered.
-func Unregister(c Collector) bool {
- return defRegistry.Unregister(c)
-}
-
-// SetMetricFamilyInjectionHook sets a function that is called whenever metrics
-// are collected. The hook function must be set before metrics collection begins
-// (i.e. call SetMetricFamilyInjectionHook before setting the HTTP handler.) The
-// MetricFamily protobufs returned by the hook function are merged with the
-// metrics collected in the usual way.
-//
-// This is a way to directly inject MetricFamily protobufs managed and owned by
-// the caller. The caller has full responsibility. As no registration of the
-// injected metrics has happened, there is no descriptor to check against, and
-// there are no registration-time checks. If collect-time checks are disabled
-// (see function EnableCollectChecks), no sanity checks are performed on the
-// returned protobufs at all. If collect-checks are enabled, type and uniqueness
-// checks are performed, but no further consistency checks (which would require
-// knowledge of a metric descriptor).
-//
-// Sorting concerns: The caller is responsible for sorting the label pairs in
-// each metric. However, the order of metrics will be sorted by the registry as
-// it is required anyway after merging with the metric families collected
-// conventionally.
-//
-// The function must be callable at any time and concurrently.
-func SetMetricFamilyInjectionHook(hook func() []*dto.MetricFamily) {
- defRegistry.metricFamilyInjectionHook = hook
-}
-
-// PanicOnCollectError sets the behavior whether a panic is caused upon an error
-// while metrics are collected and served to the HTTP endpoint. By default, an
-// internal server error (status code 500) is served with an error message.
-func PanicOnCollectError(b bool) {
- defRegistry.panicOnCollectError = b
-}
-
-// EnableCollectChecks enables (or disables) additional consistency checks
-// during metrics collection. These additional checks are not enabled by default
-// because they inflict a performance penalty and the errors they check for can
-// only happen if the used Metric and Collector types have internal programming
-// errors. It can be helpful to enable these checks while working with custom
-// Collectors or Metrics whose correctness is not well established yet.
-func EnableCollectChecks(b bool) {
- defRegistry.collectChecksEnabled = b
-}
-
-// encoder is a function that writes a dto.MetricFamily to an io.Writer in a
-// certain encoding. It returns the number of bytes written and any error
-// encountered. Note that pbutil.WriteDelimited and pbutil.MetricFamilyToText
-// are encoders.
-type encoder func(io.Writer, *dto.MetricFamily) (int, error)
-
-type registry struct {
- mtx sync.RWMutex
- collectorsByID map[uint64]Collector // ID is a hash of the descIDs.
- descIDs map[uint64]struct{}
- dimHashesByName map[string]uint64
- bufPool chan *bytes.Buffer
- metricFamilyPool chan *dto.MetricFamily
- metricPool chan *dto.Metric
- metricFamilyInjectionHook func() []*dto.MetricFamily
-
- panicOnCollectError, collectChecksEnabled bool
-}
-
-func (r *registry) Register(c Collector) (Collector, error) {
- descChan := make(chan *Desc, capDescChan)
- go func() {
- c.Describe(descChan)
- close(descChan)
- }()
-
- newDescIDs := map[uint64]struct{}{}
- newDimHashesByName := map[string]uint64{}
- var collectorID uint64 // Just a sum of all desc IDs.
- var duplicateDescErr error
-
- r.mtx.Lock()
- defer r.mtx.Unlock()
- // Coduct various tests...
- for desc := range descChan {
-
- // Is the descriptor valid at all?
- if desc.err != nil {
- return c, fmt.Errorf("descriptor %s is invalid: %s", desc, desc.err)
- }
-
- // Is the descID unique?
- // (In other words: Is the fqName + constLabel combination unique?)
- if _, exists := r.descIDs[desc.id]; exists {
- duplicateDescErr = fmt.Errorf("descriptor %s already exists with the same fully-qualified name and const label values", desc)
- }
- // If it is not a duplicate desc in this collector, add it to
- // the collectorID. (We allow duplicate descs within the same
- // collector, but their existence must be a no-op.)
- if _, exists := newDescIDs[desc.id]; !exists {
- newDescIDs[desc.id] = struct{}{}
- collectorID += desc.id
- }
-
- // Are all the label names and the help string consistent with
- // previous descriptors of the same name?
- // First check existing descriptors...
- if dimHash, exists := r.dimHashesByName[desc.fqName]; exists {
- if dimHash != desc.dimHash {
- return nil, fmt.Errorf("a previously registered descriptor with the same fully-qualified name as %s has different label names or a different help string", desc)
- }
- } else {
- // ...then check the new descriptors already seen.
- if dimHash, exists := newDimHashesByName[desc.fqName]; exists {
- if dimHash != desc.dimHash {
- return nil, fmt.Errorf("descriptors reported by collector have inconsistent label names or help strings for the same fully-qualified name, offender is %s", desc)
- }
- } else {
- newDimHashesByName[desc.fqName] = desc.dimHash
- }
- }
- }
- // Did anything happen at all?
- if len(newDescIDs) == 0 {
- return nil, errors.New("collector has no descriptors")
- }
- if existing, exists := r.collectorsByID[collectorID]; exists {
- return existing, errAlreadyReg
- }
- // If the collectorID is new, but at least one of the descs existed
- // before, we are in trouble.
- if duplicateDescErr != nil {
- return nil, duplicateDescErr
- }
-
- // Only after all tests have passed, actually register.
- r.collectorsByID[collectorID] = c
- for hash := range newDescIDs {
- r.descIDs[hash] = struct{}{}
- }
- for name, dimHash := range newDimHashesByName {
- r.dimHashesByName[name] = dimHash
- }
- return c, nil
-}
-
-func (r *registry) RegisterOrGet(m Collector) (Collector, error) {
- existing, err := r.Register(m)
- if err != nil && err != errAlreadyReg {
- return nil, err
- }
- return existing, nil
-}
-
-func (r *registry) Unregister(c Collector) bool {
- descChan := make(chan *Desc, capDescChan)
- go func() {
- c.Describe(descChan)
- close(descChan)
- }()
-
- descIDs := map[uint64]struct{}{}
- var collectorID uint64 // Just a sum of the desc IDs.
- for desc := range descChan {
- if _, exists := descIDs[desc.id]; !exists {
- collectorID += desc.id
- descIDs[desc.id] = struct{}{}
- }
- }
-
- r.mtx.RLock()
- if _, exists := r.collectorsByID[collectorID]; !exists {
- r.mtx.RUnlock()
- return false
- }
- r.mtx.RUnlock()
-
- r.mtx.Lock()
- defer r.mtx.Unlock()
-
- delete(r.collectorsByID, collectorID)
- for id := range descIDs {
- delete(r.descIDs, id)
- }
- // dimHashesByName is left untouched as those must be consistent
- // throughout the lifetime of a program.
- return true
-}
-
-func (r *registry) Push(job, instance, pushURL, method string) error {
- if !strings.Contains(pushURL, "://") {
- pushURL = "http://" + pushURL
- }
- pushURL = fmt.Sprintf("%s/metrics/jobs/%s", pushURL, url.QueryEscape(job))
- if instance != "" {
- pushURL += "/instances/" + url.QueryEscape(instance)
- }
- buf := r.getBuf()
- defer r.giveBuf(buf)
- if err := r.writePB(expfmt.NewEncoder(buf, expfmt.FmtProtoDelim)); err != nil {
- if r.panicOnCollectError {
- panic(err)
- }
- return err
- }
- req, err := http.NewRequest(method, pushURL, buf)
- if err != nil {
- return err
- }
- req.Header.Set(contentTypeHeader, DelimitedTelemetryContentType)
- resp, err := http.DefaultClient.Do(req)
- if err != nil {
- return err
- }
- defer resp.Body.Close()
- if resp.StatusCode != 202 {
- return fmt.Errorf("unexpected status code %d while pushing to %s", resp.StatusCode, pushURL)
- }
- return nil
-}
-
-func (r *registry) ServeHTTP(w http.ResponseWriter, req *http.Request) {
- contentType := expfmt.Negotiate(req.Header)
- buf := r.getBuf()
- defer r.giveBuf(buf)
- writer, encoding := decorateWriter(req, buf)
- if err := r.writePB(expfmt.NewEncoder(writer, contentType)); err != nil {
- if r.panicOnCollectError {
- panic(err)
- }
- http.Error(w, "An error has occurred:\n\n"+err.Error(), http.StatusInternalServerError)
- return
- }
- if closer, ok := writer.(io.Closer); ok {
- closer.Close()
- }
- header := w.Header()
- header.Set(contentTypeHeader, string(contentType))
- header.Set(contentLengthHeader, fmt.Sprint(buf.Len()))
- if encoding != "" {
- header.Set(contentEncodingHeader, encoding)
- }
- w.Write(buf.Bytes())
-}
-
-func (r *registry) writePB(encoder expfmt.Encoder) error {
- var metricHashes map[uint64]struct{}
- if r.collectChecksEnabled {
- metricHashes = make(map[uint64]struct{})
- }
- metricChan := make(chan Metric, capMetricChan)
- wg := sync.WaitGroup{}
-
- r.mtx.RLock()
- metricFamiliesByName := make(map[string]*dto.MetricFamily, len(r.dimHashesByName))
-
- // Scatter.
- // (Collectors could be complex and slow, so we call them all at once.)
- wg.Add(len(r.collectorsByID))
- go func() {
- wg.Wait()
- close(metricChan)
- }()
- for _, collector := range r.collectorsByID {
- go func(collector Collector) {
- defer wg.Done()
- collector.Collect(metricChan)
- }(collector)
- }
- r.mtx.RUnlock()
-
- // Drain metricChan in case of premature return.
- defer func() {
- for _ = range metricChan {
- }
- }()
-
- // Gather.
- for metric := range metricChan {
- // This could be done concurrently, too, but it required locking
- // of metricFamiliesByName (and of metricHashes if checks are
- // enabled). Most likely not worth it.
- desc := metric.Desc()
- metricFamily, ok := metricFamiliesByName[desc.fqName]
- if !ok {
- metricFamily = r.getMetricFamily()
- defer r.giveMetricFamily(metricFamily)
- metricFamily.Name = proto.String(desc.fqName)
- metricFamily.Help = proto.String(desc.help)
- metricFamiliesByName[desc.fqName] = metricFamily
- }
- dtoMetric := r.getMetric()
- defer r.giveMetric(dtoMetric)
- if err := metric.Write(dtoMetric); err != nil {
- // TODO: Consider different means of error reporting so
- // that a single erroneous metric could be skipped
- // instead of blowing up the whole collection.
- return fmt.Errorf("error collecting metric %v: %s", desc, err)
- }
- switch {
- case metricFamily.Type != nil:
- // Type already set. We are good.
- case dtoMetric.Gauge != nil:
- metricFamily.Type = dto.MetricType_GAUGE.Enum()
- case dtoMetric.Counter != nil:
- metricFamily.Type = dto.MetricType_COUNTER.Enum()
- case dtoMetric.Summary != nil:
- metricFamily.Type = dto.MetricType_SUMMARY.Enum()
- case dtoMetric.Untyped != nil:
- metricFamily.Type = dto.MetricType_UNTYPED.Enum()
- case dtoMetric.Histogram != nil:
- metricFamily.Type = dto.MetricType_HISTOGRAM.Enum()
- default:
- return fmt.Errorf("empty metric collected: %s", dtoMetric)
- }
- if r.collectChecksEnabled {
- if err := r.checkConsistency(metricFamily, dtoMetric, desc, metricHashes); err != nil {
- return err
- }
- }
- metricFamily.Metric = append(metricFamily.Metric, dtoMetric)
- }
-
- if r.metricFamilyInjectionHook != nil {
- for _, mf := range r.metricFamilyInjectionHook() {
- existingMF, exists := metricFamiliesByName[mf.GetName()]
- if !exists {
- metricFamiliesByName[mf.GetName()] = mf
- if r.collectChecksEnabled {
- for _, m := range mf.Metric {
- if err := r.checkConsistency(mf, m, nil, metricHashes); err != nil {
- return err
- }
- }
- }
- continue
- }
- for _, m := range mf.Metric {
- if r.collectChecksEnabled {
- if err := r.checkConsistency(existingMF, m, nil, metricHashes); err != nil {
- return err
- }
- }
- existingMF.Metric = append(existingMF.Metric, m)
- }
- }
- }
-
- // Now that MetricFamilies are all set, sort their Metrics
- // lexicographically by their label values.
- for _, mf := range metricFamiliesByName {
- sort.Sort(metricSorter(mf.Metric))
- }
-
- // Write out MetricFamilies sorted by their name.
- names := make([]string, 0, len(metricFamiliesByName))
- for name := range metricFamiliesByName {
- names = append(names, name)
- }
- sort.Strings(names)
-
- for _, name := range names {
- if err := encoder.Encode(metricFamiliesByName[name]); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *dto.Metric, desc *Desc, metricHashes map[uint64]struct{}) error {
-
- // Type consistency with metric family.
- if metricFamily.GetType() == dto.MetricType_GAUGE && dtoMetric.Gauge == nil ||
- metricFamily.GetType() == dto.MetricType_COUNTER && dtoMetric.Counter == nil ||
- metricFamily.GetType() == dto.MetricType_SUMMARY && dtoMetric.Summary == nil ||
- metricFamily.GetType() == dto.MetricType_HISTOGRAM && dtoMetric.Histogram == nil ||
- metricFamily.GetType() == dto.MetricType_UNTYPED && dtoMetric.Untyped == nil {
- return fmt.Errorf(
- "collected metric %s %s is not a %s",
- metricFamily.GetName(), dtoMetric, metricFamily.GetType(),
- )
- }
-
- // Is the metric unique (i.e. no other metric with the same name and the same label values)?
- h := fnv.New64a()
- var buf bytes.Buffer
- buf.WriteString(metricFamily.GetName())
- buf.WriteByte(separatorByte)
- h.Write(buf.Bytes())
- // Make sure label pairs are sorted. We depend on it for the consistency
- // check. Label pairs must be sorted by contract. But the point of this
- // method is to check for contract violations. So we better do the sort
- // now.
- sort.Sort(LabelPairSorter(dtoMetric.Label))
- for _, lp := range dtoMetric.Label {
- buf.Reset()
- buf.WriteString(lp.GetValue())
- buf.WriteByte(separatorByte)
- h.Write(buf.Bytes())
- }
- metricHash := h.Sum64()
- if _, exists := metricHashes[metricHash]; exists {
- return fmt.Errorf(
- "collected metric %s %s was collected before with the same name and label values",
- metricFamily.GetName(), dtoMetric,
- )
- }
- metricHashes[metricHash] = struct{}{}
-
- if desc == nil {
- return nil // Nothing left to check if we have no desc.
- }
-
- // Desc consistency with metric family.
- if metricFamily.GetName() != desc.fqName {
- return fmt.Errorf(
- "collected metric %s %s has name %q but should have %q",
- metricFamily.GetName(), dtoMetric, metricFamily.GetName(), desc.fqName,
- )
- }
- if metricFamily.GetHelp() != desc.help {
- return fmt.Errorf(
- "collected metric %s %s has help %q but should have %q",
- metricFamily.GetName(), dtoMetric, metricFamily.GetHelp(), desc.help,
- )
- }
-
- // Is the desc consistent with the content of the metric?
- lpsFromDesc := make([]*dto.LabelPair, 0, len(dtoMetric.Label))
- lpsFromDesc = append(lpsFromDesc, desc.constLabelPairs...)
- for _, l := range desc.variableLabels {
- lpsFromDesc = append(lpsFromDesc, &dto.LabelPair{
- Name: proto.String(l),
- })
- }
- if len(lpsFromDesc) != len(dtoMetric.Label) {
- return fmt.Errorf(
- "labels in collected metric %s %s are inconsistent with descriptor %s",
- metricFamily.GetName(), dtoMetric, desc,
- )
- }
- sort.Sort(LabelPairSorter(lpsFromDesc))
- for i, lpFromDesc := range lpsFromDesc {
- lpFromMetric := dtoMetric.Label[i]
- if lpFromDesc.GetName() != lpFromMetric.GetName() ||
- lpFromDesc.Value != nil && lpFromDesc.GetValue() != lpFromMetric.GetValue() {
- return fmt.Errorf(
- "labels in collected metric %s %s are inconsistent with descriptor %s",
- metricFamily.GetName(), dtoMetric, desc,
- )
- }
- }
-
- r.mtx.RLock() // Remaining checks need the read lock.
- defer r.mtx.RUnlock()
-
- // Is the desc registered?
- if _, exist := r.descIDs[desc.id]; !exist {
- return fmt.Errorf(
- "collected metric %s %s with unregistered descriptor %s",
- metricFamily.GetName(), dtoMetric, desc,
- )
- }
-
- return nil
-}
-
-func (r *registry) getBuf() *bytes.Buffer {
- select {
- case buf := <-r.bufPool:
- return buf
- default:
- return &bytes.Buffer{}
- }
-}
-
-func (r *registry) giveBuf(buf *bytes.Buffer) {
- buf.Reset()
- select {
- case r.bufPool <- buf:
- default:
- }
-}
-
-func (r *registry) getMetricFamily() *dto.MetricFamily {
- select {
- case mf := <-r.metricFamilyPool:
- return mf
- default:
- return &dto.MetricFamily{}
- }
-}
-
-func (r *registry) giveMetricFamily(mf *dto.MetricFamily) {
- mf.Reset()
- select {
- case r.metricFamilyPool <- mf:
- default:
- }
-}
-
-func (r *registry) getMetric() *dto.Metric {
- select {
- case m := <-r.metricPool:
- return m
- default:
- return &dto.Metric{}
- }
-}
-
-func (r *registry) giveMetric(m *dto.Metric) {
- m.Reset()
- select {
- case r.metricPool <- m:
- default:
- }
-}
-
-func newRegistry() *registry {
- return ®istry{
- collectorsByID: map[uint64]Collector{},
- descIDs: map[uint64]struct{}{},
- dimHashesByName: map[string]uint64{},
- bufPool: make(chan *bytes.Buffer, numBufs),
- metricFamilyPool: make(chan *dto.MetricFamily, numMetricFamilies),
- metricPool: make(chan *dto.Metric, numMetrics),
- }
-}
-
-func newDefaultRegistry() *registry {
- r := newRegistry()
- r.Register(NewProcessCollector(os.Getpid(), ""))
- r.Register(NewGoCollector())
- return r
-}
-
-// decorateWriter wraps a writer to handle gzip compression if requested. It
-// returns the decorated writer and the appropriate "Content-Encoding" header
-// (which is empty if no compression is enabled).
-func decorateWriter(request *http.Request, writer io.Writer) (io.Writer, string) {
- header := request.Header.Get(acceptEncodingHeader)
- parts := strings.Split(header, ",")
- for _, part := range parts {
- part := strings.TrimSpace(part)
- if part == "gzip" || strings.HasPrefix(part, "gzip;") {
- return gzip.NewWriter(writer), "gzip"
- }
- }
- return writer, ""
-}
-
-type metricSorter []*dto.Metric
-
-func (s metricSorter) Len() int {
- return len(s)
-}
-
-func (s metricSorter) Swap(i, j int) {
- s[i], s[j] = s[j], s[i]
-}
-
-func (s metricSorter) Less(i, j int) bool {
- if len(s[i].Label) != len(s[j].Label) {
- // This should not happen. The metrics are
- // inconsistent. However, we have to deal with the fact, as
- // people might use custom collectors or metric family injection
- // to create inconsistent metrics. So let's simply compare the
- // number of labels in this case. That will still yield
- // reproducible sorting.
- return len(s[i].Label) < len(s[j].Label)
- }
- for n, lp := range s[i].Label {
- vi := lp.GetValue()
- vj := s[j].Label[n].GetValue()
- if vi != vj {
- return vi < vj
- }
- }
- return true
-}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/json_decode.go b/Godeps/_workspace/src/github.com/prometheus/common/expfmt/json_decode.go
deleted file mode 100644
index 67e3a0d4d65e80b3977b41dcae82d805546b7155..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/json_decode.go
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright 2015 The Prometheus 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 expfmt
-
-import (
- "encoding/json"
- "fmt"
- "io"
- "sort"
-
- "github.com/golang/protobuf/proto"
- dto "github.com/prometheus/client_model/go"
-
- "github.com/prometheus/common/model"
-)
-
-type json2Decoder struct {
- dec *json.Decoder
- fams []*dto.MetricFamily
-}
-
-func newJSON2Decoder(r io.Reader) Decoder {
- return &json2Decoder{
- dec: json.NewDecoder(r),
- }
-}
-
-type histogram002 struct {
- Labels model.LabelSet `json:"labels"`
- Values map[string]float64 `json:"value"`
-}
-
-type counter002 struct {
- Labels model.LabelSet `json:"labels"`
- Value float64 `json:"value"`
-}
-
-func protoLabelSet(base, ext model.LabelSet) []*dto.LabelPair {
- labels := base.Clone().Merge(ext)
- delete(labels, model.MetricNameLabel)
-
- names := make([]string, 0, len(labels))
- for ln := range labels {
- names = append(names, string(ln))
- }
- sort.Strings(names)
-
- pairs := make([]*dto.LabelPair, 0, len(labels))
-
- for _, ln := range names {
- lv := labels[model.LabelName(ln)]
-
- pairs = append(pairs, &dto.LabelPair{
- Name: proto.String(ln),
- Value: proto.String(string(lv)),
- })
- }
-
- return pairs
-}
-
-func (d *json2Decoder) more() error {
- var entities []struct {
- BaseLabels model.LabelSet `json:"baseLabels"`
- Docstring string `json:"docstring"`
- Metric struct {
- Type string `json:"type"`
- Values json.RawMessage `json:"value"`
- } `json:"metric"`
- }
-
- if err := d.dec.Decode(&entities); err != nil {
- return err
- }
- for _, e := range entities {
- f := &dto.MetricFamily{
- Name: proto.String(string(e.BaseLabels[model.MetricNameLabel])),
- Help: proto.String(e.Docstring),
- Type: dto.MetricType_UNTYPED.Enum(),
- Metric: []*dto.Metric{},
- }
-
- d.fams = append(d.fams, f)
-
- switch e.Metric.Type {
- case "counter", "gauge":
- var values []counter002
-
- if err := json.Unmarshal(e.Metric.Values, &values); err != nil {
- return fmt.Errorf("could not extract %s value: %s", e.Metric.Type, err)
- }
-
- for _, ctr := range values {
- f.Metric = append(f.Metric, &dto.Metric{
- Label: protoLabelSet(e.BaseLabels, ctr.Labels),
- Untyped: &dto.Untyped{
- Value: proto.Float64(ctr.Value),
- },
- })
- }
-
- case "histogram":
- var values []histogram002
-
- if err := json.Unmarshal(e.Metric.Values, &values); err != nil {
- return fmt.Errorf("could not extract %s value: %s", e.Metric.Type, err)
- }
-
- for _, hist := range values {
- quants := make([]string, 0, len(values))
- for q := range hist.Values {
- quants = append(quants, q)
- }
-
- sort.Strings(quants)
-
- for _, q := range quants {
- value := hist.Values[q]
- // The correct label is "quantile" but to not break old expressions
- // this remains "percentile"
- hist.Labels["percentile"] = model.LabelValue(q)
-
- f.Metric = append(f.Metric, &dto.Metric{
- Label: protoLabelSet(e.BaseLabels, hist.Labels),
- Untyped: &dto.Untyped{
- Value: proto.Float64(value),
- },
- })
- }
- }
-
- default:
- return fmt.Errorf("unknown metric type %q", e.Metric.Type)
- }
- }
- return nil
-}
-
-// Decode implements the Decoder interface.
-func (d *json2Decoder) Decode(v *dto.MetricFamily) error {
- if len(d.fams) == 0 {
- if err := d.more(); err != nil {
- return err
- }
- }
-
- *v = *d.fams[0]
- d.fams = d.fams[1:]
-
- return nil
-}
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/.travis.yml b/Godeps/_workspace/src/github.com/prometheus/procfs/.travis.yml
deleted file mode 100644
index b1e6743f9c963e35a412a09bcfc704fb46ae2e54..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/.travis.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-language: go
-go:
- - 1.3
- - 1.4
- - tip
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/AUTHORS.md b/Godeps/_workspace/src/github.com/prometheus/procfs/AUTHORS.md
deleted file mode 100644
index 6eb1935cdfc6ecc7081cf7c16f294a0fc76a3dc8..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/AUTHORS.md
+++ /dev/null
@@ -1,11 +0,0 @@
-The Prometheus project was started by Matt T. Proud (emeritus) and
-Julius Volz in 2012.
-
-Maintainers of this repository:
-
-* Tobias Schmidt <ts@soundcloud.com>
-
-The following individuals have contributed code to this repository
-(listed in alphabetical order):
-
-* Tobias Schmidt <ts@soundcloud.com>
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/.gitignore b/Godeps/_workspace/src/github.com/russross/blackfriday/.gitignore
deleted file mode 100644
index 75623dcccbb760b54b892fbbf3360ef156c86c5b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-*.out
-*.swp
-*.8
-*.6
-_obj
-_test*
-markdown
-tags
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/.travis.yml b/Godeps/_workspace/src/github.com/russross/blackfriday/.travis.yml
deleted file mode 100644
index c6dc2752903e55dae669e88f21b8cea1e026e298..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/.travis.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-# Travis CI (http://travis-ci.org/) is a continuous integration service for
-# open source projects. This file configures it to run unit tests for
-# blackfriday.
-
-language: go
-
-go:
- - 1.2
- - 1.3
-
-install:
- - go get -d -t -v ./...
- - go build -v ./...
-
-script:
- - go test -v ./...
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/LICENSE.txt b/Godeps/_workspace/src/github.com/russross/blackfriday/LICENSE.txt
deleted file mode 100644
index 2885af3602d8207cd71c46b13af5bb64adc86574..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/LICENSE.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-Blackfriday is distributed under the Simplified BSD License:
-
-> Copyright © 2011 Russ Ross
-> All rights reserved.
->
-> Redistribution and use in source and binary forms, with or without
-> modification, are permitted provided that the following conditions
-> are met:
->
-> 1. Redistributions of source code must retain the above copyright
-> notice, this list of conditions and the following disclaimer.
->
-> 2. Redistributions in binary form must reproduce the above
-> copyright notice, this list of conditions and the following
-> disclaimer in the documentation and/or other materials provided with
-> the distribution.
->
-> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-> "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-> LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-> FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-> COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-> INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-> BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-> LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-> LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-> ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-> POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/README.md b/Godeps/_workspace/src/github.com/russross/blackfriday/README.md
deleted file mode 100644
index 179978d4e72a116b91cc0218fe394a48bcd41eaa..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/README.md
+++ /dev/null
@@ -1,246 +0,0 @@
-Blackfriday [](https://travis-ci.org/russross/blackfriday)
-===========
-
-Blackfriday is a [Markdown][1] processor implemented in [Go][2]. It
-is paranoid about its input (so you can safely feed it user-supplied
-data), it is fast, it supports common extensions (tables, smart
-punctuation substitutions, etc.), and it is safe for all utf-8
-(unicode) input.
-
-HTML output is currently supported, along with Smartypants
-extensions. An experimental LaTeX output engine is also included.
-
-It started as a translation from C of [upskirt][3].
-
-
-Installation
-------------
-
-Blackfriday is compatible with Go 1. If you are using an older
-release of Go, consider using v1.1 of blackfriday, which was based
-on the last stable release of Go prior to Go 1. You can find it as a
-tagged commit on github.
-
-With Go 1 and git installed:
-
- go get github.com/russross/blackfriday
-
-will download, compile, and install the package into your `$GOPATH`
-directory hierarchy. Alternatively, you can achieve the same if you
-import it into a project:
-
- import "github.com/russross/blackfriday"
-
-and `go get` without parameters.
-
-Usage
------
-
-For basic usage, it is as simple as getting your input into a byte
-slice and calling:
-
- output := blackfriday.MarkdownBasic(input)
-
-This renders it with no extensions enabled. To get a more useful
-feature set, use this instead:
-
- output := blackfriday.MarkdownCommon(input)
-
-### Sanitize untrusted content
-
-Blackfriday itself does nothing to protect against malicious content. If you are
-dealing with user-supplied markdown, we recommend running blackfriday's output
-through HTML sanitizer such as
-[Bluemonday](https://github.com/microcosm-cc/bluemonday).
-
-Here's an example of simple usage of blackfriday together with bluemonday:
-
-``` go
-import (
- "github.com/microcosm-cc/bluemonday"
- "github.com/russross/blackfriday"
-)
-
-// ...
-unsafe := blackfriday.MarkdownCommon(input)
-html := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
-```
-
-### Custom options
-
-If you want to customize the set of options, first get a renderer
-(currently either the HTML or LaTeX output engines), then use it to
-call the more general `Markdown` function. For examples, see the
-implementations of `MarkdownBasic` and `MarkdownCommon` in
-`markdown.go`.
-
-You can also check out `blackfriday-tool` for a more complete example
-of how to use it. Download and install it using:
-
- go get github.com/russross/blackfriday-tool
-
-This is a simple command-line tool that allows you to process a
-markdown file using a standalone program. You can also browse the
-source directly on github if you are just looking for some example
-code:
-
-* <http://github.com/russross/blackfriday-tool>
-
-Note that if you have not already done so, installing
-`blackfriday-tool` will be sufficient to download and install
-blackfriday in addition to the tool itself. The tool binary will be
-installed in `$GOPATH/bin`. This is a statically-linked binary that
-can be copied to wherever you need it without worrying about
-dependencies and library versions.
-
-
-Features
---------
-
-All features of upskirt are supported, including:
-
-* **Compatibility**. The Markdown v1.0.3 test suite passes with
- the `--tidy` option. Without `--tidy`, the differences are
- mostly in whitespace and entity escaping, where blackfriday is
- more consistent and cleaner.
-
-* **Common extensions**, including table support, fenced code
- blocks, autolinks, strikethroughs, non-strict emphasis, etc.
-
-* **Safety**. Blackfriday is paranoid when parsing, making it safe
- to feed untrusted user input without fear of bad things
- happening. The test suite stress tests this and there are no
- known inputs that make it crash. If you find one, please let me
- know and send me the input that does it.
-
- NOTE: "safety" in this context means *runtime safety only*. In order to
- protect yourself agains JavaScript injection in untrusted content, see
- [this example](https://github.com/russross/blackfriday#sanitize-untrusted-content).
-
-* **Fast processing**. It is fast enough to render on-demand in
- most web applications without having to cache the output.
-
-* **Thread safety**. You can run multiple parsers in different
- goroutines without ill effect. There is no dependence on global
- shared state.
-
-* **Minimal dependencies**. Blackfriday only depends on standard
- library packages in Go. The source code is pretty
- self-contained, so it is easy to add to any project, including
- Google App Engine projects.
-
-* **Standards compliant**. Output successfully validates using the
- W3C validation tool for HTML 4.01 and XHTML 1.0 Transitional.
-
-
-Extensions
-----------
-
-In addition to the standard markdown syntax, this package
-implements the following extensions:
-
-* **Intra-word emphasis supression**. The `_` character is
- commonly used inside words when discussing code, so having
- markdown interpret it as an emphasis command is usually the
- wrong thing. Blackfriday lets you treat all emphasis markers as
- normal characters when they occur inside a word.
-
-* **Tables**. Tables can be created by drawing them in the input
- using a simple syntax:
-
- ```
- Name | Age
- --------|------
- Bob | 27
- Alice | 23
- ```
-
-* **Fenced code blocks**. In addition to the normal 4-space
- indentation to mark code blocks, you can explicitly mark them
- and supply a language (to make syntax highlighting simple). Just
- mark it like this:
-
- ``` go
- func getTrue() bool {
- return true
- }
- ```
-
- You can use 3 or more backticks to mark the beginning of the
- block, and the same number to mark the end of the block.
-
-* **Autolinking**. Blackfriday can find URLs that have not been
- explicitly marked as links and turn them into links.
-
-* **Strikethrough**. Use two tildes (`~~`) to mark text that
- should be crossed out.
-
-* **Hard line breaks**. With this extension enabled (it is off by
- default in the `MarkdownBasic` and `MarkdownCommon` convenience
- functions), newlines in the input translate into line breaks in
- the output.
-
-* **Smart quotes**. Smartypants-style punctuation substitution is
- supported, turning normal double- and single-quote marks into
- curly quotes, etc.
-
-* **LaTeX-style dash parsing** is an additional option, where `--`
- is translated into `–`, and `---` is translated into
- `—`. This differs from most smartypants processors, which
- turn a single hyphen into an ndash and a double hyphen into an
- mdash.
-
-* **Smart fractions**, where anything that looks like a fraction
- is translated into suitable HTML (instead of just a few special
- cases like most smartypant processors). For example, `4/5`
- becomes `<sup>4</sup>⁄<sub>5</sub>`, which renders as
- <sup>4</sup>⁄<sub>5</sub>.
-
-
-Other renderers
----------------
-
-Blackfriday is structured to allow alternative rendering engines. Here
-are a few of note:
-
-* [github_flavored_markdown](https://godoc.org/github.com/shurcooL/go/github_flavored_markdown):
- provides a GitHub Flavored Markdown renderer with fenced code block
- highlighting, clickable header anchor links.
-
- It's not customizable, and its goal is to produce HTML output
- equivalent to the [GitHub Markdown API endpoint](https://developer.github.com/v3/markdown/#render-a-markdown-document-in-raw-mode),
- except the rendering is performed locally.
-
-* [markdownfmt](https://github.com/shurcooL/markdownfmt): like gofmt,
- but for markdown.
-
-* LaTeX output: renders output as LaTeX. This is currently part of the
- main Blackfriday repository, but may be split into its own project
- in the future. If you are interested in owning and maintaining the
- LaTeX output component, please be in touch.
-
- It renders some basic documents, but is only experimental at this
- point. In particular, it does not do any inline escaping, so input
- that happens to look like LaTeX code will be passed through without
- modification.
-
-
-Todo
-----
-
-* More unit testing
-* Improve unicode support. It does not understand all unicode
- rules (about what constitutes a letter, a punctuation symbol,
- etc.), so it may fail to detect word boundaries correctly in
- some instances. It is safe on all utf-8 input.
-
-
-License
--------
-
-[Blackfriday is distributed under the Simplified BSD License](LICENSE.txt)
-
-
- [1]: http://daringfireball.net/projects/markdown/ "Markdown"
- [2]: http://golang.org/ "Go Language"
- [3]: http://github.com/tanoku/upskirt "Upskirt"
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/block.go b/Godeps/_workspace/src/github.com/russross/blackfriday/block.go
deleted file mode 100644
index 59c6d2842e99cc353c4c7bfedc6fb10e2122f88a..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/block.go
+++ /dev/null
@@ -1,1339 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-// Functions to parse block-level elements.
-//
-
-package blackfriday
-
-import (
- "bytes"
-
- "github.com/shurcooL/sanitized_anchor_name"
-)
-
-// Parse block-level data.
-// Note: this function and many that it calls assume that
-// the input buffer ends with a newline.
-func (p *parser) block(out *bytes.Buffer, data []byte) {
- if len(data) == 0 || data[len(data)-1] != '\n' {
- panic("block input is missing terminating newline")
- }
-
- // this is called recursively: enforce a maximum depth
- if p.nesting >= p.maxNesting {
- return
- }
- p.nesting++
-
- // parse out one block-level construct at a time
- for len(data) > 0 {
- // prefixed header:
- //
- // # Header 1
- // ## Header 2
- // ...
- // ###### Header 6
- if p.isPrefixHeader(data) {
- data = data[p.prefixHeader(out, data):]
- continue
- }
-
- // block of preformatted HTML:
- //
- // <div>
- // ...
- // </div>
- if data[0] == '<' {
- if i := p.html(out, data, true); i > 0 {
- data = data[i:]
- continue
- }
- }
-
- // title block
- //
- // % stuff
- // % more stuff
- // % even more stuff
- if p.flags&EXTENSION_TITLEBLOCK != 0 {
- if data[0] == '%' {
- if i := p.titleBlock(out, data, true); i > 0 {
- data = data[i:]
- continue
- }
- }
- }
-
- // blank lines. note: returns the # of bytes to skip
- if i := p.isEmpty(data); i > 0 {
- data = data[i:]
- continue
- }
-
- // indented code block:
- //
- // func max(a, b int) int {
- // if a > b {
- // return a
- // }
- // return b
- // }
- if p.codePrefix(data) > 0 {
- data = data[p.code(out, data):]
- continue
- }
-
- // fenced code block:
- //
- // ``` go
- // func fact(n int) int {
- // if n <= 1 {
- // return n
- // }
- // return n * fact(n-1)
- // }
- // ```
- if p.flags&EXTENSION_FENCED_CODE != 0 {
- if i := p.fencedCode(out, data, true); i > 0 {
- data = data[i:]
- continue
- }
- }
-
- // horizontal rule:
- //
- // ------
- // or
- // ******
- // or
- // ______
- if p.isHRule(data) {
- p.r.HRule(out)
- var i int
- for i = 0; data[i] != '\n'; i++ {
- }
- data = data[i:]
- continue
- }
-
- // block quote:
- //
- // > A big quote I found somewhere
- // > on the web
- if p.quotePrefix(data) > 0 {
- data = data[p.quote(out, data):]
- continue
- }
-
- // table:
- //
- // Name | Age | Phone
- // ------|-----|---------
- // Bob | 31 | 555-1234
- // Alice | 27 | 555-4321
- if p.flags&EXTENSION_TABLES != 0 {
- if i := p.table(out, data); i > 0 {
- data = data[i:]
- continue
- }
- }
-
- // an itemized/unordered list:
- //
- // * Item 1
- // * Item 2
- //
- // also works with + or -
- if p.uliPrefix(data) > 0 {
- data = data[p.list(out, data, 0):]
- continue
- }
-
- // a numbered/ordered list:
- //
- // 1. Item 1
- // 2. Item 2
- if p.oliPrefix(data) > 0 {
- data = data[p.list(out, data, LIST_TYPE_ORDERED):]
- continue
- }
-
- // anything else must look like a normal paragraph
- // note: this finds underlined headers, too
- data = data[p.paragraph(out, data):]
- }
-
- p.nesting--
-}
-
-func (p *parser) isPrefixHeader(data []byte) bool {
- if data[0] != '#' {
- return false
- }
-
- if p.flags&EXTENSION_SPACE_HEADERS != 0 {
- level := 0
- for level < 6 && data[level] == '#' {
- level++
- }
- if data[level] != ' ' {
- return false
- }
- }
- return true
-}
-
-func (p *parser) prefixHeader(out *bytes.Buffer, data []byte) int {
- level := 0
- for level < 6 && data[level] == '#' {
- level++
- }
- i, end := 0, 0
- for i = level; data[i] == ' '; i++ {
- }
- for end = i; data[end] != '\n'; end++ {
- }
- skip := end
- id := ""
- if p.flags&EXTENSION_HEADER_IDS != 0 {
- j, k := 0, 0
- // find start/end of header id
- for j = i; j < end-1 && (data[j] != '{' || data[j+1] != '#'); j++ {
- }
- for k = j + 1; k < end && data[k] != '}'; k++ {
- }
- // extract header id iff found
- if j < end && k < end {
- id = string(data[j+2 : k])
- end = j
- skip = k + 1
- for end > 0 && data[end-1] == ' ' {
- end--
- }
- }
- }
- for end > 0 && data[end-1] == '#' {
- end--
- }
- for end > 0 && data[end-1] == ' ' {
- end--
- }
- if end > i {
- if id == "" && p.flags&EXTENSION_AUTO_HEADER_IDS != 0 {
- id = sanitized_anchor_name.Create(string(data[i:end]))
- }
- work := func() bool {
- p.inline(out, data[i:end])
- return true
- }
- p.r.Header(out, work, level, id)
- }
- return skip
-}
-
-func (p *parser) isUnderlinedHeader(data []byte) int {
- // test of level 1 header
- if data[0] == '=' {
- i := 1
- for data[i] == '=' {
- i++
- }
- for data[i] == ' ' {
- i++
- }
- if data[i] == '\n' {
- return 1
- } else {
- return 0
- }
- }
-
- // test of level 2 header
- if data[0] == '-' {
- i := 1
- for data[i] == '-' {
- i++
- }
- for data[i] == ' ' {
- i++
- }
- if data[i] == '\n' {
- return 2
- } else {
- return 0
- }
- }
-
- return 0
-}
-
-func (p *parser) titleBlock(out *bytes.Buffer, data []byte, doRender bool) int {
- if data[0] != '%' {
- return 0
- }
- splitData := bytes.Split(data, []byte("\n"))
- var i int
- for idx, b := range splitData {
- if !bytes.HasPrefix(b, []byte("%")) {
- i = idx // - 1
- break
- }
- }
-
- data = bytes.Join(splitData[0:i], []byte("\n"))
- p.r.TitleBlock(out, data)
-
- return len(data)
-}
-
-func (p *parser) html(out *bytes.Buffer, data []byte, doRender bool) int {
- var i, j int
-
- // identify the opening tag
- if data[0] != '<' {
- return 0
- }
- curtag, tagfound := p.htmlFindTag(data[1:])
-
- // handle special cases
- if !tagfound {
- // check for an HTML comment
- if size := p.htmlComment(out, data, doRender); size > 0 {
- return size
- }
-
- // check for an <hr> tag
- if size := p.htmlHr(out, data, doRender); size > 0 {
- return size
- }
-
- // no special case recognized
- return 0
- }
-
- // look for an unindented matching closing tag
- // followed by a blank line
- found := false
- /*
- closetag := []byte("\n</" + curtag + ">")
- j = len(curtag) + 1
- for !found {
- // scan for a closing tag at the beginning of a line
- if skip := bytes.Index(data[j:], closetag); skip >= 0 {
- j += skip + len(closetag)
- } else {
- break
- }
-
- // see if it is the only thing on the line
- if skip := p.isEmpty(data[j:]); skip > 0 {
- // see if it is followed by a blank line/eof
- j += skip
- if j >= len(data) {
- found = true
- i = j
- } else {
- if skip := p.isEmpty(data[j:]); skip > 0 {
- j += skip
- found = true
- i = j
- }
- }
- }
- }
- */
-
- // if not found, try a second pass looking for indented match
- // but not if tag is "ins" or "del" (following original Markdown.pl)
- if !found && curtag != "ins" && curtag != "del" {
- i = 1
- for i < len(data) {
- i++
- for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {
- i++
- }
-
- if i+2+len(curtag) >= len(data) {
- break
- }
-
- j = p.htmlFindEnd(curtag, data[i-1:])
-
- if j > 0 {
- i += j - 1
- found = true
- break
- }
- }
- }
-
- if !found {
- return 0
- }
-
- // the end of the block has been found
- if doRender {
- // trim newlines
- end := i
- for end > 0 && data[end-1] == '\n' {
- end--
- }
- p.r.BlockHtml(out, data[:end])
- }
-
- return i
-}
-
-// HTML comment, lax form
-func (p *parser) htmlComment(out *bytes.Buffer, data []byte, doRender bool) int {
- if data[0] != '<' || data[1] != '!' || data[2] != '-' || data[3] != '-' {
- return 0
- }
-
- i := 5
-
- // scan for an end-of-comment marker, across lines if necessary
- for i < len(data) && !(data[i-2] == '-' && data[i-1] == '-' && data[i] == '>') {
- i++
- }
- i++
-
- // no end-of-comment marker
- if i >= len(data) {
- return 0
- }
-
- // needs to end with a blank line
- if j := p.isEmpty(data[i:]); j > 0 {
- size := i + j
- if doRender {
- // trim trailing newlines
- end := size
- for end > 0 && data[end-1] == '\n' {
- end--
- }
- p.r.BlockHtml(out, data[:end])
- }
- return size
- }
-
- return 0
-}
-
-// HR, which is the only self-closing block tag considered
-func (p *parser) htmlHr(out *bytes.Buffer, data []byte, doRender bool) int {
- if data[0] != '<' || (data[1] != 'h' && data[1] != 'H') || (data[2] != 'r' && data[2] != 'R') {
- return 0
- }
- if data[3] != ' ' && data[3] != '/' && data[3] != '>' {
- // not an <hr> tag after all; at least not a valid one
- return 0
- }
-
- i := 3
- for data[i] != '>' && data[i] != '\n' {
- i++
- }
-
- if data[i] == '>' {
- i++
- if j := p.isEmpty(data[i:]); j > 0 {
- size := i + j
- if doRender {
- // trim newlines
- end := size
- for end > 0 && data[end-1] == '\n' {
- end--
- }
- p.r.BlockHtml(out, data[:end])
- }
- return size
- }
- }
-
- return 0
-}
-
-func (p *parser) htmlFindTag(data []byte) (string, bool) {
- i := 0
- for isalnum(data[i]) {
- i++
- }
- key := string(data[:i])
- if blockTags[key] {
- return key, true
- }
- return "", false
-}
-
-func (p *parser) htmlFindEnd(tag string, data []byte) int {
- // assume data[0] == '<' && data[1] == '/' already tested
-
- // check if tag is a match
- closetag := []byte("</" + tag + ">")
- if !bytes.HasPrefix(data, closetag) {
- return 0
- }
- i := len(closetag)
-
- // check that the rest of the line is blank
- skip := 0
- if skip = p.isEmpty(data[i:]); skip == 0 {
- return 0
- }
- i += skip
- skip = 0
-
- if i >= len(data) {
- return i
- }
-
- if p.flags&EXTENSION_LAX_HTML_BLOCKS != 0 {
- return i
- }
- if skip = p.isEmpty(data[i:]); skip == 0 {
- // following line must be blank
- return 0
- }
-
- return i + skip
-}
-
-func (p *parser) isEmpty(data []byte) int {
- // it is okay to call isEmpty on an empty buffer
- if len(data) == 0 {
- return 0
- }
-
- var i int
- for i = 0; i < len(data) && data[i] != '\n'; i++ {
- if data[i] != ' ' && data[i] != '\t' {
- return 0
- }
- }
- return i + 1
-}
-
-func (p *parser) isHRule(data []byte) bool {
- i := 0
-
- // skip up to three spaces
- for i < 3 && data[i] == ' ' {
- i++
- }
-
- // look at the hrule char
- if data[i] != '*' && data[i] != '-' && data[i] != '_' {
- return false
- }
- c := data[i]
-
- // the whole line must be the char or whitespace
- n := 0
- for data[i] != '\n' {
- switch {
- case data[i] == c:
- n++
- case data[i] != ' ':
- return false
- }
- i++
- }
-
- return n >= 3
-}
-
-func (p *parser) isFencedCode(data []byte, syntax **string, oldmarker string) (skip int, marker string) {
- i, size := 0, 0
- skip = 0
-
- // skip up to three spaces
- for i < len(data) && i < 3 && data[i] == ' ' {
- i++
- }
- if i >= len(data) {
- return
- }
-
- // check for the marker characters: ~ or `
- if data[i] != '~' && data[i] != '`' {
- return
- }
-
- c := data[i]
-
- // the whole line must be the same char or whitespace
- for i < len(data) && data[i] == c {
- size++
- i++
- }
-
- if i >= len(data) {
- return
- }
-
- // the marker char must occur at least 3 times
- if size < 3 {
- return
- }
- marker = string(data[i-size : i])
-
- // if this is the end marker, it must match the beginning marker
- if oldmarker != "" && marker != oldmarker {
- return
- }
-
- if syntax != nil {
- syn := 0
-
- for i < len(data) && data[i] == ' ' {
- i++
- }
-
- if i >= len(data) {
- return
- }
-
- syntaxStart := i
-
- if data[i] == '{' {
- i++
- syntaxStart++
-
- for i < len(data) && data[i] != '}' && data[i] != '\n' {
- syn++
- i++
- }
-
- if i >= len(data) || data[i] != '}' {
- return
- }
-
- // strip all whitespace at the beginning and the end
- // of the {} block
- for syn > 0 && isspace(data[syntaxStart]) {
- syntaxStart++
- syn--
- }
-
- for syn > 0 && isspace(data[syntaxStart+syn-1]) {
- syn--
- }
-
- i++
- } else {
- for i < len(data) && !isspace(data[i]) {
- syn++
- i++
- }
- }
-
- language := string(data[syntaxStart : syntaxStart+syn])
- *syntax = &language
- }
-
- for i < len(data) && data[i] == ' ' {
- i++
- }
- if i >= len(data) || data[i] != '\n' {
- return
- }
-
- skip = i + 1
- return
-}
-
-func (p *parser) fencedCode(out *bytes.Buffer, data []byte, doRender bool) int {
- var lang *string
- beg, marker := p.isFencedCode(data, &lang, "")
- if beg == 0 || beg >= len(data) {
- return 0
- }
-
- var work bytes.Buffer
-
- for {
- // safe to assume beg < len(data)
-
- // check for the end of the code block
- fenceEnd, _ := p.isFencedCode(data[beg:], nil, marker)
- if fenceEnd != 0 {
- beg += fenceEnd
- break
- }
-
- // copy the current line
- end := beg
- for end < len(data) && data[end] != '\n' {
- end++
- }
- end++
-
- // did we reach the end of the buffer without a closing marker?
- if end >= len(data) {
- return 0
- }
-
- // verbatim copy to the working buffer
- if doRender {
- work.Write(data[beg:end])
- }
- beg = end
- }
-
- syntax := ""
- if lang != nil {
- syntax = *lang
- }
-
- if doRender {
- p.r.BlockCode(out, work.Bytes(), syntax)
- }
-
- return beg
-}
-
-func (p *parser) table(out *bytes.Buffer, data []byte) int {
- var header bytes.Buffer
- i, columns := p.tableHeader(&header, data)
- if i == 0 {
- return 0
- }
-
- var body bytes.Buffer
-
- for i < len(data) {
- pipes, rowStart := 0, i
- for ; data[i] != '\n'; i++ {
- if data[i] == '|' {
- pipes++
- }
- }
-
- if pipes == 0 {
- i = rowStart
- break
- }
-
- // include the newline in data sent to tableRow
- i++
- p.tableRow(&body, data[rowStart:i], columns, false)
- }
-
- p.r.Table(out, header.Bytes(), body.Bytes(), columns)
-
- return i
-}
-
-// check if the specified position is preceeded by an odd number of backslashes
-func isBackslashEscaped(data []byte, i int) bool {
- backslashes := 0
- for i-backslashes-1 >= 0 && data[i-backslashes-1] == '\\' {
- backslashes++
- }
- return backslashes&1 == 1
-}
-
-func (p *parser) tableHeader(out *bytes.Buffer, data []byte) (size int, columns []int) {
- i := 0
- colCount := 1
- for i = 0; data[i] != '\n'; i++ {
- if data[i] == '|' && !isBackslashEscaped(data, i) {
- colCount++
- }
- }
-
- // doesn't look like a table header
- if colCount == 1 {
- return
- }
-
- // include the newline in the data sent to tableRow
- header := data[:i+1]
-
- // column count ignores pipes at beginning or end of line
- if data[0] == '|' {
- colCount--
- }
- if i > 2 && data[i-1] == '|' && !isBackslashEscaped(data, i-1) {
- colCount--
- }
-
- columns = make([]int, colCount)
-
- // move on to the header underline
- i++
- if i >= len(data) {
- return
- }
-
- if data[i] == '|' && !isBackslashEscaped(data, i) {
- i++
- }
- for data[i] == ' ' {
- i++
- }
-
- // each column header is of form: / *:?-+:? *|/ with # dashes + # colons >= 3
- // and trailing | optional on last column
- col := 0
- for data[i] != '\n' {
- dashes := 0
-
- if data[i] == ':' {
- i++
- columns[col] |= TABLE_ALIGNMENT_LEFT
- dashes++
- }
- for data[i] == '-' {
- i++
- dashes++
- }
- if data[i] == ':' {
- i++
- columns[col] |= TABLE_ALIGNMENT_RIGHT
- dashes++
- }
- for data[i] == ' ' {
- i++
- }
-
- // end of column test is messy
- switch {
- case dashes < 3:
- // not a valid column
- return
-
- case data[i] == '|' && !isBackslashEscaped(data, i):
- // marker found, now skip past trailing whitespace
- col++
- i++
- for data[i] == ' ' {
- i++
- }
-
- // trailing junk found after last column
- if col >= colCount && data[i] != '\n' {
- return
- }
-
- case (data[i] != '|' || isBackslashEscaped(data, i)) && col+1 < colCount:
- // something else found where marker was required
- return
-
- case data[i] == '\n':
- // marker is optional for the last column
- col++
-
- default:
- // trailing junk found after last column
- return
- }
- }
- if col != colCount {
- return
- }
-
- p.tableRow(out, header, columns, true)
- size = i + 1
- return
-}
-
-func (p *parser) tableRow(out *bytes.Buffer, data []byte, columns []int, header bool) {
- i, col := 0, 0
- var rowWork bytes.Buffer
-
- if data[i] == '|' && !isBackslashEscaped(data, i) {
- i++
- }
-
- for col = 0; col < len(columns) && i < len(data); col++ {
- for data[i] == ' ' {
- i++
- }
-
- cellStart := i
-
- for (data[i] != '|' || isBackslashEscaped(data, i)) && data[i] != '\n' {
- i++
- }
-
- cellEnd := i
-
- // skip the end-of-cell marker, possibly taking us past end of buffer
- i++
-
- for cellEnd > cellStart && data[cellEnd-1] == ' ' {
- cellEnd--
- }
-
- var cellWork bytes.Buffer
- p.inline(&cellWork, data[cellStart:cellEnd])
-
- if header {
- p.r.TableHeaderCell(&rowWork, cellWork.Bytes(), columns[col])
- } else {
- p.r.TableCell(&rowWork, cellWork.Bytes(), columns[col])
- }
- }
-
- // pad it out with empty columns to get the right number
- for ; col < len(columns); col++ {
- if header {
- p.r.TableHeaderCell(&rowWork, nil, columns[col])
- } else {
- p.r.TableCell(&rowWork, nil, columns[col])
- }
- }
-
- // silently ignore rows with too many cells
-
- p.r.TableRow(out, rowWork.Bytes())
-}
-
-// returns blockquote prefix length
-func (p *parser) quotePrefix(data []byte) int {
- i := 0
- for i < 3 && data[i] == ' ' {
- i++
- }
- if data[i] == '>' {
- if data[i+1] == ' ' {
- return i + 2
- }
- return i + 1
- }
- return 0
-}
-
-// parse a blockquote fragment
-func (p *parser) quote(out *bytes.Buffer, data []byte) int {
- var raw bytes.Buffer
- beg, end := 0, 0
- for beg < len(data) {
- end = beg
- for data[end] != '\n' {
- end++
- }
- end++
-
- if pre := p.quotePrefix(data[beg:]); pre > 0 {
- // skip the prefix
- beg += pre
- } else if p.isEmpty(data[beg:]) > 0 &&
- (end >= len(data) ||
- (p.quotePrefix(data[end:]) == 0 && p.isEmpty(data[end:]) == 0)) {
- // blockquote ends with at least one blank line
- // followed by something without a blockquote prefix
- break
- }
-
- // this line is part of the blockquote
- raw.Write(data[beg:end])
- beg = end
- }
-
- var cooked bytes.Buffer
- p.block(&cooked, raw.Bytes())
- p.r.BlockQuote(out, cooked.Bytes())
- return end
-}
-
-// returns prefix length for block code
-func (p *parser) codePrefix(data []byte) int {
- if data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ' {
- return 4
- }
- return 0
-}
-
-func (p *parser) code(out *bytes.Buffer, data []byte) int {
- var work bytes.Buffer
-
- i := 0
- for i < len(data) {
- beg := i
- for data[i] != '\n' {
- i++
- }
- i++
-
- blankline := p.isEmpty(data[beg:i]) > 0
- if pre := p.codePrefix(data[beg:i]); pre > 0 {
- beg += pre
- } else if !blankline {
- // non-empty, non-prefixed line breaks the pre
- i = beg
- break
- }
-
- // verbatim copy to the working buffeu
- if blankline {
- work.WriteByte('\n')
- } else {
- work.Write(data[beg:i])
- }
- }
-
- // trim all the \n off the end of work
- workbytes := work.Bytes()
- eol := len(workbytes)
- for eol > 0 && workbytes[eol-1] == '\n' {
- eol--
- }
- if eol != len(workbytes) {
- work.Truncate(eol)
- }
-
- work.WriteByte('\n')
-
- p.r.BlockCode(out, work.Bytes(), "")
-
- return i
-}
-
-// returns unordered list item prefix
-func (p *parser) uliPrefix(data []byte) int {
- i := 0
-
- // start with up to 3 spaces
- for i < 3 && data[i] == ' ' {
- i++
- }
-
- // need a *, +, or - followed by a space
- if (data[i] != '*' && data[i] != '+' && data[i] != '-') ||
- data[i+1] != ' ' {
- return 0
- }
- return i + 2
-}
-
-// returns ordered list item prefix
-func (p *parser) oliPrefix(data []byte) int {
- i := 0
-
- // start with up to 3 spaces
- for i < 3 && data[i] == ' ' {
- i++
- }
-
- // count the digits
- start := i
- for data[i] >= '0' && data[i] <= '9' {
- i++
- }
-
- // we need >= 1 digits followed by a dot and a space
- if start == i || data[i] != '.' || data[i+1] != ' ' {
- return 0
- }
- return i + 2
-}
-
-// parse ordered or unordered list block
-func (p *parser) list(out *bytes.Buffer, data []byte, flags int) int {
- i := 0
- flags |= LIST_ITEM_BEGINNING_OF_LIST
- work := func() bool {
- for i < len(data) {
- skip := p.listItem(out, data[i:], &flags)
- i += skip
-
- if skip == 0 || flags&LIST_ITEM_END_OF_LIST != 0 {
- break
- }
- flags &= ^LIST_ITEM_BEGINNING_OF_LIST
- }
- return true
- }
-
- p.r.List(out, work, flags)
- return i
-}
-
-// Parse a single list item.
-// Assumes initial prefix is already removed if this is a sublist.
-func (p *parser) listItem(out *bytes.Buffer, data []byte, flags *int) int {
- // keep track of the indentation of the first line
- itemIndent := 0
- for itemIndent < 3 && data[itemIndent] == ' ' {
- itemIndent++
- }
-
- i := p.uliPrefix(data)
- if i == 0 {
- i = p.oliPrefix(data)
- }
- if i == 0 {
- return 0
- }
-
- // skip leading whitespace on first line
- for data[i] == ' ' {
- i++
- }
-
- // find the end of the line
- line := i
- for data[i-1] != '\n' {
- i++
- }
-
- // get working buffer
- var raw bytes.Buffer
-
- // put the first line into the working buffer
- raw.Write(data[line:i])
- line = i
-
- // process the following lines
- containsBlankLine := false
- sublist := 0
-
-gatherlines:
- for line < len(data) {
- i++
-
- // find the end of this line
- for data[i-1] != '\n' {
- i++
- }
-
- // if it is an empty line, guess that it is part of this item
- // and move on to the next line
- if p.isEmpty(data[line:i]) > 0 {
- containsBlankLine = true
- line = i
- continue
- }
-
- // calculate the indentation
- indent := 0
- for indent < 4 && line+indent < i && data[line+indent] == ' ' {
- indent++
- }
-
- chunk := data[line+indent : i]
-
- // evaluate how this line fits in
- switch {
- // is this a nested list item?
- case (p.uliPrefix(chunk) > 0 && !p.isHRule(chunk)) ||
- p.oliPrefix(chunk) > 0:
-
- if containsBlankLine {
- *flags |= LIST_ITEM_CONTAINS_BLOCK
- }
-
- // to be a nested list, it must be indented more
- // if not, it is the next item in the same list
- if indent <= itemIndent {
- break gatherlines
- }
-
- // is this the first item in the the nested list?
- if sublist == 0 {
- sublist = raw.Len()
- }
-
- // is this a nested prefix header?
- case p.isPrefixHeader(chunk):
- // if the header is not indented, it is not nested in the list
- // and thus ends the list
- if containsBlankLine && indent < 4 {
- *flags |= LIST_ITEM_END_OF_LIST
- break gatherlines
- }
- *flags |= LIST_ITEM_CONTAINS_BLOCK
-
- // anything following an empty line is only part
- // of this item if it is indented 4 spaces
- // (regardless of the indentation of the beginning of the item)
- case containsBlankLine && indent < 4:
- *flags |= LIST_ITEM_END_OF_LIST
- break gatherlines
-
- // a blank line means this should be parsed as a block
- case containsBlankLine:
- raw.WriteByte('\n')
- *flags |= LIST_ITEM_CONTAINS_BLOCK
- }
-
- // if this line was preceeded by one or more blanks,
- // re-introduce the blank into the buffer
- if containsBlankLine {
- containsBlankLine = false
- raw.WriteByte('\n')
- }
-
- // add the line into the working buffer without prefix
- raw.Write(data[line+indent : i])
-
- line = i
- }
-
- rawBytes := raw.Bytes()
-
- // render the contents of the list item
- var cooked bytes.Buffer
- if *flags&LIST_ITEM_CONTAINS_BLOCK != 0 {
- // intermediate render of block li
- if sublist > 0 {
- p.block(&cooked, rawBytes[:sublist])
- p.block(&cooked, rawBytes[sublist:])
- } else {
- p.block(&cooked, rawBytes)
- }
- } else {
- // intermediate render of inline li
- if sublist > 0 {
- p.inline(&cooked, rawBytes[:sublist])
- p.block(&cooked, rawBytes[sublist:])
- } else {
- p.inline(&cooked, rawBytes)
- }
- }
-
- // render the actual list item
- cookedBytes := cooked.Bytes()
- parsedEnd := len(cookedBytes)
-
- // strip trailing newlines
- for parsedEnd > 0 && cookedBytes[parsedEnd-1] == '\n' {
- parsedEnd--
- }
- p.r.ListItem(out, cookedBytes[:parsedEnd], *flags)
-
- return line
-}
-
-// render a single paragraph that has already been parsed out
-func (p *parser) renderParagraph(out *bytes.Buffer, data []byte) {
- if len(data) == 0 {
- return
- }
-
- // trim leading spaces
- beg := 0
- for data[beg] == ' ' {
- beg++
- }
-
- // trim trailing newline
- end := len(data) - 1
-
- // trim trailing spaces
- for end > beg && data[end-1] == ' ' {
- end--
- }
-
- work := func() bool {
- p.inline(out, data[beg:end])
- return true
- }
- p.r.Paragraph(out, work)
-}
-
-func (p *parser) paragraph(out *bytes.Buffer, data []byte) int {
- // prev: index of 1st char of previous line
- // line: index of 1st char of current line
- // i: index of cursor/end of current line
- var prev, line, i int
-
- // keep going until we find something to mark the end of the paragraph
- for i < len(data) {
- // mark the beginning of the current line
- prev = line
- current := data[i:]
- line = i
-
- // did we find a blank line marking the end of the paragraph?
- if n := p.isEmpty(current); n > 0 {
- p.renderParagraph(out, data[:i])
- return i + n
- }
-
- // an underline under some text marks a header, so our paragraph ended on prev line
- if i > 0 {
- if level := p.isUnderlinedHeader(current); level > 0 {
- // render the paragraph
- p.renderParagraph(out, data[:prev])
-
- // ignore leading and trailing whitespace
- eol := i - 1
- for prev < eol && data[prev] == ' ' {
- prev++
- }
- for eol > prev && data[eol-1] == ' ' {
- eol--
- }
-
- // render the header
- // this ugly double closure avoids forcing variables onto the heap
- work := func(o *bytes.Buffer, pp *parser, d []byte) func() bool {
- return func() bool {
- pp.inline(o, d)
- return true
- }
- }(out, p, data[prev:eol])
-
- id := ""
- if p.flags&EXTENSION_AUTO_HEADER_IDS != 0 {
- id = sanitized_anchor_name.Create(string(data[prev:eol]))
- }
-
- p.r.Header(out, work, level, id)
-
- // find the end of the underline
- for data[i] != '\n' {
- i++
- }
- return i
- }
- }
-
- // if the next line starts a block of HTML, then the paragraph ends here
- if p.flags&EXTENSION_LAX_HTML_BLOCKS != 0 {
- if data[i] == '<' && p.html(out, current, false) > 0 {
- // rewind to before the HTML block
- p.renderParagraph(out, data[:i])
- return i
- }
- }
-
- // if there's a prefixed header or a horizontal rule after this, paragraph is over
- if p.isPrefixHeader(current) || p.isHRule(current) {
- p.renderParagraph(out, data[:i])
- return i
- }
-
- // if there's a list after this, paragraph is over
- if p.flags&EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK != 0 {
- if p.uliPrefix(current) != 0 ||
- p.oliPrefix(current) != 0 ||
- p.quotePrefix(current) != 0 ||
- p.codePrefix(current) != 0 {
- p.renderParagraph(out, data[:i])
- return i
- }
- }
-
- // otherwise, scan to the beginning of the next line
- for data[i] != '\n' {
- i++
- }
- i++
- }
-
- p.renderParagraph(out, data[:i])
- return i
-}
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/html.go b/Godeps/_workspace/src/github.com/russross/blackfriday/html.go
deleted file mode 100644
index 666d0e3dd5c54326d2724037ca54f88d333e54e9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/html.go
+++ /dev/null
@@ -1,896 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-//
-// HTML rendering backend
-//
-//
-
-package blackfriday
-
-import (
- "bytes"
- "fmt"
- "regexp"
- "strconv"
- "strings"
-)
-
-// Html renderer configuration options.
-const (
- HTML_SKIP_HTML = 1 << iota // skip preformatted HTML blocks
- HTML_SKIP_STYLE // skip embedded <style> elements
- HTML_SKIP_IMAGES // skip embedded images
- HTML_SKIP_LINKS // skip all links
- HTML_SAFELINK // only link to trusted protocols
- HTML_NOFOLLOW_LINKS // only link with rel="nofollow"
- HTML_HREF_TARGET_BLANK // add a blank target
- HTML_TOC // generate a table of contents
- HTML_OMIT_CONTENTS // skip the main contents (for a standalone table of contents)
- HTML_COMPLETE_PAGE // generate a complete HTML page
- HTML_USE_XHTML // generate XHTML output instead of HTML
- HTML_USE_SMARTYPANTS // enable smart punctuation substitutions
- HTML_SMARTYPANTS_FRACTIONS // enable smart fractions (with HTML_USE_SMARTYPANTS)
- HTML_SMARTYPANTS_LATEX_DASHES // enable LaTeX-style dashes (with HTML_USE_SMARTYPANTS)
- HTML_SMARTYPANTS_ANGLED_QUOTES // enable angled double quotes (with HTML_USE_SMARTYPANTS) for double quotes rendering
- HTML_FOOTNOTE_RETURN_LINKS // generate a link at the end of a footnote to return to the source
-)
-
-var (
- alignments = []string{
- "left",
- "right",
- "center",
- }
-
- // TODO: improve this regexp to catch all possible entities:
- htmlEntity = regexp.MustCompile(`&[a-z]{2,5};`)
-)
-
-type HtmlRendererParameters struct {
- // Prepend this text to each relative URL.
- AbsolutePrefix string
- // Add this text to each footnote anchor, to ensure uniqueness.
- FootnoteAnchorPrefix string
- // Show this text inside the <a> tag for a footnote return link, if the
- // HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
- // <sup>[return]</sup> is used.
- FootnoteReturnLinkContents string
- // If set, add this text to the front of each Header ID, to ensure
- // uniqueness.
- HeaderIDPrefix string
- // If set, add this text to the back of each Header ID, to ensure uniqueness.
- HeaderIDSuffix string
-}
-
-// Html is a type that implements the Renderer interface for HTML output.
-//
-// Do not create this directly, instead use the HtmlRenderer function.
-type Html struct {
- flags int // HTML_* options
- closeTag string // how to end singleton tags: either " />\n" or ">\n"
- title string // document title
- css string // optional css file url (used with HTML_COMPLETE_PAGE)
-
- parameters HtmlRendererParameters
-
- // table of contents data
- tocMarker int
- headerCount int
- currentLevel int
- toc *bytes.Buffer
-
- // Track header IDs to prevent ID collision in a single generation.
- headerIDs map[string]int
-
- smartypants *smartypantsRenderer
-}
-
-const (
- xhtmlClose = " />\n"
- htmlClose = ">\n"
-)
-
-// HtmlRenderer creates and configures an Html object, which
-// satisfies the Renderer interface.
-//
-// flags is a set of HTML_* options ORed together.
-// title is the title of the document, and css is a URL for the document's
-// stylesheet.
-// title and css are only used when HTML_COMPLETE_PAGE is selected.
-func HtmlRenderer(flags int, title string, css string) Renderer {
- return HtmlRendererWithParameters(flags, title, css, HtmlRendererParameters{})
-}
-
-func HtmlRendererWithParameters(flags int, title string,
- css string, renderParameters HtmlRendererParameters) Renderer {
- // configure the rendering engine
- closeTag := htmlClose
- if flags&HTML_USE_XHTML != 0 {
- closeTag = xhtmlClose
- }
-
- if renderParameters.FootnoteReturnLinkContents == "" {
- renderParameters.FootnoteReturnLinkContents = `<sup>[return]</sup>`
- }
-
- return &Html{
- flags: flags,
- closeTag: closeTag,
- title: title,
- css: css,
- parameters: renderParameters,
-
- headerCount: 0,
- currentLevel: 0,
- toc: new(bytes.Buffer),
-
- headerIDs: make(map[string]int),
-
- smartypants: smartypants(flags),
- }
-}
-
-// Using if statements is a bit faster than a switch statement. As the compiler
-// improves, this should be unnecessary this is only worthwhile because
-// attrEscape is the single largest CPU user in normal use.
-// Also tried using map, but that gave a ~3x slowdown.
-func escapeSingleChar(char byte) (string, bool) {
- if char == '"' {
- return """, true
- }
- if char == '&' {
- return "&", true
- }
- if char == '<' {
- return "<", true
- }
- if char == '>' {
- return ">", true
- }
- return "", false
-}
-
-func attrEscape(out *bytes.Buffer, src []byte) {
- org := 0
- for i, ch := range src {
- if entity, ok := escapeSingleChar(ch); ok {
- if i > org {
- // copy all the normal characters since the last escape
- out.Write(src[org:i])
- }
- org = i + 1
- out.WriteString(entity)
- }
- }
- if org < len(src) {
- out.Write(src[org:])
- }
-}
-
-func entityEscapeWithSkip(out *bytes.Buffer, src []byte, skipRanges [][]int) {
- end := 0
- for _, rang := range skipRanges {
- attrEscape(out, src[end:rang[0]])
- out.Write(src[rang[0]:rang[1]])
- end = rang[1]
- }
- attrEscape(out, src[end:])
-}
-
-func (options *Html) GetFlags() int {
- return options.flags
-}
-
-func (options *Html) TitleBlock(out *bytes.Buffer, text []byte) {
- text = bytes.TrimPrefix(text, []byte("% "))
- text = bytes.Replace(text, []byte("\n% "), []byte("\n"), -1)
- out.WriteString("<h1 class=\"title\">")
- out.Write(text)
- out.WriteString("\n</h1>")
-}
-
-func (options *Html) Header(out *bytes.Buffer, text func() bool, level int, id string) {
- marker := out.Len()
- doubleSpace(out)
-
- if id == "" && options.flags&HTML_TOC != 0 {
- id = fmt.Sprintf("toc_%d", options.headerCount)
- }
-
- if id != "" {
- id = options.ensureUniqueHeaderID(id)
-
- if options.parameters.HeaderIDPrefix != "" {
- id = options.parameters.HeaderIDPrefix + id
- }
-
- if options.parameters.HeaderIDSuffix != "" {
- id = id + options.parameters.HeaderIDSuffix
- }
-
- out.WriteString(fmt.Sprintf("<h%d id=\"%s\">", level, id))
- } else {
- out.WriteString(fmt.Sprintf("<h%d>", level))
- }
-
- tocMarker := out.Len()
- if !text() {
- out.Truncate(marker)
- return
- }
-
- // are we building a table of contents?
- if options.flags&HTML_TOC != 0 {
- options.TocHeaderWithAnchor(out.Bytes()[tocMarker:], level, id)
- }
-
- out.WriteString(fmt.Sprintf("</h%d>\n", level))
-}
-
-func (options *Html) BlockHtml(out *bytes.Buffer, text []byte) {
- if options.flags&HTML_SKIP_HTML != 0 {
- return
- }
-
- doubleSpace(out)
- out.Write(text)
- out.WriteByte('\n')
-}
-
-func (options *Html) HRule(out *bytes.Buffer) {
- doubleSpace(out)
- out.WriteString("<hr")
- out.WriteString(options.closeTag)
-}
-
-func (options *Html) BlockCode(out *bytes.Buffer, text []byte, lang string) {
- doubleSpace(out)
-
- // parse out the language names/classes
- count := 0
- for _, elt := range strings.Fields(lang) {
- if elt[0] == '.' {
- elt = elt[1:]
- }
- if len(elt) == 0 {
- continue
- }
- if count == 0 {
- out.WriteString("<pre><code class=\"language-")
- } else {
- out.WriteByte(' ')
- }
- attrEscape(out, []byte(elt))
- count++
- }
-
- if count == 0 {
- out.WriteString("<pre><code>")
- } else {
- out.WriteString("\">")
- }
-
- attrEscape(out, text)
- out.WriteString("</code></pre>\n")
-}
-
-func (options *Html) BlockQuote(out *bytes.Buffer, text []byte) {
- doubleSpace(out)
- out.WriteString("<blockquote>\n")
- out.Write(text)
- out.WriteString("</blockquote>\n")
-}
-
-func (options *Html) Table(out *bytes.Buffer, header []byte, body []byte, columnData []int) {
- doubleSpace(out)
- out.WriteString("<table>\n<thead>\n")
- out.Write(header)
- out.WriteString("</thead>\n\n<tbody>\n")
- out.Write(body)
- out.WriteString("</tbody>\n</table>\n")
-}
-
-func (options *Html) TableRow(out *bytes.Buffer, text []byte) {
- doubleSpace(out)
- out.WriteString("<tr>\n")
- out.Write(text)
- out.WriteString("\n</tr>\n")
-}
-
-func (options *Html) TableHeaderCell(out *bytes.Buffer, text []byte, align int) {
- doubleSpace(out)
- switch align {
- case TABLE_ALIGNMENT_LEFT:
- out.WriteString("<th align=\"left\">")
- case TABLE_ALIGNMENT_RIGHT:
- out.WriteString("<th align=\"right\">")
- case TABLE_ALIGNMENT_CENTER:
- out.WriteString("<th align=\"center\">")
- default:
- out.WriteString("<th>")
- }
-
- out.Write(text)
- out.WriteString("</th>")
-}
-
-func (options *Html) TableCell(out *bytes.Buffer, text []byte, align int) {
- doubleSpace(out)
- switch align {
- case TABLE_ALIGNMENT_LEFT:
- out.WriteString("<td align=\"left\">")
- case TABLE_ALIGNMENT_RIGHT:
- out.WriteString("<td align=\"right\">")
- case TABLE_ALIGNMENT_CENTER:
- out.WriteString("<td align=\"center\">")
- default:
- out.WriteString("<td>")
- }
-
- out.Write(text)
- out.WriteString("</td>")
-}
-
-func (options *Html) Footnotes(out *bytes.Buffer, text func() bool) {
- out.WriteString("<div class=\"footnotes\">\n")
- options.HRule(out)
- options.List(out, text, LIST_TYPE_ORDERED)
- out.WriteString("</div>\n")
-}
-
-func (options *Html) FootnoteItem(out *bytes.Buffer, name, text []byte, flags int) {
- if flags&LIST_ITEM_CONTAINS_BLOCK != 0 || flags&LIST_ITEM_BEGINNING_OF_LIST != 0 {
- doubleSpace(out)
- }
- slug := slugify(name)
- out.WriteString(`<li id="`)
- out.WriteString(`fn:`)
- out.WriteString(options.parameters.FootnoteAnchorPrefix)
- out.Write(slug)
- out.WriteString(`">`)
- out.Write(text)
- if options.flags&HTML_FOOTNOTE_RETURN_LINKS != 0 {
- out.WriteString(` <a class="footnote-return" href="#`)
- out.WriteString(`fnref:`)
- out.WriteString(options.parameters.FootnoteAnchorPrefix)
- out.Write(slug)
- out.WriteString(`">`)
- out.WriteString(options.parameters.FootnoteReturnLinkContents)
- out.WriteString(`</a>`)
- }
- out.WriteString("</li>\n")
-}
-
-func (options *Html) List(out *bytes.Buffer, text func() bool, flags int) {
- marker := out.Len()
- doubleSpace(out)
-
- if flags&LIST_TYPE_ORDERED != 0 {
- out.WriteString("<ol>")
- } else {
- out.WriteString("<ul>")
- }
- if !text() {
- out.Truncate(marker)
- return
- }
- if flags&LIST_TYPE_ORDERED != 0 {
- out.WriteString("</ol>\n")
- } else {
- out.WriteString("</ul>\n")
- }
-}
-
-func (options *Html) ListItem(out *bytes.Buffer, text []byte, flags int) {
- if flags&LIST_ITEM_CONTAINS_BLOCK != 0 || flags&LIST_ITEM_BEGINNING_OF_LIST != 0 {
- doubleSpace(out)
- }
- out.WriteString("<li>")
- out.Write(text)
- out.WriteString("</li>\n")
-}
-
-func (options *Html) Paragraph(out *bytes.Buffer, text func() bool) {
- marker := out.Len()
- doubleSpace(out)
-
- out.WriteString("<p>")
- if !text() {
- out.Truncate(marker)
- return
- }
- out.WriteString("</p>\n")
-}
-
-func (options *Html) AutoLink(out *bytes.Buffer, link []byte, kind int) {
- skipRanges := htmlEntity.FindAllIndex(link, -1)
- if options.flags&HTML_SAFELINK != 0 && !isSafeLink(link) && kind != LINK_TYPE_EMAIL {
- // mark it but don't link it if it is not a safe link: no smartypants
- out.WriteString("<tt>")
- entityEscapeWithSkip(out, link, skipRanges)
- out.WriteString("</tt>")
- return
- }
-
- out.WriteString("<a href=\"")
- if kind == LINK_TYPE_EMAIL {
- out.WriteString("mailto:")
- } else {
- options.maybeWriteAbsolutePrefix(out, link)
- }
-
- entityEscapeWithSkip(out, link, skipRanges)
-
- if options.flags&HTML_NOFOLLOW_LINKS != 0 && !isRelativeLink(link) {
- out.WriteString("\" rel=\"nofollow")
- }
- // blank target only add to external link
- if options.flags&HTML_HREF_TARGET_BLANK != 0 && !isRelativeLink(link) {
- out.WriteString("\" target=\"_blank")
- }
-
- out.WriteString("\">")
-
- // Pretty print: if we get an email address as
- // an actual URI, e.g. `mailto:foo@bar.com`, we don't
- // want to print the `mailto:` prefix
- switch {
- case bytes.HasPrefix(link, []byte("mailto://")):
- attrEscape(out, link[len("mailto://"):])
- case bytes.HasPrefix(link, []byte("mailto:")):
- attrEscape(out, link[len("mailto:"):])
- default:
- entityEscapeWithSkip(out, link, skipRanges)
- }
-
- out.WriteString("</a>")
-}
-
-func (options *Html) CodeSpan(out *bytes.Buffer, text []byte) {
- out.WriteString("<code>")
- attrEscape(out, text)
- out.WriteString("</code>")
-}
-
-func (options *Html) DoubleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("<strong>")
- out.Write(text)
- out.WriteString("</strong>")
-}
-
-func (options *Html) Emphasis(out *bytes.Buffer, text []byte) {
- if len(text) == 0 {
- return
- }
- out.WriteString("<em>")
- out.Write(text)
- out.WriteString("</em>")
-}
-
-func (options *Html) maybeWriteAbsolutePrefix(out *bytes.Buffer, link []byte) {
- if options.parameters.AbsolutePrefix != "" && isRelativeLink(link) {
- out.WriteString(options.parameters.AbsolutePrefix)
- if link[0] != '/' {
- out.WriteByte('/')
- }
- }
-}
-
-func (options *Html) Image(out *bytes.Buffer, link []byte, title []byte, alt []byte) {
- if options.flags&HTML_SKIP_IMAGES != 0 {
- return
- }
-
- out.WriteString("<img src=\"")
- options.maybeWriteAbsolutePrefix(out, link)
- attrEscape(out, link)
- out.WriteString("\" alt=\"")
- if len(alt) > 0 {
- attrEscape(out, alt)
- }
- if len(title) > 0 {
- out.WriteString("\" title=\"")
- attrEscape(out, title)
- }
-
- out.WriteByte('"')
- out.WriteString(options.closeTag)
- return
-}
-
-func (options *Html) LineBreak(out *bytes.Buffer) {
- out.WriteString("<br")
- out.WriteString(options.closeTag)
-}
-
-func (options *Html) Link(out *bytes.Buffer, link []byte, title []byte, content []byte) {
- if options.flags&HTML_SKIP_LINKS != 0 {
- // write the link text out but don't link it, just mark it with typewriter font
- out.WriteString("<tt>")
- attrEscape(out, content)
- out.WriteString("</tt>")
- return
- }
-
- if options.flags&HTML_SAFELINK != 0 && !isSafeLink(link) {
- // write the link text out but don't link it, just mark it with typewriter font
- out.WriteString("<tt>")
- attrEscape(out, content)
- out.WriteString("</tt>")
- return
- }
-
- out.WriteString("<a href=\"")
- options.maybeWriteAbsolutePrefix(out, link)
- attrEscape(out, link)
- if len(title) > 0 {
- out.WriteString("\" title=\"")
- attrEscape(out, title)
- }
- if options.flags&HTML_NOFOLLOW_LINKS != 0 && !isRelativeLink(link) {
- out.WriteString("\" rel=\"nofollow")
- }
- // blank target only add to external link
- if options.flags&HTML_HREF_TARGET_BLANK != 0 && !isRelativeLink(link) {
- out.WriteString("\" target=\"_blank")
- }
-
- out.WriteString("\">")
- out.Write(content)
- out.WriteString("</a>")
- return
-}
-
-func (options *Html) RawHtmlTag(out *bytes.Buffer, text []byte) {
- if options.flags&HTML_SKIP_HTML != 0 {
- return
- }
- if options.flags&HTML_SKIP_STYLE != 0 && isHtmlTag(text, "style") {
- return
- }
- if options.flags&HTML_SKIP_LINKS != 0 && isHtmlTag(text, "a") {
- return
- }
- if options.flags&HTML_SKIP_IMAGES != 0 && isHtmlTag(text, "img") {
- return
- }
- out.Write(text)
-}
-
-func (options *Html) TripleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("<strong><em>")
- out.Write(text)
- out.WriteString("</em></strong>")
-}
-
-func (options *Html) StrikeThrough(out *bytes.Buffer, text []byte) {
- out.WriteString("<del>")
- out.Write(text)
- out.WriteString("</del>")
-}
-
-func (options *Html) FootnoteRef(out *bytes.Buffer, ref []byte, id int) {
- slug := slugify(ref)
- out.WriteString(`<sup class="footnote-ref" id="`)
- out.WriteString(`fnref:`)
- out.WriteString(options.parameters.FootnoteAnchorPrefix)
- out.Write(slug)
- out.WriteString(`"><a rel="footnote" href="#`)
- out.WriteString(`fn:`)
- out.WriteString(options.parameters.FootnoteAnchorPrefix)
- out.Write(slug)
- out.WriteString(`">`)
- out.WriteString(strconv.Itoa(id))
- out.WriteString(`</a></sup>`)
-}
-
-func (options *Html) Entity(out *bytes.Buffer, entity []byte) {
- out.Write(entity)
-}
-
-func (options *Html) NormalText(out *bytes.Buffer, text []byte) {
- if options.flags&HTML_USE_SMARTYPANTS != 0 {
- options.Smartypants(out, text)
- } else {
- attrEscape(out, text)
- }
-}
-
-func (options *Html) Smartypants(out *bytes.Buffer, text []byte) {
- smrt := smartypantsData{false, false}
-
- // first do normal entity escaping
- var escaped bytes.Buffer
- attrEscape(&escaped, text)
- text = escaped.Bytes()
-
- mark := 0
- for i := 0; i < len(text); i++ {
- if action := options.smartypants[text[i]]; action != nil {
- if i > mark {
- out.Write(text[mark:i])
- }
-
- previousChar := byte(0)
- if i > 0 {
- previousChar = text[i-1]
- }
- i += action(out, &smrt, previousChar, text[i:])
- mark = i + 1
- }
- }
-
- if mark < len(text) {
- out.Write(text[mark:])
- }
-}
-
-func (options *Html) DocumentHeader(out *bytes.Buffer) {
- if options.flags&HTML_COMPLETE_PAGE == 0 {
- return
- }
-
- ending := ""
- if options.flags&HTML_USE_XHTML != 0 {
- out.WriteString("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" ")
- out.WriteString("\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n")
- out.WriteString("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n")
- ending = " /"
- } else {
- out.WriteString("<!DOCTYPE html>\n")
- out.WriteString("<html>\n")
- }
- out.WriteString("<head>\n")
- out.WriteString(" <title>")
- options.NormalText(out, []byte(options.title))
- out.WriteString("</title>\n")
- out.WriteString(" <meta name=\"GENERATOR\" content=\"Blackfriday Markdown Processor v")
- out.WriteString(VERSION)
- out.WriteString("\"")
- out.WriteString(ending)
- out.WriteString(">\n")
- out.WriteString(" <meta charset=\"utf-8\"")
- out.WriteString(ending)
- out.WriteString(">\n")
- if options.css != "" {
- out.WriteString(" <link rel=\"stylesheet\" type=\"text/css\" href=\"")
- attrEscape(out, []byte(options.css))
- out.WriteString("\"")
- out.WriteString(ending)
- out.WriteString(">\n")
- }
- out.WriteString("</head>\n")
- out.WriteString("<body>\n")
-
- options.tocMarker = out.Len()
-}
-
-func (options *Html) DocumentFooter(out *bytes.Buffer) {
- // finalize and insert the table of contents
- if options.flags&HTML_TOC != 0 {
- options.TocFinalize()
-
- // now we have to insert the table of contents into the document
- var temp bytes.Buffer
-
- // start by making a copy of everything after the document header
- temp.Write(out.Bytes()[options.tocMarker:])
-
- // now clear the copied material from the main output buffer
- out.Truncate(options.tocMarker)
-
- // corner case spacing issue
- if options.flags&HTML_COMPLETE_PAGE != 0 {
- out.WriteByte('\n')
- }
-
- // insert the table of contents
- out.WriteString("<nav>\n")
- out.Write(options.toc.Bytes())
- out.WriteString("</nav>\n")
-
- // corner case spacing issue
- if options.flags&HTML_COMPLETE_PAGE == 0 && options.flags&HTML_OMIT_CONTENTS == 0 {
- out.WriteByte('\n')
- }
-
- // write out everything that came after it
- if options.flags&HTML_OMIT_CONTENTS == 0 {
- out.Write(temp.Bytes())
- }
- }
-
- if options.flags&HTML_COMPLETE_PAGE != 0 {
- out.WriteString("\n</body>\n")
- out.WriteString("</html>\n")
- }
-
-}
-
-func (options *Html) TocHeaderWithAnchor(text []byte, level int, anchor string) {
- for level > options.currentLevel {
- switch {
- case bytes.HasSuffix(options.toc.Bytes(), []byte("</li>\n")):
- // this sublist can nest underneath a header
- size := options.toc.Len()
- options.toc.Truncate(size - len("</li>\n"))
-
- case options.currentLevel > 0:
- options.toc.WriteString("<li>")
- }
- if options.toc.Len() > 0 {
- options.toc.WriteByte('\n')
- }
- options.toc.WriteString("<ul>\n")
- options.currentLevel++
- }
-
- for level < options.currentLevel {
- options.toc.WriteString("</ul>")
- if options.currentLevel > 1 {
- options.toc.WriteString("</li>\n")
- }
- options.currentLevel--
- }
-
- options.toc.WriteString("<li><a href=\"#")
- if anchor != "" {
- options.toc.WriteString(anchor)
- } else {
- options.toc.WriteString("toc_")
- options.toc.WriteString(strconv.Itoa(options.headerCount))
- }
- options.toc.WriteString("\">")
- options.headerCount++
-
- options.toc.Write(text)
-
- options.toc.WriteString("</a></li>\n")
-}
-
-func (options *Html) TocHeader(text []byte, level int) {
- options.TocHeaderWithAnchor(text, level, "")
-}
-
-func (options *Html) TocFinalize() {
- for options.currentLevel > 1 {
- options.toc.WriteString("</ul></li>\n")
- options.currentLevel--
- }
-
- if options.currentLevel > 0 {
- options.toc.WriteString("</ul>\n")
- }
-}
-
-func isHtmlTag(tag []byte, tagname string) bool {
- found, _ := findHtmlTagPos(tag, tagname)
- return found
-}
-
-// Look for a character, but ignore it when it's in any kind of quotes, it
-// might be JavaScript
-func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int {
- inSingleQuote := false
- inDoubleQuote := false
- inGraveQuote := false
- i := start
- for i < len(html) {
- switch {
- case html[i] == char && !inSingleQuote && !inDoubleQuote && !inGraveQuote:
- return i
- case html[i] == '\'':
- inSingleQuote = !inSingleQuote
- case html[i] == '"':
- inDoubleQuote = !inDoubleQuote
- case html[i] == '`':
- inGraveQuote = !inGraveQuote
- }
- i++
- }
- return start
-}
-
-func findHtmlTagPos(tag []byte, tagname string) (bool, int) {
- i := 0
- if i < len(tag) && tag[0] != '<' {
- return false, -1
- }
- i++
- i = skipSpace(tag, i)
-
- if i < len(tag) && tag[i] == '/' {
- i++
- }
-
- i = skipSpace(tag, i)
- j := 0
- for ; i < len(tag); i, j = i+1, j+1 {
- if j >= len(tagname) {
- break
- }
-
- if strings.ToLower(string(tag[i]))[0] != tagname[j] {
- return false, -1
- }
- }
-
- if i == len(tag) {
- return false, -1
- }
-
- rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')
- if rightAngle > i {
- return true, rightAngle
- }
-
- return false, -1
-}
-
-func skipUntilChar(text []byte, start int, char byte) int {
- i := start
- for i < len(text) && text[i] != char {
- i++
- }
- return i
-}
-
-func skipSpace(tag []byte, i int) int {
- for i < len(tag) && isspace(tag[i]) {
- i++
- }
- return i
-}
-
-func doubleSpace(out *bytes.Buffer) {
- if out.Len() > 0 {
- out.WriteByte('\n')
- }
-}
-
-func isRelativeLink(link []byte) (yes bool) {
- yes = false
-
- // a tag begin with '#'
- if link[0] == '#' {
- yes = true
- }
-
- // link begin with '/' but not '//', the second maybe a protocol relative link
- if len(link) >= 2 && link[0] == '/' && link[1] != '/' {
- yes = true
- }
-
- // only the root '/'
- if len(link) == 1 && link[0] == '/' {
- yes = true
- }
- return
-}
-
-func (options *Html) ensureUniqueHeaderID(id string) string {
- for count, found := options.headerIDs[id]; found; count, found = options.headerIDs[id] {
- tmp := fmt.Sprintf("%s-%d", id, count+1)
-
- if _, tmpFound := options.headerIDs[tmp]; !tmpFound {
- options.headerIDs[id] = count + 1
- id = tmp
- } else {
- id = id + "-1"
- }
- }
-
- if _, found := options.headerIDs[id]; !found {
- options.headerIDs[id] = 0
- }
-
- return id
-}
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/inline.go b/Godeps/_workspace/src/github.com/russross/blackfriday/inline.go
deleted file mode 100644
index f76d7b375cdea670585bdac5ba1c062b5d888fd9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/inline.go
+++ /dev/null
@@ -1,1080 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-// Functions to parse inline elements.
-//
-
-package blackfriday
-
-import (
- "bytes"
- "regexp"
- "strconv"
-)
-
-var (
- urlRe = `((https?|ftp):\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+`
- anchorRe = regexp.MustCompile(`^(<a\shref="` + urlRe + `"(\stitle="[^"<>]+")?\s?>` + urlRe + `<\/a>)`)
-)
-
-// Functions to parse text within a block
-// Each function returns the number of chars taken care of
-// data is the complete block being rendered
-// offset is the number of valid chars before the current cursor
-
-func (p *parser) inline(out *bytes.Buffer, data []byte) {
- // this is called recursively: enforce a maximum depth
- if p.nesting >= p.maxNesting {
- return
- }
- p.nesting++
-
- i, end := 0, 0
- for i < len(data) {
- // copy inactive chars into the output
- for end < len(data) && p.inlineCallback[data[end]] == nil {
- end++
- }
-
- p.r.NormalText(out, data[i:end])
-
- if end >= len(data) {
- break
- }
- i = end
-
- // call the trigger
- handler := p.inlineCallback[data[end]]
- if consumed := handler(p, out, data, i); consumed == 0 {
- // no action from the callback; buffer the byte for later
- end = i + 1
- } else {
- // skip past whatever the callback used
- i += consumed
- end = i
- }
- }
-
- p.nesting--
-}
-
-// single and double emphasis parsing
-func emphasis(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- data = data[offset:]
- c := data[0]
- ret := 0
-
- if len(data) > 2 && data[1] != c {
- // whitespace cannot follow an opening emphasis;
- // strikethrough only takes two characters '~~'
- if c == '~' || isspace(data[1]) {
- return 0
- }
- if ret = helperEmphasis(p, out, data[1:], c); ret == 0 {
- return 0
- }
-
- return ret + 1
- }
-
- if len(data) > 3 && data[1] == c && data[2] != c {
- if isspace(data[2]) {
- return 0
- }
- if ret = helperDoubleEmphasis(p, out, data[2:], c); ret == 0 {
- return 0
- }
-
- return ret + 2
- }
-
- if len(data) > 4 && data[1] == c && data[2] == c && data[3] != c {
- if c == '~' || isspace(data[3]) {
- return 0
- }
- if ret = helperTripleEmphasis(p, out, data, 3, c); ret == 0 {
- return 0
- }
-
- return ret + 3
- }
-
- return 0
-}
-
-func codeSpan(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- data = data[offset:]
-
- nb := 0
-
- // count the number of backticks in the delimiter
- for nb < len(data) && data[nb] == '`' {
- nb++
- }
-
- // find the next delimiter
- i, end := 0, 0
- for end = nb; end < len(data) && i < nb; end++ {
- if data[end] == '`' {
- i++
- } else {
- i = 0
- }
- }
-
- // no matching delimiter?
- if i < nb && end >= len(data) {
- return 0
- }
-
- // trim outside whitespace
- fBegin := nb
- for fBegin < end && data[fBegin] == ' ' {
- fBegin++
- }
-
- fEnd := end - nb
- for fEnd > fBegin && data[fEnd-1] == ' ' {
- fEnd--
- }
-
- // render the code span
- if fBegin != fEnd {
- p.r.CodeSpan(out, data[fBegin:fEnd])
- }
-
- return end
-
-}
-
-// newline preceded by two spaces becomes <br>
-// newline without two spaces works when EXTENSION_HARD_LINE_BREAK is enabled
-func lineBreak(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- // remove trailing spaces from out
- outBytes := out.Bytes()
- end := len(outBytes)
- eol := end
- for eol > 0 && outBytes[eol-1] == ' ' {
- eol--
- }
- out.Truncate(eol)
-
- precededByTwoSpaces := offset >= 2 && data[offset-2] == ' ' && data[offset-1] == ' '
-
- // should there be a hard line break here?
- if p.flags&EXTENSION_HARD_LINE_BREAK == 0 && !precededByTwoSpaces {
- return 0
- }
-
- p.r.LineBreak(out)
- return 1
-}
-
-type linkType int
-
-const (
- linkNormal linkType = iota
- linkImg
- linkDeferredFootnote
- linkInlineFootnote
-)
-
-// '[': parse a link or an image or a footnote
-func link(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- // no links allowed inside regular links, footnote, and deferred footnotes
- if p.insideLink && (offset > 0 && data[offset-1] == '[' || len(data)-1 > offset && data[offset+1] == '^') {
- return 0
- }
-
- // [text] == regular link
- // ![alt] == image
- // ^[text] == inline footnote
- // [^refId] == deferred footnote
- var t linkType
- if offset > 0 && data[offset-1] == '!' {
- t = linkImg
- } else if p.flags&EXTENSION_FOOTNOTES != 0 {
- if offset > 0 && data[offset-1] == '^' {
- t = linkInlineFootnote
- } else if len(data)-1 > offset && data[offset+1] == '^' {
- t = linkDeferredFootnote
- }
- }
-
- data = data[offset:]
-
- var (
- i = 1
- noteId int
- title, link []byte
- textHasNl = false
- )
-
- if t == linkDeferredFootnote {
- i++
- }
-
- // look for the matching closing bracket
- for level := 1; level > 0 && i < len(data); i++ {
- switch {
- case data[i] == '\n':
- textHasNl = true
-
- case data[i-1] == '\\':
- continue
-
- case data[i] == '[':
- level++
-
- case data[i] == ']':
- level--
- if level <= 0 {
- i-- // compensate for extra i++ in for loop
- }
- }
- }
-
- if i >= len(data) {
- return 0
- }
-
- txtE := i
- i++
-
- // skip any amount of whitespace or newline
- // (this is much more lax than original markdown syntax)
- for i < len(data) && isspace(data[i]) {
- i++
- }
-
- // inline style link
- switch {
- case i < len(data) && data[i] == '(':
- // skip initial whitespace
- i++
-
- for i < len(data) && isspace(data[i]) {
- i++
- }
-
- linkB := i
-
- // look for link end: ' " )
- findlinkend:
- for i < len(data) {
- switch {
- case data[i] == '\\':
- i += 2
-
- case data[i] == ')' || data[i] == '\'' || data[i] == '"':
- break findlinkend
-
- default:
- i++
- }
- }
-
- if i >= len(data) {
- return 0
- }
- linkE := i
-
- // look for title end if present
- titleB, titleE := 0, 0
- if data[i] == '\'' || data[i] == '"' {
- i++
- titleB = i
-
- findtitleend:
- for i < len(data) {
- switch {
- case data[i] == '\\':
- i += 2
-
- case data[i] == ')':
- break findtitleend
-
- default:
- i++
- }
- }
-
- if i >= len(data) {
- return 0
- }
-
- // skip whitespace after title
- titleE = i - 1
- for titleE > titleB && isspace(data[titleE]) {
- titleE--
- }
-
- // check for closing quote presence
- if data[titleE] != '\'' && data[titleE] != '"' {
- titleB, titleE = 0, 0
- linkE = i
- }
- }
-
- // remove whitespace at the end of the link
- for linkE > linkB && isspace(data[linkE-1]) {
- linkE--
- }
-
- // remove optional angle brackets around the link
- if data[linkB] == '<' {
- linkB++
- }
- if data[linkE-1] == '>' {
- linkE--
- }
-
- // build escaped link and title
- if linkE > linkB {
- link = data[linkB:linkE]
- }
-
- if titleE > titleB {
- title = data[titleB:titleE]
- }
-
- i++
-
- // reference style link
- case i < len(data) && data[i] == '[':
- var id []byte
-
- // look for the id
- i++
- linkB := i
- for i < len(data) && data[i] != ']' {
- i++
- }
- if i >= len(data) {
- return 0
- }
- linkE := i
-
- // find the reference
- if linkB == linkE {
- if textHasNl {
- var b bytes.Buffer
-
- for j := 1; j < txtE; j++ {
- switch {
- case data[j] != '\n':
- b.WriteByte(data[j])
- case data[j-1] != ' ':
- b.WriteByte(' ')
- }
- }
-
- id = b.Bytes()
- } else {
- id = data[1:txtE]
- }
- } else {
- id = data[linkB:linkE]
- }
-
- // find the reference with matching id (ids are case-insensitive)
- key := string(bytes.ToLower(id))
- lr, ok := p.refs[key]
- if !ok {
- return 0
-
- }
-
- // keep link and title from reference
- link = lr.link
- title = lr.title
- i++
-
- // shortcut reference style link or reference or inline footnote
- default:
- var id []byte
-
- // craft the id
- if textHasNl {
- var b bytes.Buffer
-
- for j := 1; j < txtE; j++ {
- switch {
- case data[j] != '\n':
- b.WriteByte(data[j])
- case data[j-1] != ' ':
- b.WriteByte(' ')
- }
- }
-
- id = b.Bytes()
- } else {
- if t == linkDeferredFootnote {
- id = data[2:txtE] // get rid of the ^
- } else {
- id = data[1:txtE]
- }
- }
-
- key := string(bytes.ToLower(id))
- if t == linkInlineFootnote {
- // create a new reference
- noteId = len(p.notes) + 1
-
- var fragment []byte
- if len(id) > 0 {
- if len(id) < 16 {
- fragment = make([]byte, len(id))
- } else {
- fragment = make([]byte, 16)
- }
- copy(fragment, slugify(id))
- } else {
- fragment = append([]byte("footnote-"), []byte(strconv.Itoa(noteId))...)
- }
-
- ref := &reference{
- noteId: noteId,
- hasBlock: false,
- link: fragment,
- title: id,
- }
-
- p.notes = append(p.notes, ref)
-
- link = ref.link
- title = ref.title
- } else {
- // find the reference with matching id
- lr, ok := p.refs[key]
- if !ok {
- return 0
- }
-
- if t == linkDeferredFootnote {
- lr.noteId = len(p.notes) + 1
- p.notes = append(p.notes, lr)
- }
-
- // keep link and title from reference
- link = lr.link
- // if inline footnote, title == footnote contents
- title = lr.title
- noteId = lr.noteId
- }
-
- // rewind the whitespace
- i = txtE + 1
- }
-
- // build content: img alt is escaped, link content is parsed
- var content bytes.Buffer
- if txtE > 1 {
- if t == linkImg {
- content.Write(data[1:txtE])
- } else {
- // links cannot contain other links, so turn off link parsing temporarily
- insideLink := p.insideLink
- p.insideLink = true
- p.inline(&content, data[1:txtE])
- p.insideLink = insideLink
- }
- }
-
- var uLink []byte
- if t == linkNormal || t == linkImg {
- if len(link) > 0 {
- var uLinkBuf bytes.Buffer
- unescapeText(&uLinkBuf, link)
- uLink = uLinkBuf.Bytes()
- }
-
- // links need something to click on and somewhere to go
- if len(uLink) == 0 || (t == linkNormal && content.Len() == 0) {
- return 0
- }
- }
-
- // call the relevant rendering function
- switch t {
- case linkNormal:
- p.r.Link(out, uLink, title, content.Bytes())
-
- case linkImg:
- outSize := out.Len()
- outBytes := out.Bytes()
- if outSize > 0 && outBytes[outSize-1] == '!' {
- out.Truncate(outSize - 1)
- }
-
- p.r.Image(out, uLink, title, content.Bytes())
-
- case linkInlineFootnote:
- outSize := out.Len()
- outBytes := out.Bytes()
- if outSize > 0 && outBytes[outSize-1] == '^' {
- out.Truncate(outSize - 1)
- }
-
- p.r.FootnoteRef(out, link, noteId)
-
- case linkDeferredFootnote:
- p.r.FootnoteRef(out, link, noteId)
-
- default:
- return 0
- }
-
- return i
-}
-
-// '<' when tags or autolinks are allowed
-func leftAngle(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- data = data[offset:]
- altype := LINK_TYPE_NOT_AUTOLINK
- end := tagLength(data, &altype)
-
- if end > 2 {
- if altype != LINK_TYPE_NOT_AUTOLINK {
- var uLink bytes.Buffer
- unescapeText(&uLink, data[1:end+1-2])
- if uLink.Len() > 0 {
- p.r.AutoLink(out, uLink.Bytes(), altype)
- }
- } else {
- p.r.RawHtmlTag(out, data[:end])
- }
- }
-
- return end
-}
-
-// '\\' backslash escape
-var escapeChars = []byte("\\`*_{}[]()#+-.!:|&<>~")
-
-func escape(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- data = data[offset:]
-
- if len(data) > 1 {
- if bytes.IndexByte(escapeChars, data[1]) < 0 {
- return 0
- }
-
- p.r.NormalText(out, data[1:2])
- }
-
- return 2
-}
-
-func unescapeText(ob *bytes.Buffer, src []byte) {
- i := 0
- for i < len(src) {
- org := i
- for i < len(src) && src[i] != '\\' {
- i++
- }
-
- if i > org {
- ob.Write(src[org:i])
- }
-
- if i+1 >= len(src) {
- break
- }
-
- ob.WriteByte(src[i+1])
- i += 2
- }
-}
-
-// '&' escaped when it doesn't belong to an entity
-// valid entities are assumed to be anything matching &#?[A-Za-z0-9]+;
-func entity(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- data = data[offset:]
-
- end := 1
-
- if end < len(data) && data[end] == '#' {
- end++
- }
-
- for end < len(data) && isalnum(data[end]) {
- end++
- }
-
- if end < len(data) && data[end] == ';' {
- end++ // real entity
- } else {
- return 0 // lone '&'
- }
-
- p.r.Entity(out, data[:end])
-
- return end
-}
-
-func linkEndsWithEntity(data []byte, linkEnd int) bool {
- entityRanges := htmlEntity.FindAllIndex(data[:linkEnd], -1)
- if entityRanges != nil && entityRanges[len(entityRanges)-1][1] == linkEnd {
- return true
- }
- return false
-}
-
-func autoLink(p *parser, out *bytes.Buffer, data []byte, offset int) int {
- // quick check to rule out most false hits on ':'
- if p.insideLink || len(data) < offset+3 || data[offset+1] != '/' || data[offset+2] != '/' {
- return 0
- }
-
- // Now a more expensive check to see if we're not inside an anchor element
- anchorStart := offset
- offsetFromAnchor := 0
- for anchorStart > 0 && data[anchorStart] != '<' {
- anchorStart--
- offsetFromAnchor++
- }
-
- anchorStr := anchorRe.Find(data[anchorStart:])
- if anchorStr != nil {
- out.Write(anchorStr[offsetFromAnchor:])
- return len(anchorStr) - offsetFromAnchor
- }
-
- // scan backward for a word boundary
- rewind := 0
- for offset-rewind > 0 && rewind <= 7 && isletter(data[offset-rewind-1]) {
- rewind++
- }
- if rewind > 6 { // longest supported protocol is "mailto" which has 6 letters
- return 0
- }
-
- origData := data
- data = data[offset-rewind:]
-
- if !isSafeLink(data) {
- return 0
- }
-
- linkEnd := 0
- for linkEnd < len(data) && !isEndOfLink(data[linkEnd]) {
- linkEnd++
- }
-
- // Skip punctuation at the end of the link
- if (data[linkEnd-1] == '.' || data[linkEnd-1] == ',') && data[linkEnd-2] != '\\' {
- linkEnd--
- }
-
- // But don't skip semicolon if it's a part of escaped entity:
- if data[linkEnd-1] == ';' && data[linkEnd-2] != '\\' && !linkEndsWithEntity(data, linkEnd) {
- linkEnd--
- }
-
- // See if the link finishes with a punctuation sign that can be closed.
- var copen byte
- switch data[linkEnd-1] {
- case '"':
- copen = '"'
- case '\'':
- copen = '\''
- case ')':
- copen = '('
- case ']':
- copen = '['
- case '}':
- copen = '{'
- default:
- copen = 0
- }
-
- if copen != 0 {
- bufEnd := offset - rewind + linkEnd - 2
-
- openDelim := 1
-
- /* Try to close the final punctuation sign in this same line;
- * if we managed to close it outside of the URL, that means that it's
- * not part of the URL. If it closes inside the URL, that means it
- * is part of the URL.
- *
- * Examples:
- *
- * foo http://www.pokemon.com/Pikachu_(Electric) bar
- * => http://www.pokemon.com/Pikachu_(Electric)
- *
- * foo (http://www.pokemon.com/Pikachu_(Electric)) bar
- * => http://www.pokemon.com/Pikachu_(Electric)
- *
- * foo http://www.pokemon.com/Pikachu_(Electric)) bar
- * => http://www.pokemon.com/Pikachu_(Electric))
- *
- * (foo http://www.pokemon.com/Pikachu_(Electric)) bar
- * => foo http://www.pokemon.com/Pikachu_(Electric)
- */
-
- for bufEnd >= 0 && origData[bufEnd] != '\n' && openDelim != 0 {
- if origData[bufEnd] == data[linkEnd-1] {
- openDelim++
- }
-
- if origData[bufEnd] == copen {
- openDelim--
- }
-
- bufEnd--
- }
-
- if openDelim == 0 {
- linkEnd--
- }
- }
-
- // we were triggered on the ':', so we need to rewind the output a bit
- if out.Len() >= rewind {
- out.Truncate(len(out.Bytes()) - rewind)
- }
-
- var uLink bytes.Buffer
- unescapeText(&uLink, data[:linkEnd])
-
- if uLink.Len() > 0 {
- p.r.AutoLink(out, uLink.Bytes(), LINK_TYPE_NORMAL)
- }
-
- return linkEnd - rewind
-}
-
-func isEndOfLink(char byte) bool {
- return isspace(char) || char == '<'
-}
-
-var validUris = [][]byte{[]byte("http://"), []byte("https://"), []byte("ftp://"), []byte("mailto://"), []byte("/")}
-
-func isSafeLink(link []byte) bool {
- for _, prefix := range validUris {
- // TODO: handle unicode here
- // case-insensitive prefix test
- if len(link) > len(prefix) && bytes.Equal(bytes.ToLower(link[:len(prefix)]), prefix) && isalnum(link[len(prefix)]) {
- return true
- }
- }
-
- return false
-}
-
-// return the length of the given tag, or 0 is it's not valid
-func tagLength(data []byte, autolink *int) int {
- var i, j int
-
- // a valid tag can't be shorter than 3 chars
- if len(data) < 3 {
- return 0
- }
-
- // begins with a '<' optionally followed by '/', followed by letter or number
- if data[0] != '<' {
- return 0
- }
- if data[1] == '/' {
- i = 2
- } else {
- i = 1
- }
-
- if !isalnum(data[i]) {
- return 0
- }
-
- // scheme test
- *autolink = LINK_TYPE_NOT_AUTOLINK
-
- // try to find the beginning of an URI
- for i < len(data) && (isalnum(data[i]) || data[i] == '.' || data[i] == '+' || data[i] == '-') {
- i++
- }
-
- if i > 1 && i < len(data) && data[i] == '@' {
- if j = isMailtoAutoLink(data[i:]); j != 0 {
- *autolink = LINK_TYPE_EMAIL
- return i + j
- }
- }
-
- if i > 2 && i < len(data) && data[i] == ':' {
- *autolink = LINK_TYPE_NORMAL
- i++
- }
-
- // complete autolink test: no whitespace or ' or "
- switch {
- case i >= len(data):
- *autolink = LINK_TYPE_NOT_AUTOLINK
- case *autolink != 0:
- j = i
-
- for i < len(data) {
- if data[i] == '\\' {
- i += 2
- } else if data[i] == '>' || data[i] == '\'' || data[i] == '"' || isspace(data[i]) {
- break
- } else {
- i++
- }
-
- }
-
- if i >= len(data) {
- return 0
- }
- if i > j && data[i] == '>' {
- return i + 1
- }
-
- // one of the forbidden chars has been found
- *autolink = LINK_TYPE_NOT_AUTOLINK
- }
-
- // look for something looking like a tag end
- for i < len(data) && data[i] != '>' {
- i++
- }
- if i >= len(data) {
- return 0
- }
- return i + 1
-}
-
-// look for the address part of a mail autolink and '>'
-// this is less strict than the original markdown e-mail address matching
-func isMailtoAutoLink(data []byte) int {
- nb := 0
-
- // address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@'
- for i := 0; i < len(data); i++ {
- if isalnum(data[i]) {
- continue
- }
-
- switch data[i] {
- case '@':
- nb++
-
- case '-', '.', '_':
- break
-
- case '>':
- if nb == 1 {
- return i + 1
- } else {
- return 0
- }
- default:
- return 0
- }
- }
-
- return 0
-}
-
-// look for the next emph char, skipping other constructs
-func helperFindEmphChar(data []byte, c byte) int {
- i := 1
-
- for i < len(data) {
- for i < len(data) && data[i] != c && data[i] != '`' && data[i] != '[' {
- i++
- }
- if i >= len(data) {
- return 0
- }
- if data[i] == c {
- return i
- }
-
- // do not count escaped chars
- if i != 0 && data[i-1] == '\\' {
- i++
- continue
- }
-
- if data[i] == '`' {
- // skip a code span
- tmpI := 0
- i++
- for i < len(data) && data[i] != '`' {
- if tmpI == 0 && data[i] == c {
- tmpI = i
- }
- i++
- }
- if i >= len(data) {
- return tmpI
- }
- i++
- } else if data[i] == '[' {
- // skip a link
- tmpI := 0
- i++
- for i < len(data) && data[i] != ']' {
- if tmpI == 0 && data[i] == c {
- tmpI = i
- }
- i++
- }
- i++
- for i < len(data) && (data[i] == ' ' || data[i] == '\n') {
- i++
- }
- if i >= len(data) {
- return tmpI
- }
- if data[i] != '[' && data[i] != '(' { // not a link
- if tmpI > 0 {
- return tmpI
- } else {
- continue
- }
- }
- cc := data[i]
- i++
- for i < len(data) && data[i] != cc {
- if tmpI == 0 && data[i] == c {
- return i
- }
- i++
- }
- if i >= len(data) {
- return tmpI
- }
- i++
- }
- }
- return 0
-}
-
-func helperEmphasis(p *parser, out *bytes.Buffer, data []byte, c byte) int {
- i := 0
-
- // skip one symbol if coming from emph3
- if len(data) > 1 && data[0] == c && data[1] == c {
- i = 1
- }
-
- for i < len(data) {
- length := helperFindEmphChar(data[i:], c)
- if length == 0 {
- return 0
- }
- i += length
- if i >= len(data) {
- return 0
- }
-
- if i+1 < len(data) && data[i+1] == c {
- i++
- continue
- }
-
- if data[i] == c && !isspace(data[i-1]) {
-
- if p.flags&EXTENSION_NO_INTRA_EMPHASIS != 0 {
- if !(i+1 == len(data) || isspace(data[i+1]) || ispunct(data[i+1])) {
- continue
- }
- }
-
- var work bytes.Buffer
- p.inline(&work, data[:i])
- p.r.Emphasis(out, work.Bytes())
- return i + 1
- }
- }
-
- return 0
-}
-
-func helperDoubleEmphasis(p *parser, out *bytes.Buffer, data []byte, c byte) int {
- i := 0
-
- for i < len(data) {
- length := helperFindEmphChar(data[i:], c)
- if length == 0 {
- return 0
- }
- i += length
-
- if i+1 < len(data) && data[i] == c && data[i+1] == c && i > 0 && !isspace(data[i-1]) {
- var work bytes.Buffer
- p.inline(&work, data[:i])
-
- if work.Len() > 0 {
- // pick the right renderer
- if c == '~' {
- p.r.StrikeThrough(out, work.Bytes())
- } else {
- p.r.DoubleEmphasis(out, work.Bytes())
- }
- }
- return i + 2
- }
- i++
- }
- return 0
-}
-
-func helperTripleEmphasis(p *parser, out *bytes.Buffer, data []byte, offset int, c byte) int {
- i := 0
- origData := data
- data = data[offset:]
-
- for i < len(data) {
- length := helperFindEmphChar(data[i:], c)
- if length == 0 {
- return 0
- }
- i += length
-
- // skip whitespace preceded symbols
- if data[i] != c || isspace(data[i-1]) {
- continue
- }
-
- switch {
- case i+2 < len(data) && data[i+1] == c && data[i+2] == c:
- // triple symbol found
- var work bytes.Buffer
-
- p.inline(&work, data[:i])
- if work.Len() > 0 {
- p.r.TripleEmphasis(out, work.Bytes())
- }
- return i + 3
- case (i+1 < len(data) && data[i+1] == c):
- // double symbol found, hand over to emph1
- length = helperEmphasis(p, out, origData[offset-2:], c)
- if length == 0 {
- return 0
- } else {
- return length - 2
- }
- default:
- // single symbol found, hand over to emph2
- length = helperDoubleEmphasis(p, out, origData[offset-1:], c)
- if length == 0 {
- return 0
- } else {
- return length - 1
- }
- }
- }
- return 0
-}
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/latex.go b/Godeps/_workspace/src/github.com/russross/blackfriday/latex.go
deleted file mode 100644
index 85627463b8f21e10b7c20249f89dbde86c353131..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/latex.go
+++ /dev/null
@@ -1,332 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-//
-// LaTeX rendering backend
-//
-//
-
-package blackfriday
-
-import (
- "bytes"
-)
-
-// Latex is a type that implements the Renderer interface for LaTeX output.
-//
-// Do not create this directly, instead use the LatexRenderer function.
-type Latex struct {
-}
-
-// LatexRenderer creates and configures a Latex object, which
-// satisfies the Renderer interface.
-//
-// flags is a set of LATEX_* options ORed together (currently no such options
-// are defined).
-func LatexRenderer(flags int) Renderer {
- return &Latex{}
-}
-
-func (options *Latex) GetFlags() int {
- return 0
-}
-
-// render code chunks using verbatim, or listings if we have a language
-func (options *Latex) BlockCode(out *bytes.Buffer, text []byte, lang string) {
- if lang == "" {
- out.WriteString("\n\\begin{verbatim}\n")
- } else {
- out.WriteString("\n\\begin{lstlisting}[language=")
- out.WriteString(lang)
- out.WriteString("]\n")
- }
- out.Write(text)
- if lang == "" {
- out.WriteString("\n\\end{verbatim}\n")
- } else {
- out.WriteString("\n\\end{lstlisting}\n")
- }
-}
-
-func (options *Latex) TitleBlock(out *bytes.Buffer, text []byte) {
-
-}
-
-func (options *Latex) BlockQuote(out *bytes.Buffer, text []byte) {
- out.WriteString("\n\\begin{quotation}\n")
- out.Write(text)
- out.WriteString("\n\\end{quotation}\n")
-}
-
-func (options *Latex) BlockHtml(out *bytes.Buffer, text []byte) {
- // a pretty lame thing to do...
- out.WriteString("\n\\begin{verbatim}\n")
- out.Write(text)
- out.WriteString("\n\\end{verbatim}\n")
-}
-
-func (options *Latex) Header(out *bytes.Buffer, text func() bool, level int, id string) {
- marker := out.Len()
-
- switch level {
- case 1:
- out.WriteString("\n\\section{")
- case 2:
- out.WriteString("\n\\subsection{")
- case 3:
- out.WriteString("\n\\subsubsection{")
- case 4:
- out.WriteString("\n\\paragraph{")
- case 5:
- out.WriteString("\n\\subparagraph{")
- case 6:
- out.WriteString("\n\\textbf{")
- }
- if !text() {
- out.Truncate(marker)
- return
- }
- out.WriteString("}\n")
-}
-
-func (options *Latex) HRule(out *bytes.Buffer) {
- out.WriteString("\n\\HRule\n")
-}
-
-func (options *Latex) List(out *bytes.Buffer, text func() bool, flags int) {
- marker := out.Len()
- if flags&LIST_TYPE_ORDERED != 0 {
- out.WriteString("\n\\begin{enumerate}\n")
- } else {
- out.WriteString("\n\\begin{itemize}\n")
- }
- if !text() {
- out.Truncate(marker)
- return
- }
- if flags&LIST_TYPE_ORDERED != 0 {
- out.WriteString("\n\\end{enumerate}\n")
- } else {
- out.WriteString("\n\\end{itemize}\n")
- }
-}
-
-func (options *Latex) ListItem(out *bytes.Buffer, text []byte, flags int) {
- out.WriteString("\n\\item ")
- out.Write(text)
-}
-
-func (options *Latex) Paragraph(out *bytes.Buffer, text func() bool) {
- marker := out.Len()
- out.WriteString("\n")
- if !text() {
- out.Truncate(marker)
- return
- }
- out.WriteString("\n")
-}
-
-func (options *Latex) Table(out *bytes.Buffer, header []byte, body []byte, columnData []int) {
- out.WriteString("\n\\begin{tabular}{")
- for _, elt := range columnData {
- switch elt {
- case TABLE_ALIGNMENT_LEFT:
- out.WriteByte('l')
- case TABLE_ALIGNMENT_RIGHT:
- out.WriteByte('r')
- default:
- out.WriteByte('c')
- }
- }
- out.WriteString("}\n")
- out.Write(header)
- out.WriteString(" \\\\\n\\hline\n")
- out.Write(body)
- out.WriteString("\n\\end{tabular}\n")
-}
-
-func (options *Latex) TableRow(out *bytes.Buffer, text []byte) {
- if out.Len() > 0 {
- out.WriteString(" \\\\\n")
- }
- out.Write(text)
-}
-
-func (options *Latex) TableHeaderCell(out *bytes.Buffer, text []byte, align int) {
- if out.Len() > 0 {
- out.WriteString(" & ")
- }
- out.Write(text)
-}
-
-func (options *Latex) TableCell(out *bytes.Buffer, text []byte, align int) {
- if out.Len() > 0 {
- out.WriteString(" & ")
- }
- out.Write(text)
-}
-
-// TODO: this
-func (options *Latex) Footnotes(out *bytes.Buffer, text func() bool) {
-
-}
-
-func (options *Latex) FootnoteItem(out *bytes.Buffer, name, text []byte, flags int) {
-
-}
-
-func (options *Latex) AutoLink(out *bytes.Buffer, link []byte, kind int) {
- out.WriteString("\\href{")
- if kind == LINK_TYPE_EMAIL {
- out.WriteString("mailto:")
- }
- out.Write(link)
- out.WriteString("}{")
- out.Write(link)
- out.WriteString("}")
-}
-
-func (options *Latex) CodeSpan(out *bytes.Buffer, text []byte) {
- out.WriteString("\\texttt{")
- escapeSpecialChars(out, text)
- out.WriteString("}")
-}
-
-func (options *Latex) DoubleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\textbf{")
- out.Write(text)
- out.WriteString("}")
-}
-
-func (options *Latex) Emphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\textit{")
- out.Write(text)
- out.WriteString("}")
-}
-
-func (options *Latex) Image(out *bytes.Buffer, link []byte, title []byte, alt []byte) {
- if bytes.HasPrefix(link, []byte("http://")) || bytes.HasPrefix(link, []byte("https://")) {
- // treat it like a link
- out.WriteString("\\href{")
- out.Write(link)
- out.WriteString("}{")
- out.Write(alt)
- out.WriteString("}")
- } else {
- out.WriteString("\\includegraphics{")
- out.Write(link)
- out.WriteString("}")
- }
-}
-
-func (options *Latex) LineBreak(out *bytes.Buffer) {
- out.WriteString(" \\\\\n")
-}
-
-func (options *Latex) Link(out *bytes.Buffer, link []byte, title []byte, content []byte) {
- out.WriteString("\\href{")
- out.Write(link)
- out.WriteString("}{")
- out.Write(content)
- out.WriteString("}")
-}
-
-func (options *Latex) RawHtmlTag(out *bytes.Buffer, tag []byte) {
-}
-
-func (options *Latex) TripleEmphasis(out *bytes.Buffer, text []byte) {
- out.WriteString("\\textbf{\\textit{")
- out.Write(text)
- out.WriteString("}}")
-}
-
-func (options *Latex) StrikeThrough(out *bytes.Buffer, text []byte) {
- out.WriteString("\\sout{")
- out.Write(text)
- out.WriteString("}")
-}
-
-// TODO: this
-func (options *Latex) FootnoteRef(out *bytes.Buffer, ref []byte, id int) {
-
-}
-
-func needsBackslash(c byte) bool {
- for _, r := range []byte("_{}%$&\\~") {
- if c == r {
- return true
- }
- }
- return false
-}
-
-func escapeSpecialChars(out *bytes.Buffer, text []byte) {
- for i := 0; i < len(text); i++ {
- // directly copy normal characters
- org := i
-
- for i < len(text) && !needsBackslash(text[i]) {
- i++
- }
- if i > org {
- out.Write(text[org:i])
- }
-
- // escape a character
- if i >= len(text) {
- break
- }
- out.WriteByte('\\')
- out.WriteByte(text[i])
- }
-}
-
-func (options *Latex) Entity(out *bytes.Buffer, entity []byte) {
- // TODO: convert this into a unicode character or something
- out.Write(entity)
-}
-
-func (options *Latex) NormalText(out *bytes.Buffer, text []byte) {
- escapeSpecialChars(out, text)
-}
-
-// header and footer
-func (options *Latex) DocumentHeader(out *bytes.Buffer) {
- out.WriteString("\\documentclass{article}\n")
- out.WriteString("\n")
- out.WriteString("\\usepackage{graphicx}\n")
- out.WriteString("\\usepackage{listings}\n")
- out.WriteString("\\usepackage[margin=1in]{geometry}\n")
- out.WriteString("\\usepackage[utf8]{inputenc}\n")
- out.WriteString("\\usepackage{verbatim}\n")
- out.WriteString("\\usepackage[normalem]{ulem}\n")
- out.WriteString("\\usepackage{hyperref}\n")
- out.WriteString("\n")
- out.WriteString("\\hypersetup{colorlinks,%\n")
- out.WriteString(" citecolor=black,%\n")
- out.WriteString(" filecolor=black,%\n")
- out.WriteString(" linkcolor=black,%\n")
- out.WriteString(" urlcolor=black,%\n")
- out.WriteString(" pdfstartview=FitH,%\n")
- out.WriteString(" breaklinks=true,%\n")
- out.WriteString(" pdfauthor={Blackfriday Markdown Processor v")
- out.WriteString(VERSION)
- out.WriteString("}}\n")
- out.WriteString("\n")
- out.WriteString("\\newcommand{\\HRule}{\\rule{\\linewidth}{0.5mm}}\n")
- out.WriteString("\\addtolength{\\parskip}{0.5\\baselineskip}\n")
- out.WriteString("\\parindent=0pt\n")
- out.WriteString("\n")
- out.WriteString("\\begin{document}\n")
-}
-
-func (options *Latex) DocumentFooter(out *bytes.Buffer) {
- out.WriteString("\n\\end{document}\n")
-}
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/markdown.go b/Godeps/_workspace/src/github.com/russross/blackfriday/markdown.go
deleted file mode 100644
index 4315488f3376337527294d510a46f7f314bf0ce7..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/markdown.go
+++ /dev/null
@@ -1,836 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-//
-// Markdown parsing and processing
-//
-//
-
-// Blackfriday markdown processor.
-//
-// Translates plain text with simple formatting rules into HTML or LaTeX.
-package blackfriday
-
-import (
- "bytes"
- "unicode/utf8"
-)
-
-const VERSION = "1.1"
-
-// These are the supported markdown parsing extensions.
-// OR these values together to select multiple extensions.
-const (
- EXTENSION_NO_INTRA_EMPHASIS = 1 << iota // ignore emphasis markers inside words
- EXTENSION_TABLES // render tables
- EXTENSION_FENCED_CODE // render fenced code blocks
- EXTENSION_AUTOLINK // detect embedded URLs that are not explicitly marked
- EXTENSION_STRIKETHROUGH // strikethrough text using ~~test~~
- EXTENSION_LAX_HTML_BLOCKS // loosen up HTML block parsing rules
- EXTENSION_SPACE_HEADERS // be strict about prefix header rules
- EXTENSION_HARD_LINE_BREAK // translate newlines into line breaks
- EXTENSION_TAB_SIZE_EIGHT // expand tabs to eight spaces instead of four
- EXTENSION_FOOTNOTES // Pandoc-style footnotes
- EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK // No need to insert an empty line to start a (code, quote, order list, unorder list)block
- EXTENSION_HEADER_IDS // specify header IDs with {#id}
- EXTENSION_TITLEBLOCK // Titleblock ala pandoc
- EXTENSION_AUTO_HEADER_IDS // Create the header ID from the text
-
- commonHtmlFlags = 0 |
- HTML_USE_XHTML |
- HTML_USE_SMARTYPANTS |
- HTML_SMARTYPANTS_FRACTIONS |
- HTML_SMARTYPANTS_LATEX_DASHES
-
- commonExtensions = 0 |
- EXTENSION_NO_INTRA_EMPHASIS |
- EXTENSION_TABLES |
- EXTENSION_FENCED_CODE |
- EXTENSION_AUTOLINK |
- EXTENSION_STRIKETHROUGH |
- EXTENSION_SPACE_HEADERS |
- EXTENSION_HEADER_IDS
-)
-
-// These are the possible flag values for the link renderer.
-// Only a single one of these values will be used; they are not ORed together.
-// These are mostly of interest if you are writing a new output format.
-const (
- LINK_TYPE_NOT_AUTOLINK = iota
- LINK_TYPE_NORMAL
- LINK_TYPE_EMAIL
-)
-
-// These are the possible flag values for the ListItem renderer.
-// Multiple flag values may be ORed together.
-// These are mostly of interest if you are writing a new output format.
-const (
- LIST_TYPE_ORDERED = 1 << iota
- LIST_ITEM_CONTAINS_BLOCK
- LIST_ITEM_BEGINNING_OF_LIST
- LIST_ITEM_END_OF_LIST
-)
-
-// These are the possible flag values for the table cell renderer.
-// Only a single one of these values will be used; they are not ORed together.
-// These are mostly of interest if you are writing a new output format.
-const (
- TABLE_ALIGNMENT_LEFT = 1 << iota
- TABLE_ALIGNMENT_RIGHT
- TABLE_ALIGNMENT_CENTER = (TABLE_ALIGNMENT_LEFT | TABLE_ALIGNMENT_RIGHT)
-)
-
-// The size of a tab stop.
-const (
- TAB_SIZE_DEFAULT = 4
- TAB_SIZE_EIGHT = 8
-)
-
-// These are the tags that are recognized as HTML block tags.
-// Any of these can be included in markdown text without special escaping.
-var blockTags = map[string]bool{
- "p": true,
- "dl": true,
- "h1": true,
- "h2": true,
- "h3": true,
- "h4": true,
- "h5": true,
- "h6": true,
- "ol": true,
- "ul": true,
- "del": true,
- "div": true,
- "ins": true,
- "pre": true,
- "form": true,
- "math": true,
- "table": true,
- "iframe": true,
- "script": true,
- "fieldset": true,
- "noscript": true,
- "blockquote": true,
-
- // HTML5
- "video": true,
- "aside": true,
- "canvas": true,
- "figure": true,
- "footer": true,
- "header": true,
- "hgroup": true,
- "output": true,
- "article": true,
- "section": true,
- "progress": true,
- "figcaption": true,
-}
-
-// Renderer is the rendering interface.
-// This is mostly of interest if you are implementing a new rendering format.
-//
-// When a byte slice is provided, it contains the (rendered) contents of the
-// element.
-//
-// When a callback is provided instead, it will write the contents of the
-// respective element directly to the output buffer and return true on success.
-// If the callback returns false, the rendering function should reset the
-// output buffer as though it had never been called.
-//
-// Currently Html and Latex implementations are provided
-type Renderer interface {
- // block-level callbacks
- BlockCode(out *bytes.Buffer, text []byte, lang string)
- BlockQuote(out *bytes.Buffer, text []byte)
- BlockHtml(out *bytes.Buffer, text []byte)
- Header(out *bytes.Buffer, text func() bool, level int, id string)
- HRule(out *bytes.Buffer)
- List(out *bytes.Buffer, text func() bool, flags int)
- ListItem(out *bytes.Buffer, text []byte, flags int)
- Paragraph(out *bytes.Buffer, text func() bool)
- Table(out *bytes.Buffer, header []byte, body []byte, columnData []int)
- TableRow(out *bytes.Buffer, text []byte)
- TableHeaderCell(out *bytes.Buffer, text []byte, flags int)
- TableCell(out *bytes.Buffer, text []byte, flags int)
- Footnotes(out *bytes.Buffer, text func() bool)
- FootnoteItem(out *bytes.Buffer, name, text []byte, flags int)
- TitleBlock(out *bytes.Buffer, text []byte)
-
- // Span-level callbacks
- AutoLink(out *bytes.Buffer, link []byte, kind int)
- CodeSpan(out *bytes.Buffer, text []byte)
- DoubleEmphasis(out *bytes.Buffer, text []byte)
- Emphasis(out *bytes.Buffer, text []byte)
- Image(out *bytes.Buffer, link []byte, title []byte, alt []byte)
- LineBreak(out *bytes.Buffer)
- Link(out *bytes.Buffer, link []byte, title []byte, content []byte)
- RawHtmlTag(out *bytes.Buffer, tag []byte)
- TripleEmphasis(out *bytes.Buffer, text []byte)
- StrikeThrough(out *bytes.Buffer, text []byte)
- FootnoteRef(out *bytes.Buffer, ref []byte, id int)
-
- // Low-level callbacks
- Entity(out *bytes.Buffer, entity []byte)
- NormalText(out *bytes.Buffer, text []byte)
-
- // Header and footer
- DocumentHeader(out *bytes.Buffer)
- DocumentFooter(out *bytes.Buffer)
-
- GetFlags() int
-}
-
-// Callback functions for inline parsing. One such function is defined
-// for each character that triggers a response when parsing inline data.
-type inlineParser func(p *parser, out *bytes.Buffer, data []byte, offset int) int
-
-// Parser holds runtime state used by the parser.
-// This is constructed by the Markdown function.
-type parser struct {
- r Renderer
- refs map[string]*reference
- inlineCallback [256]inlineParser
- flags int
- nesting int
- maxNesting int
- insideLink bool
-
- // Footnotes need to be ordered as well as available to quickly check for
- // presence. If a ref is also a footnote, it's stored both in refs and here
- // in notes. Slice is nil if footnotes not enabled.
- notes []*reference
-}
-
-//
-//
-// Public interface
-//
-//
-
-// MarkdownBasic is a convenience function for simple rendering.
-// It processes markdown input with no extensions enabled.
-func MarkdownBasic(input []byte) []byte {
- // set up the HTML renderer
- htmlFlags := HTML_USE_XHTML
- renderer := HtmlRenderer(htmlFlags, "", "")
-
- // set up the parser
- extensions := 0
-
- return Markdown(input, renderer, extensions)
-}
-
-// Call Markdown with most useful extensions enabled
-// MarkdownCommon is a convenience function for simple rendering.
-// It processes markdown input with common extensions enabled, including:
-//
-// * Smartypants processing with smart fractions and LaTeX dashes
-//
-// * Intra-word emphasis suppression
-//
-// * Tables
-//
-// * Fenced code blocks
-//
-// * Autolinking
-//
-// * Strikethrough support
-//
-// * Strict header parsing
-//
-// * Custom Header IDs
-func MarkdownCommon(input []byte) []byte {
- // set up the HTML renderer
- renderer := HtmlRenderer(commonHtmlFlags, "", "")
- return Markdown(input, renderer, commonExtensions)
-}
-
-// Markdown is the main rendering function.
-// It parses and renders a block of markdown-encoded text.
-// The supplied Renderer is used to format the output, and extensions dictates
-// which non-standard extensions are enabled.
-//
-// To use the supplied Html or LaTeX renderers, see HtmlRenderer and
-// LatexRenderer, respectively.
-func Markdown(input []byte, renderer Renderer, extensions int) []byte {
- // no point in parsing if we can't render
- if renderer == nil {
- return nil
- }
-
- // fill in the render structure
- p := new(parser)
- p.r = renderer
- p.flags = extensions
- p.refs = make(map[string]*reference)
- p.maxNesting = 16
- p.insideLink = false
-
- // register inline parsers
- p.inlineCallback['*'] = emphasis
- p.inlineCallback['_'] = emphasis
- if extensions&EXTENSION_STRIKETHROUGH != 0 {
- p.inlineCallback['~'] = emphasis
- }
- p.inlineCallback['`'] = codeSpan
- p.inlineCallback['\n'] = lineBreak
- p.inlineCallback['['] = link
- p.inlineCallback['<'] = leftAngle
- p.inlineCallback['\\'] = escape
- p.inlineCallback['&'] = entity
-
- if extensions&EXTENSION_AUTOLINK != 0 {
- p.inlineCallback[':'] = autoLink
- }
-
- if extensions&EXTENSION_FOOTNOTES != 0 {
- p.notes = make([]*reference, 0)
- }
-
- first := firstPass(p, input)
- second := secondPass(p, first)
- return second
-}
-
-// first pass:
-// - extract references
-// - expand tabs
-// - normalize newlines
-// - copy everything else
-// - add missing newlines before fenced code blocks
-func firstPass(p *parser, input []byte) []byte {
- var out bytes.Buffer
- tabSize := TAB_SIZE_DEFAULT
- if p.flags&EXTENSION_TAB_SIZE_EIGHT != 0 {
- tabSize = TAB_SIZE_EIGHT
- }
- beg, end := 0, 0
- lastLineWasBlank := false
- lastFencedCodeBlockEnd := 0
- for beg < len(input) { // iterate over lines
- if end = isReference(p, input[beg:], tabSize); end > 0 {
- beg += end
- } else { // skip to the next line
- end = beg
- for end < len(input) && input[end] != '\n' && input[end] != '\r' {
- end++
- }
-
- if p.flags&EXTENSION_FENCED_CODE != 0 {
- // when last line was none blank and a fenced code block comes after
- if beg >= lastFencedCodeBlockEnd {
- if i := p.fencedCode(&out, input[beg:], false); i > 0 {
- if !lastLineWasBlank {
- out.WriteByte('\n') // need to inject additional linebreak
- }
- lastFencedCodeBlockEnd = beg + i
- }
- }
- lastLineWasBlank = end == beg
- }
-
- // add the line body if present
- if end > beg {
- if end < lastFencedCodeBlockEnd { // Do not expand tabs while inside fenced code blocks.
- out.Write(input[beg:end])
- } else {
- expandTabs(&out, input[beg:end], tabSize)
- }
- }
- out.WriteByte('\n')
-
- if end < len(input) && input[end] == '\r' {
- end++
- }
- if end < len(input) && input[end] == '\n' {
- end++
- }
-
- beg = end
- }
- }
-
- // empty input?
- if out.Len() == 0 {
- out.WriteByte('\n')
- }
-
- return out.Bytes()
-}
-
-// second pass: actual rendering
-func secondPass(p *parser, input []byte) []byte {
- var output bytes.Buffer
-
- p.r.DocumentHeader(&output)
- p.block(&output, input)
-
- if p.flags&EXTENSION_FOOTNOTES != 0 && len(p.notes) > 0 {
- p.r.Footnotes(&output, func() bool {
- flags := LIST_ITEM_BEGINNING_OF_LIST
- for _, ref := range p.notes {
- var buf bytes.Buffer
- if ref.hasBlock {
- flags |= LIST_ITEM_CONTAINS_BLOCK
- p.block(&buf, ref.title)
- } else {
- p.inline(&buf, ref.title)
- }
- p.r.FootnoteItem(&output, ref.link, buf.Bytes(), flags)
- flags &^= LIST_ITEM_BEGINNING_OF_LIST | LIST_ITEM_CONTAINS_BLOCK
- }
-
- return true
- })
- }
-
- p.r.DocumentFooter(&output)
-
- if p.nesting != 0 {
- panic("Nesting level did not end at zero")
- }
-
- return output.Bytes()
-}
-
-//
-// Link references
-//
-// This section implements support for references that (usually) appear
-// as footnotes in a document, and can be referenced anywhere in the document.
-// The basic format is:
-//
-// [1]: http://www.google.com/ "Google"
-// [2]: http://www.github.com/ "Github"
-//
-// Anywhere in the document, the reference can be linked by referring to its
-// label, i.e., 1 and 2 in this example, as in:
-//
-// This library is hosted on [Github][2], a git hosting site.
-//
-// Actual footnotes as specified in Pandoc and supported by some other Markdown
-// libraries such as php-markdown are also taken care of. They look like this:
-//
-// This sentence needs a bit of further explanation.[^note]
-//
-// [^note]: This is the explanation.
-//
-// Footnotes should be placed at the end of the document in an ordered list.
-// Inline footnotes such as:
-//
-// Inline footnotes^[Not supported.] also exist.
-//
-// are not yet supported.
-
-// References are parsed and stored in this struct.
-type reference struct {
- link []byte
- title []byte
- noteId int // 0 if not a footnote ref
- hasBlock bool
-}
-
-// Check whether or not data starts with a reference link.
-// If so, it is parsed and stored in the list of references
-// (in the render struct).
-// Returns the number of bytes to skip to move past it,
-// or zero if the first line is not a reference.
-func isReference(p *parser, data []byte, tabSize int) int {
- // up to 3 optional leading spaces
- if len(data) < 4 {
- return 0
- }
- i := 0
- for i < 3 && data[i] == ' ' {
- i++
- }
-
- noteId := 0
-
- // id part: anything but a newline between brackets
- if data[i] != '[' {
- return 0
- }
- i++
- if p.flags&EXTENSION_FOOTNOTES != 0 {
- if data[i] == '^' {
- // we can set it to anything here because the proper noteIds will
- // be assigned later during the second pass. It just has to be != 0
- noteId = 1
- i++
- }
- }
- idOffset := i
- for i < len(data) && data[i] != '\n' && data[i] != '\r' && data[i] != ']' {
- i++
- }
- if i >= len(data) || data[i] != ']' {
- return 0
- }
- idEnd := i
-
- // spacer: colon (space | tab)* newline? (space | tab)*
- i++
- if i >= len(data) || data[i] != ':' {
- return 0
- }
- i++
- for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
- i++
- }
- if i < len(data) && (data[i] == '\n' || data[i] == '\r') {
- i++
- if i < len(data) && data[i] == '\n' && data[i-1] == '\r' {
- i++
- }
- }
- for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
- i++
- }
- if i >= len(data) {
- return 0
- }
-
- var (
- linkOffset, linkEnd int
- titleOffset, titleEnd int
- lineEnd int
- raw []byte
- hasBlock bool
- )
-
- if p.flags&EXTENSION_FOOTNOTES != 0 && noteId != 0 {
- linkOffset, linkEnd, raw, hasBlock = scanFootnote(p, data, i, tabSize)
- lineEnd = linkEnd
- } else {
- linkOffset, linkEnd, titleOffset, titleEnd, lineEnd = scanLinkRef(p, data, i)
- }
- if lineEnd == 0 {
- return 0
- }
-
- // a valid ref has been found
-
- ref := &reference{
- noteId: noteId,
- hasBlock: hasBlock,
- }
-
- if noteId > 0 {
- // reusing the link field for the id since footnotes don't have links
- ref.link = data[idOffset:idEnd]
- // if footnote, it's not really a title, it's the contained text
- ref.title = raw
- } else {
- ref.link = data[linkOffset:linkEnd]
- ref.title = data[titleOffset:titleEnd]
- }
-
- // id matches are case-insensitive
- id := string(bytes.ToLower(data[idOffset:idEnd]))
-
- p.refs[id] = ref
-
- return lineEnd
-}
-
-func scanLinkRef(p *parser, data []byte, i int) (linkOffset, linkEnd, titleOffset, titleEnd, lineEnd int) {
- // link: whitespace-free sequence, optionally between angle brackets
- if data[i] == '<' {
- i++
- }
- linkOffset = i
- for i < len(data) && data[i] != ' ' && data[i] != '\t' && data[i] != '\n' && data[i] != '\r' {
- i++
- }
- linkEnd = i
- if data[linkOffset] == '<' && data[linkEnd-1] == '>' {
- linkOffset++
- linkEnd--
- }
-
- // optional spacer: (space | tab)* (newline | '\'' | '"' | '(' )
- for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
- i++
- }
- if i < len(data) && data[i] != '\n' && data[i] != '\r' && data[i] != '\'' && data[i] != '"' && data[i] != '(' {
- return
- }
-
- // compute end-of-line
- if i >= len(data) || data[i] == '\r' || data[i] == '\n' {
- lineEnd = i
- }
- if i+1 < len(data) && data[i] == '\r' && data[i+1] == '\n' {
- lineEnd++
- }
-
- // optional (space|tab)* spacer after a newline
- if lineEnd > 0 {
- i = lineEnd + 1
- for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
- i++
- }
- }
-
- // optional title: any non-newline sequence enclosed in '"() alone on its line
- if i+1 < len(data) && (data[i] == '\'' || data[i] == '"' || data[i] == '(') {
- i++
- titleOffset = i
-
- // look for EOL
- for i < len(data) && data[i] != '\n' && data[i] != '\r' {
- i++
- }
- if i+1 < len(data) && data[i] == '\n' && data[i+1] == '\r' {
- titleEnd = i + 1
- } else {
- titleEnd = i
- }
-
- // step back
- i--
- for i > titleOffset && (data[i] == ' ' || data[i] == '\t') {
- i--
- }
- if i > titleOffset && (data[i] == '\'' || data[i] == '"' || data[i] == ')') {
- lineEnd = titleEnd
- titleEnd = i
- }
- }
-
- return
-}
-
-// The first bit of this logic is the same as (*parser).listItem, but the rest
-// is much simpler. This function simply finds the entire block and shifts it
-// over by one tab if it is indeed a block (just returns the line if it's not).
-// blockEnd is the end of the section in the input buffer, and contents is the
-// extracted text that was shifted over one tab. It will need to be rendered at
-// the end of the document.
-func scanFootnote(p *parser, data []byte, i, indentSize int) (blockStart, blockEnd int, contents []byte, hasBlock bool) {
- if i == 0 || len(data) == 0 {
- return
- }
-
- // skip leading whitespace on first line
- for i < len(data) && data[i] == ' ' {
- i++
- }
-
- blockStart = i
-
- // find the end of the line
- blockEnd = i
- for i < len(data) && data[i-1] != '\n' {
- i++
- }
-
- // get working buffer
- var raw bytes.Buffer
-
- // put the first line into the working buffer
- raw.Write(data[blockEnd:i])
- blockEnd = i
-
- // process the following lines
- containsBlankLine := false
-
-gatherLines:
- for blockEnd < len(data) {
- i++
-
- // find the end of this line
- for i < len(data) && data[i-1] != '\n' {
- i++
- }
-
- // if it is an empty line, guess that it is part of this item
- // and move on to the next line
- if p.isEmpty(data[blockEnd:i]) > 0 {
- containsBlankLine = true
- blockEnd = i
- continue
- }
-
- n := 0
- if n = isIndented(data[blockEnd:i], indentSize); n == 0 {
- // this is the end of the block.
- // we don't want to include this last line in the index.
- break gatherLines
- }
-
- // if there were blank lines before this one, insert a new one now
- if containsBlankLine {
- raw.WriteByte('\n')
- containsBlankLine = false
- }
-
- // get rid of that first tab, write to buffer
- raw.Write(data[blockEnd+n : i])
- hasBlock = true
-
- blockEnd = i
- }
-
- if data[blockEnd-1] != '\n' {
- raw.WriteByte('\n')
- }
-
- contents = raw.Bytes()
-
- return
-}
-
-//
-//
-// Miscellaneous helper functions
-//
-//
-
-// Test if a character is a punctuation symbol.
-// Taken from a private function in regexp in the stdlib.
-func ispunct(c byte) bool {
- for _, r := range []byte("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~") {
- if c == r {
- return true
- }
- }
- return false
-}
-
-// Test if a character is a whitespace character.
-func isspace(c byte) bool {
- return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v'
-}
-
-// Test if a character is letter.
-func isletter(c byte) bool {
- return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-}
-
-// Test if a character is a letter or a digit.
-// TODO: check when this is looking for ASCII alnum and when it should use unicode
-func isalnum(c byte) bool {
- return (c >= '0' && c <= '9') || isletter(c)
-}
-
-// Replace tab characters with spaces, aligning to the next TAB_SIZE column.
-// always ends output with a newline
-func expandTabs(out *bytes.Buffer, line []byte, tabSize int) {
- // first, check for common cases: no tabs, or only tabs at beginning of line
- i, prefix := 0, 0
- slowcase := false
- for i = 0; i < len(line); i++ {
- if line[i] == '\t' {
- if prefix == i {
- prefix++
- } else {
- slowcase = true
- break
- }
- }
- }
-
- // no need to decode runes if all tabs are at the beginning of the line
- if !slowcase {
- for i = 0; i < prefix*tabSize; i++ {
- out.WriteByte(' ')
- }
- out.Write(line[prefix:])
- return
- }
-
- // the slow case: we need to count runes to figure out how
- // many spaces to insert for each tab
- column := 0
- i = 0
- for i < len(line) {
- start := i
- for i < len(line) && line[i] != '\t' {
- _, size := utf8.DecodeRune(line[i:])
- i += size
- column++
- }
-
- if i > start {
- out.Write(line[start:i])
- }
-
- if i >= len(line) {
- break
- }
-
- for {
- out.WriteByte(' ')
- column++
- if column%tabSize == 0 {
- break
- }
- }
-
- i++
- }
-}
-
-// Find if a line counts as indented or not.
-// Returns number of characters the indent is (0 = not indented).
-func isIndented(data []byte, indentSize int) int {
- if len(data) == 0 {
- return 0
- }
- if data[0] == '\t' {
- return 1
- }
- if len(data) < indentSize {
- return 0
- }
- for i := 0; i < indentSize; i++ {
- if data[i] != ' ' {
- return 0
- }
- }
- return indentSize
-}
-
-// Create a url-safe slug for fragments
-func slugify(in []byte) []byte {
- if len(in) == 0 {
- return in
- }
- out := make([]byte, 0, len(in))
- sym := false
-
- for _, ch := range in {
- if isalnum(ch) {
- sym = false
- out = append(out, ch)
- } else if sym {
- continue
- } else {
- out = append(out, '-')
- sym = true
- }
- }
- var a, b int
- var ch byte
- for a, ch = range out {
- if ch != '-' {
- break
- }
- }
- for b = len(out) - 1; b > 0; b-- {
- if out[b] != '-' {
- break
- }
- }
- return out[a : b+1]
-}
diff --git a/Godeps/_workspace/src/github.com/russross/blackfriday/smartypants.go b/Godeps/_workspace/src/github.com/russross/blackfriday/smartypants.go
deleted file mode 100644
index 8027571df336cd1a931419d0fea92e23f171555e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/russross/blackfriday/smartypants.go
+++ /dev/null
@@ -1,398 +0,0 @@
-//
-// Blackfriday Markdown Processor
-// Available at http://github.com/russross/blackfriday
-//
-// Copyright © 2011 Russ Ross <russ@russross.com>.
-// Distributed under the Simplified BSD License.
-// See README.md for details.
-//
-
-//
-//
-// SmartyPants rendering
-//
-//
-
-package blackfriday
-
-import (
- "bytes"
-)
-
-type smartypantsData struct {
- inSingleQuote bool
- inDoubleQuote bool
-}
-
-func wordBoundary(c byte) bool {
- return c == 0 || isspace(c) || ispunct(c)
-}
-
-func tolower(c byte) byte {
- if c >= 'A' && c <= 'Z' {
- return c - 'A' + 'a'
- }
- return c
-}
-
-func isdigit(c byte) bool {
- return c >= '0' && c <= '9'
-}
-
-func smartQuoteHelper(out *bytes.Buffer, previousChar byte, nextChar byte, quote byte, isOpen *bool) bool {
- // edge of the buffer is likely to be a tag that we don't get to see,
- // so we treat it like text sometimes
-
- // enumerate all sixteen possibilities for (previousChar, nextChar)
- // each can be one of {0, space, punct, other}
- switch {
- case previousChar == 0 && nextChar == 0:
- // context is not any help here, so toggle
- *isOpen = !*isOpen
- case isspace(previousChar) && nextChar == 0:
- // [ "] might be [ "<code>foo...]
- *isOpen = true
- case ispunct(previousChar) && nextChar == 0:
- // [!"] hmm... could be [Run!"] or [("<code>...]
- *isOpen = false
- case /* isnormal(previousChar) && */ nextChar == 0:
- // [a"] is probably a close
- *isOpen = false
- case previousChar == 0 && isspace(nextChar):
- // [" ] might be [...foo</code>" ]
- *isOpen = false
- case isspace(previousChar) && isspace(nextChar):
- // [ " ] context is not any help here, so toggle
- *isOpen = !*isOpen
- case ispunct(previousChar) && isspace(nextChar):
- // [!" ] is probably a close
- *isOpen = false
- case /* isnormal(previousChar) && */ isspace(nextChar):
- // [a" ] this is one of the easy cases
- *isOpen = false
- case previousChar == 0 && ispunct(nextChar):
- // ["!] hmm... could be ["$1.95] or [</code>"!...]
- *isOpen = false
- case isspace(previousChar) && ispunct(nextChar):
- // [ "!] looks more like [ "$1.95]
- *isOpen = true
- case ispunct(previousChar) && ispunct(nextChar):
- // [!"!] context is not any help here, so toggle
- *isOpen = !*isOpen
- case /* isnormal(previousChar) && */ ispunct(nextChar):
- // [a"!] is probably a close
- *isOpen = false
- case previousChar == 0 /* && isnormal(nextChar) */ :
- // ["a] is probably an open
- *isOpen = true
- case isspace(previousChar) /* && isnormal(nextChar) */ :
- // [ "a] this is one of the easy cases
- *isOpen = true
- case ispunct(previousChar) /* && isnormal(nextChar) */ :
- // [!"a] is probably an open
- *isOpen = true
- default:
- // [a'b] maybe a contraction?
- *isOpen = false
- }
-
- out.WriteByte('&')
- if *isOpen {
- out.WriteByte('l')
- } else {
- out.WriteByte('r')
- }
- out.WriteByte(quote)
- out.WriteString("quo;")
- return true
-}
-
-func smartSingleQuote(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 2 {
- t1 := tolower(text[1])
-
- if t1 == '\'' {
- nextChar := byte(0)
- if len(text) >= 3 {
- nextChar = text[2]
- }
- if smartQuoteHelper(out, previousChar, nextChar, 'd', &smrt.inDoubleQuote) {
- return 1
- }
- }
-
- if (t1 == 's' || t1 == 't' || t1 == 'm' || t1 == 'd') && (len(text) < 3 || wordBoundary(text[2])) {
- out.WriteString("’")
- return 0
- }
-
- if len(text) >= 3 {
- t2 := tolower(text[2])
-
- if ((t1 == 'r' && t2 == 'e') || (t1 == 'l' && t2 == 'l') || (t1 == 'v' && t2 == 'e')) &&
- (len(text) < 4 || wordBoundary(text[3])) {
- out.WriteString("’")
- return 0
- }
- }
- }
-
- nextChar := byte(0)
- if len(text) > 1 {
- nextChar = text[1]
- }
- if smartQuoteHelper(out, previousChar, nextChar, 's', &smrt.inSingleQuote) {
- return 0
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartParens(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 3 {
- t1 := tolower(text[1])
- t2 := tolower(text[2])
-
- if t1 == 'c' && t2 == ')' {
- out.WriteString("©")
- return 2
- }
-
- if t1 == 'r' && t2 == ')' {
- out.WriteString("®")
- return 2
- }
-
- if len(text) >= 4 && t1 == 't' && t2 == 'm' && text[3] == ')' {
- out.WriteString("™")
- return 3
- }
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartDash(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 2 {
- if text[1] == '-' {
- out.WriteString("—")
- return 1
- }
-
- if wordBoundary(previousChar) && wordBoundary(text[1]) {
- out.WriteString("–")
- return 0
- }
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartDashLatex(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 3 && text[1] == '-' && text[2] == '-' {
- out.WriteString("—")
- return 2
- }
- if len(text) >= 2 && text[1] == '-' {
- out.WriteString("–")
- return 1
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartAmpVariant(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte, quote byte) int {
- if bytes.HasPrefix(text, []byte(""")) {
- nextChar := byte(0)
- if len(text) >= 7 {
- nextChar = text[6]
- }
- if smartQuoteHelper(out, previousChar, nextChar, quote, &smrt.inDoubleQuote) {
- return 5
- }
- }
-
- if bytes.HasPrefix(text, []byte("�")) {
- return 3
- }
-
- out.WriteByte('&')
- return 0
-}
-
-func smartAmp(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- return smartAmpVariant(out, smrt, previousChar, text, 'd')
-}
-
-func smartAmpAngledQuote(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- return smartAmpVariant(out, smrt, previousChar, text, 'a')
-}
-
-func smartPeriod(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 3 && text[1] == '.' && text[2] == '.' {
- out.WriteString("…")
- return 2
- }
-
- if len(text) >= 5 && text[1] == ' ' && text[2] == '.' && text[3] == ' ' && text[4] == '.' {
- out.WriteString("…")
- return 4
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartBacktick(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if len(text) >= 2 && text[1] == '`' {
- nextChar := byte(0)
- if len(text) >= 3 {
- nextChar = text[2]
- }
- if smartQuoteHelper(out, previousChar, nextChar, 'd', &smrt.inDoubleQuote) {
- return 1
- }
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartNumberGeneric(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if wordBoundary(previousChar) && previousChar != '/' && len(text) >= 3 {
- // is it of the form digits/digits(word boundary)?, i.e., \d+/\d+\b
- // note: check for regular slash (/) or fraction slash (⁄, 0x2044, or 0xe2 81 84 in utf-8)
- // and avoid changing dates like 1/23/2005 into fractions.
- numEnd := 0
- for len(text) > numEnd && isdigit(text[numEnd]) {
- numEnd++
- }
- if numEnd == 0 {
- out.WriteByte(text[0])
- return 0
- }
- denStart := numEnd + 1
- if len(text) > numEnd+3 && text[numEnd] == 0xe2 && text[numEnd+1] == 0x81 && text[numEnd+2] == 0x84 {
- denStart = numEnd + 3
- } else if len(text) < numEnd+2 || text[numEnd] != '/' {
- out.WriteByte(text[0])
- return 0
- }
- denEnd := denStart
- for len(text) > denEnd && isdigit(text[denEnd]) {
- denEnd++
- }
- if denEnd == denStart {
- out.WriteByte(text[0])
- return 0
- }
- if len(text) == denEnd || wordBoundary(text[denEnd]) && text[denEnd] != '/' {
- out.WriteString("<sup>")
- out.Write(text[:numEnd])
- out.WriteString("</sup>⁄<sub>")
- out.Write(text[denStart:denEnd])
- out.WriteString("</sub>")
- return denEnd - 1
- }
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartNumber(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- if wordBoundary(previousChar) && previousChar != '/' && len(text) >= 3 {
- if text[0] == '1' && text[1] == '/' && text[2] == '2' {
- if len(text) < 4 || wordBoundary(text[3]) && text[3] != '/' {
- out.WriteString("½")
- return 2
- }
- }
-
- if text[0] == '1' && text[1] == '/' && text[2] == '4' {
- if len(text) < 4 || wordBoundary(text[3]) && text[3] != '/' || (len(text) >= 5 && tolower(text[3]) == 't' && tolower(text[4]) == 'h') {
- out.WriteString("¼")
- return 2
- }
- }
-
- if text[0] == '3' && text[1] == '/' && text[2] == '4' {
- if len(text) < 4 || wordBoundary(text[3]) && text[3] != '/' || (len(text) >= 6 && tolower(text[3]) == 't' && tolower(text[4]) == 'h' && tolower(text[5]) == 's') {
- out.WriteString("¾")
- return 2
- }
- }
- }
-
- out.WriteByte(text[0])
- return 0
-}
-
-func smartDoubleQuoteVariant(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte, quote byte) int {
- nextChar := byte(0)
- if len(text) > 1 {
- nextChar = text[1]
- }
- if !smartQuoteHelper(out, previousChar, nextChar, quote, &smrt.inDoubleQuote) {
- out.WriteString(""")
- }
-
- return 0
-}
-
-func smartDoubleQuote(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- return smartDoubleQuoteVariant(out, smrt, previousChar, text, 'd')
-}
-
-func smartAngledDoubleQuote(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- return smartDoubleQuoteVariant(out, smrt, previousChar, text, 'a')
-}
-
-func smartLeftAngle(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int {
- i := 0
-
- for i < len(text) && text[i] != '>' {
- i++
- }
-
- out.Write(text[:i+1])
- return i
-}
-
-type smartCallback func(out *bytes.Buffer, smrt *smartypantsData, previousChar byte, text []byte) int
-
-type smartypantsRenderer [256]smartCallback
-
-func smartypants(flags int) *smartypantsRenderer {
- r := new(smartypantsRenderer)
- if flags&HTML_SMARTYPANTS_ANGLED_QUOTES == 0 {
- r['"'] = smartDoubleQuote
- r['&'] = smartAmp
- } else {
- r['"'] = smartAngledDoubleQuote
- r['&'] = smartAmpAngledQuote
- }
- r['\''] = smartSingleQuote
- r['('] = smartParens
- if flags&HTML_SMARTYPANTS_LATEX_DASHES == 0 {
- r['-'] = smartDash
- } else {
- r['-'] = smartDashLatex
- }
- r['.'] = smartPeriod
- if flags&HTML_SMARTYPANTS_FRACTIONS == 0 {
- r['1'] = smartNumber
- r['3'] = smartNumber
- } else {
- for ch := '1'; ch <= '9'; ch++ {
- r[ch] = smartNumberGeneric
- }
- }
- r['<'] = smartLeftAngle
- r['`'] = smartBacktick
- return r
-}
diff --git a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/.travis.yml b/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/.travis.yml
deleted file mode 100644
index aaee9cf2c4f6cb797f3eda96cb32952f56a50a9c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/.travis.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-language: go
-go:
- - 1.4
-install:
- - go get golang.org/x/tools/cmd/vet
-script:
- - go get -t -v ./...
- - diff -u <(echo -n) <(gofmt -d ./)
- - go tool vet ./
- - go test -v -race ./...
diff --git a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/README.md b/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/README.md
deleted file mode 100644
index 87e33e212de1267b770cb9438c5ec0c0edd4305b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-sanitized_anchor_name [](https://travis-ci.org/shurcooL/sanitized_anchor_name)
-=====================
-
-Package `sanitized_anchor_name` provides a func to create sanitized anchor names.
-
-Its logic can be reused by multiple packages to create interoperable anchor names and links to those anchors.
-
-At this time, it does not try to ensure that generated anchor names are unique, that responsibility falls on the caller.
-
-Example
-=======
-
-```Go
-anchorName := sanitized_anchor_name.Create("This is a header")
-
-fmt.Println(anchorName)
-
-// Output:
-// this-is-a-header
-```
diff --git a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/main.go b/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/main.go
deleted file mode 100644
index 6baae23b50e40a4c2ce233d35db093b23b6481ae..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/shurcooL/sanitized_anchor_name/main.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Package sanitized_anchor_name provides a func to create sanitized anchor names.
-//
-// Its logic can be reused by multiple packages to create interoperable anchor names
-// and links to those anchors.
-//
-// At this time, it does not try to ensure that generated anchor names
-// are unique, that responsibility falls on the caller.
-package sanitized_anchor_name
-
-import "unicode"
-
-// Create returns a sanitized anchor name for the given text.
-func Create(text string) string {
- var anchorName []rune
- var futureDash = false
- for _, r := range []rune(text) {
- switch {
- case unicode.IsLetter(r) || unicode.IsNumber(r):
- if futureDash && len(anchorName) > 0 {
- anchorName = append(anchorName, '-')
- }
- futureDash = false
- anchorName = append(anchorName, unicode.ToLower(r))
- default:
- futureDash = true
- }
- }
- return string(anchorName)
-}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go b/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
deleted file mode 100644
index 965bfdb036f3284dc5d2e0e6aff81a5f356d9840..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
+++ /dev/null
@@ -1,425 +0,0 @@
-package cobra
-
-import (
- "bytes"
- "fmt"
- "os"
- "sort"
- "strings"
-
- "github.com/spf13/pflag"
-)
-
-const (
- BashCompFilenameExt = "cobra_annotation_bash_completion_filename_extentions"
- BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag"
- BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir"
-)
-
-func preamble(out *bytes.Buffer) {
- fmt.Fprintf(out, `#!/bin/bash
-
-__debug()
-{
- if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
- echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
- fi
-}
-
-# Homebrew on Macs have version 1.3 of bash-completion which doesn't include
-# _init_completion. This is a very minimal version of that function.
-__my_init_completion()
-{
- COMPREPLY=()
- _get_comp_words_by_ref cur prev words cword
-}
-
-__index_of_word()
-{
- local w word=$1
- shift
- index=0
- for w in "$@"; do
- [[ $w = "$word" ]] && return
- index=$((index+1))
- done
- index=-1
-}
-
-__contains_word()
-{
- local w word=$1; shift
- for w in "$@"; do
- [[ $w = "$word" ]] && return
- done
- return 1
-}
-
-__handle_reply()
-{
- __debug "${FUNCNAME}"
- case $cur in
- -*)
- if [[ $(type -t compopt) = "builtin" ]]; then
- compopt -o nospace
- fi
- local allflags
- if [ ${#must_have_one_flag[@]} -ne 0 ]; then
- allflags=("${must_have_one_flag[@]}")
- else
- allflags=("${flags[*]} ${two_word_flags[*]}")
- fi
- COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") )
- if [[ $(type -t compopt) = "builtin" ]]; then
- [[ $COMPREPLY == *= ]] || compopt +o nospace
- fi
- return 0;
- ;;
- esac
-
- # check if we are handling a flag with special work handling
- local index
- __index_of_word "${prev}" "${flags_with_completion[@]}"
- if [[ ${index} -ge 0 ]]; then
- ${flags_completion[${index}]}
- return
- fi
-
- # we are parsing a flag and don't have a special handler, no completion
- if [[ ${cur} != "${words[cword]}" ]]; then
- return
- fi
-
- local completions
- if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then
- completions=("${must_have_one_flag[@]}")
- elif [[ ${#must_have_one_noun[@]} -ne 0 ]]; then
- completions=("${must_have_one_noun[@]}")
- else
- completions=("${commands[@]}")
- fi
- COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") )
-
- if [[ ${#COMPREPLY[@]} -eq 0 ]]; then
- declare -F __custom_func >/dev/null && __custom_func
- fi
-}
-
-# The arguments should be in the form "ext1|ext2|extn"
-__handle_filename_extension_flag()
-{
- local ext="$1"
- _filedir "@(${ext})"
-}
-
-__handle_subdirs_in_dir_flag()
-{
- local dir="$1"
- pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1
-}
-
-__handle_flag()
-{
- __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
-
- # if a command required a flag, and we found it, unset must_have_one_flag()
- local flagname=${words[c]}
- # if the word contained an =
- if [[ ${words[c]} == *"="* ]]; then
- flagname=${flagname%%=*} # strip everything after the =
- flagname="${flagname}=" # but put the = back
- fi
- __debug "${FUNCNAME}: looking for ${flagname}"
- if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then
- must_have_one_flag=()
- fi
-
- # skip the argument to a two word flag
- if __contains_word "${words[c]}" "${two_word_flags[@]}"; then
- c=$((c+1))
- # if we are looking for a flags value, don't show commands
- if [[ $c -eq $cword ]]; then
- commands=()
- fi
- fi
-
- # skip the flag itself
- c=$((c+1))
-
-}
-
-__handle_noun()
-{
- __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
-
- if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then
- must_have_one_noun=()
- fi
-
- nouns+=("${words[c]}")
- c=$((c+1))
-}
-
-__handle_command()
-{
- __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
-
- local next_command
- if [[ -n ${last_command} ]]; then
- next_command="_${last_command}_${words[c]}"
- else
- next_command="_${words[c]}"
- fi
- c=$((c+1))
- __debug "${FUNCNAME}: looking for ${next_command}"
- declare -F $next_command >/dev/null && $next_command
-}
-
-__handle_word()
-{
- if [[ $c -ge $cword ]]; then
- __handle_reply
- return
- fi
- __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
- if [[ "${words[c]}" == -* ]]; then
- __handle_flag
- elif __contains_word "${words[c]}" "${commands[@]}"; then
- __handle_command
- else
- __handle_noun
- fi
- __handle_word
-}
-
-`)
-}
-
-func postscript(out *bytes.Buffer, name string) {
- fmt.Fprintf(out, "__start_%s()\n", name)
- fmt.Fprintf(out, `{
- local cur prev words cword
- if declare -F _init_completion >/dev/null 2>&1; then
- _init_completion -s || return
- else
- __my_init_completion || return
- fi
-
- local c=0
- local flags=()
- local two_word_flags=()
- local flags_with_completion=()
- local flags_completion=()
- local commands=("%s")
- local must_have_one_flag=()
- local must_have_one_noun=()
- local last_command
- local nouns=()
-
- __handle_word
-}
-
-`, name)
- fmt.Fprintf(out, `if [[ $(type -t compopt) = "builtin" ]]; then
- complete -F __start_%s %s
-else
- complete -o nospace -F __start_%s %s
-fi
-
-`, name, name, name, name)
- fmt.Fprintf(out, "# ex: ts=4 sw=4 et filetype=sh\n")
-}
-
-func writeCommands(cmd *Command, out *bytes.Buffer) {
- fmt.Fprintf(out, " commands=()\n")
- for _, c := range cmd.Commands() {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- fmt.Fprintf(out, " commands+=(%q)\n", c.Name())
- }
- fmt.Fprintf(out, "\n")
-}
-
-func writeFlagHandler(name string, annotations map[string][]string, out *bytes.Buffer) {
- for key, value := range annotations {
- switch key {
- case BashCompFilenameExt:
- fmt.Fprintf(out, " flags_with_completion+=(%q)\n", name)
-
- if len(value) > 0 {
- ext := "__handle_filename_extension_flag " + strings.Join(value, "|")
- fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
- } else {
- ext := "_filedir"
- fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
- }
- case BashCompSubdirsInDir:
- fmt.Fprintf(out, " flags_with_completion+=(%q)\n", name)
-
- if len(value) == 1 {
- ext := "__handle_subdirs_in_dir_flag " + value[0]
- fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
- } else {
- ext := "_filedir -d"
- fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
- }
- }
- }
-}
-
-func writeShortFlag(flag *pflag.Flag, out *bytes.Buffer) {
- b := (flag.Value.Type() == "bool")
- name := flag.Shorthand
- format := " "
- if !b {
- format += "two_word_"
- }
- format += "flags+=(\"-%s\")\n"
- fmt.Fprintf(out, format, name)
- writeFlagHandler("-"+name, flag.Annotations, out)
-}
-
-func writeFlag(flag *pflag.Flag, out *bytes.Buffer) {
- b := (flag.Value.Type() == "bool")
- name := flag.Name
- format := " flags+=(\"--%s"
- if !b {
- format += "="
- }
- format += "\")\n"
- fmt.Fprintf(out, format, name)
- writeFlagHandler("--"+name, flag.Annotations, out)
-}
-
-func writeFlags(cmd *Command, out *bytes.Buffer) {
- fmt.Fprintf(out, ` flags=()
- two_word_flags=()
- flags_with_completion=()
- flags_completion=()
-
-`)
- cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) {
- writeFlag(flag, out)
- if len(flag.Shorthand) > 0 {
- writeShortFlag(flag, out)
- }
- })
- cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) {
- writeFlag(flag, out)
- if len(flag.Shorthand) > 0 {
- writeShortFlag(flag, out)
- }
- })
-
- fmt.Fprintf(out, "\n")
-}
-
-func writeRequiredFlag(cmd *Command, out *bytes.Buffer) {
- fmt.Fprintf(out, " must_have_one_flag=()\n")
- flags := cmd.NonInheritedFlags()
- flags.VisitAll(func(flag *pflag.Flag) {
- for key := range flag.Annotations {
- switch key {
- case BashCompOneRequiredFlag:
- format := " must_have_one_flag+=(\"--%s"
- b := (flag.Value.Type() == "bool")
- if !b {
- format += "="
- }
- format += "\")\n"
- fmt.Fprintf(out, format, flag.Name)
-
- if len(flag.Shorthand) > 0 {
- fmt.Fprintf(out, " must_have_one_flag+=(\"-%s\")\n", flag.Shorthand)
- }
- }
- }
- })
-}
-
-func writeRequiredNoun(cmd *Command, out *bytes.Buffer) {
- fmt.Fprintf(out, " must_have_one_noun=()\n")
- sort.Sort(sort.StringSlice(cmd.ValidArgs))
- for _, value := range cmd.ValidArgs {
- fmt.Fprintf(out, " must_have_one_noun+=(%q)\n", value)
- }
-}
-
-func gen(cmd *Command, out *bytes.Buffer) {
- for _, c := range cmd.Commands() {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- gen(c, out)
- }
- commandName := cmd.CommandPath()
- commandName = strings.Replace(commandName, " ", "_", -1)
- fmt.Fprintf(out, "_%s()\n{\n", commandName)
- fmt.Fprintf(out, " last_command=%q\n", commandName)
- writeCommands(cmd, out)
- writeFlags(cmd, out)
- writeRequiredFlag(cmd, out)
- writeRequiredNoun(cmd, out)
- fmt.Fprintf(out, "}\n\n")
-}
-
-func (cmd *Command) GenBashCompletion(out *bytes.Buffer) {
- preamble(out)
- if len(cmd.BashCompletionFunction) > 0 {
- fmt.Fprintf(out, "%s\n", cmd.BashCompletionFunction)
- }
- gen(cmd, out)
- postscript(out, cmd.Name())
-}
-
-func (cmd *Command) GenBashCompletionFile(filename string) error {
- out := new(bytes.Buffer)
-
- cmd.GenBashCompletion(out)
-
- outFile, err := os.Create(filename)
- if err != nil {
- return err
- }
- defer outFile.Close()
-
- _, err = outFile.Write(out.Bytes())
- if err != nil {
- return err
- }
- return nil
-}
-
-// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists.
-func (cmd *Command) MarkFlagRequired(name string) error {
- return MarkFlagRequired(cmd.Flags(), name)
-}
-
-// MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag, if it exists.
-func (cmd *Command) MarkPersistentFlagRequired(name string) error {
- return MarkFlagRequired(cmd.PersistentFlags(), name)
-}
-
-// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists.
-func MarkFlagRequired(flags *pflag.FlagSet, name string) error {
- return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"})
-}
-
-// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists.
-// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
-func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error {
- return MarkFlagFilename(cmd.Flags(), name, extensions...)
-}
-
-// MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists.
-// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
-func (cmd *Command) MarkPersistentFlagFilename(name string, extensions ...string) error {
- return MarkFlagFilename(cmd.PersistentFlags(), name, extensions...)
-}
-
-// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists.
-// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
-func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error {
- return flags.SetAnnotation(name, BashCompFilenameExt, extensions)
-}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/doc_util.go b/Godeps/_workspace/src/github.com/spf13/cobra/doc_util.go
deleted file mode 100644
index e248216284bd1b9933139c2ec907e1491e8d6405..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/doc_util.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2015 Red Hat Inc. All rights reserved.
-//
-// 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 cobra
-
-// Test to see if we have a reason to print See Also information in docs
-// Basically this is a test for a parent commend or a subcommand which is
-// both not deprecated and not the autogenerated help command.
-func (cmd *Command) hasSeeAlso() bool {
- if cmd.HasParent() {
- return true
- }
- children := cmd.Commands()
- if len(children) == 0 {
- return false
- }
- for _, c := range children {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- return true
- }
- return false
-}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.go b/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.go
deleted file mode 100644
index c168b62874b618fa4d13a26cb1e0d5199e3f4991..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.go
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright 2015 Red Hat Inc. All rights reserved.
-//
-// 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 cobra
-
-import (
- "bytes"
- "fmt"
- "os"
- "sort"
- "strings"
- "time"
-
- mangen "github.com/cpuguy83/go-md2man/md2man"
- "github.com/spf13/pflag"
-)
-
-// GenManTree will call cmd.GenManTree(header, dir)
-func GenManTree(cmd *Command, header *GenManHeader, dir string) {
- cmd.GenManTree(header, dir)
-}
-
-// GenManTree will generate a man page for this command and all decendants
-// in the directory given. The header may be nil. This function may not work
-// correctly if your command names have - in them. If you have `cmd` with two
-// subcmds, `sub` and `sub-third`. And `sub` has a subcommand called `third`
-// it is undefined which help output will be in the file `cmd-sub-third.1`.
-func (cmd *Command) GenManTree(header *GenManHeader, dir string) {
- if header == nil {
- header = &GenManHeader{}
- }
- for _, c := range cmd.Commands() {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- GenManTree(c, header, dir)
- }
- out := new(bytes.Buffer)
-
- needToResetTitle := header.Title == ""
-
- cmd.GenMan(header, out)
-
- if needToResetTitle {
- header.Title = ""
- }
-
- filename := cmd.CommandPath()
- filename = dir + strings.Replace(filename, " ", "-", -1) + ".1"
- outFile, err := os.Create(filename)
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
- defer outFile.Close()
- _, err = outFile.Write(out.Bytes())
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
-}
-
-// GenManHeader is a lot like the .TH header at the start of man pages. These
-// include the title, section, date, source, and manual. We will use the
-// current time if Date if unset and will use "Auto generated by spf13/cobra"
-// if the Source is unset.
-type GenManHeader struct {
- Title string
- Section string
- Date *time.Time
- date string
- Source string
- Manual string
-}
-
-// GenMan will call cmd.GenMan(header, out)
-func GenMan(cmd *Command, header *GenManHeader, out *bytes.Buffer) {
- cmd.GenMan(header, out)
-}
-
-// GenMan will generate a man page for the given command in the out buffer.
-// The header argument may be nil, however obviously out may not.
-func (cmd *Command) GenMan(header *GenManHeader, out *bytes.Buffer) {
- if header == nil {
- header = &GenManHeader{}
- }
- buf := genMarkdown(cmd, header)
- final := mangen.Render(buf)
- out.Write(final)
-}
-
-func fillHeader(header *GenManHeader, name string) {
- if header.Title == "" {
- header.Title = strings.ToUpper(strings.Replace(name, " ", "\\-", -1))
- }
- if header.Section == "" {
- header.Section = "1"
- }
- if header.Date == nil {
- now := time.Now()
- header.Date = &now
- }
- header.date = (*header.Date).Format("Jan 2006")
- if header.Source == "" {
- header.Source = "Auto generated by spf13/cobra"
- }
-}
-
-func manPreamble(out *bytes.Buffer, header *GenManHeader, name, short, long string) {
- dashName := strings.Replace(name, " ", "-", -1)
- fmt.Fprintf(out, `%% %s(%s)%s
-%% %s
-%% %s
-# NAME
-`, header.Title, header.Section, header.date, header.Source, header.Manual)
- fmt.Fprintf(out, "%s \\- %s\n\n", dashName, short)
- fmt.Fprintf(out, "# SYNOPSIS\n")
- fmt.Fprintf(out, "**%s** [OPTIONS]\n\n", name)
- fmt.Fprintf(out, "# DESCRIPTION\n")
- fmt.Fprintf(out, "%s\n\n", long)
-}
-
-func manPrintFlags(out *bytes.Buffer, flags *pflag.FlagSet) {
- flags.VisitAll(func(flag *pflag.Flag) {
- if len(flag.Deprecated) > 0 || flag.Hidden {
- return
- }
- format := ""
- if len(flag.Shorthand) > 0 {
- format = "**-%s**, **--%s**"
- } else {
- format = "%s**--%s**"
- }
- if len(flag.NoOptDefVal) > 0 {
- format = format + "["
- }
- if flag.Value.Type() == "string" {
- // put quotes on the value
- format = format + "=%q"
- } else {
- format = format + "=%s"
- }
- if len(flag.NoOptDefVal) > 0 {
- format = format + "]"
- }
- format = format + "\n\t%s\n\n"
- fmt.Fprintf(out, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage)
- })
-}
-
-func manPrintOptions(out *bytes.Buffer, command *Command) {
- flags := command.NonInheritedFlags()
- if flags.HasFlags() {
- fmt.Fprintf(out, "# OPTIONS\n")
- manPrintFlags(out, flags)
- fmt.Fprintf(out, "\n")
- }
- flags = command.InheritedFlags()
- if flags.HasFlags() {
- fmt.Fprintf(out, "# OPTIONS INHERITED FROM PARENT COMMANDS\n")
- manPrintFlags(out, flags)
- fmt.Fprintf(out, "\n")
- }
-}
-
-func genMarkdown(cmd *Command, header *GenManHeader) []byte {
- // something like `rootcmd subcmd1 subcmd2`
- commandName := cmd.CommandPath()
- // something like `rootcmd-subcmd1-subcmd2`
- dashCommandName := strings.Replace(commandName, " ", "-", -1)
-
- fillHeader(header, commandName)
-
- buf := new(bytes.Buffer)
-
- short := cmd.Short
- long := cmd.Long
- if len(long) == 0 {
- long = short
- }
-
- manPreamble(buf, header, commandName, short, long)
- manPrintOptions(buf, cmd)
- if len(cmd.Example) > 0 {
- fmt.Fprintf(buf, "# EXAMPLE\n")
- fmt.Fprintf(buf, "```\n%s\n```\n", cmd.Example)
- }
- if cmd.hasSeeAlso() {
- fmt.Fprintf(buf, "# SEE ALSO\n")
- if cmd.HasParent() {
- parentPath := cmd.Parent().CommandPath()
- dashParentPath := strings.Replace(parentPath, " ", "-", -1)
- fmt.Fprintf(buf, "**%s(%s)**", dashParentPath, header.Section)
- cmd.VisitParents(func(c *Command) {
- if c.DisableAutoGenTag {
- cmd.DisableAutoGenTag = c.DisableAutoGenTag
- }
- })
- }
- children := cmd.Commands()
- sort.Sort(byName(children))
- for i, c := range children {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- if cmd.HasParent() || i > 0 {
- fmt.Fprintf(buf, ", ")
- }
- fmt.Fprintf(buf, "**%s-%s(%s)**", dashCommandName, c.Name(), header.Section)
- }
- fmt.Fprintf(buf, "\n")
- }
- if !cmd.DisableAutoGenTag {
- fmt.Fprintf(buf, "# HISTORY\n%s Auto generated by spf13/cobra\n", header.Date.Format("2-Jan-2006"))
- }
- return buf.Bytes()
-}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.md b/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.md
deleted file mode 100644
index 3408c30115fd2c4e53f613f10cda22ceb9e4684c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/man_docs.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Generating Man Pages For Your Own cobra.Command
-
-Generating man pages from a cobra command is incredibly easy. An example is as follows:
-
-```go
-package main
-
-import (
- "github.com/spf13/cobra"
-)
-
-func main() {
- cmd := &cobra.Command{
- Use: "test",
- Short: "my test program",
- }
- header := &cobra.GenManHeader{
- Title: "MINE",
- Section: "3",
- }
- cmd.GenManTree(header, "/tmp")
-}
-```
-
-That will get you a man page `/tmp/test.1`
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.go b/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.go
deleted file mode 100644
index e940ba160abc89b1ae01760b867e7860511518ae..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.go
+++ /dev/null
@@ -1,162 +0,0 @@
-//Copyright 2015 Red Hat Inc. All rights reserved.
-//
-// 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 cobra
-
-import (
- "bytes"
- "fmt"
- "os"
- "sort"
- "strings"
- "time"
-)
-
-func printOptions(out *bytes.Buffer, cmd *Command, name string) {
- flags := cmd.NonInheritedFlags()
- flags.SetOutput(out)
- if flags.HasFlags() {
- fmt.Fprintf(out, "### Options\n\n```\n")
- flags.PrintDefaults()
- fmt.Fprintf(out, "```\n\n")
- }
-
- parentFlags := cmd.InheritedFlags()
- parentFlags.SetOutput(out)
- if parentFlags.HasFlags() {
- fmt.Fprintf(out, "### Options inherited from parent commands\n\n```\n")
- parentFlags.PrintDefaults()
- fmt.Fprintf(out, "```\n\n")
- }
-}
-
-type byName []*Command
-
-func (s byName) Len() int { return len(s) }
-func (s byName) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-func (s byName) Less(i, j int) bool { return s[i].Name() < s[j].Name() }
-
-func GenMarkdown(cmd *Command, out *bytes.Buffer) {
- cmd.GenMarkdown(out)
-}
-
-func (cmd *Command) GenMarkdown(out *bytes.Buffer) {
- cmd.GenMarkdownCustom(out, func(s string) string { return s })
-}
-
-func GenMarkdownCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string) {
- cmd.GenMarkdownCustom(out, linkHandler)
-}
-
-func (cmd *Command) GenMarkdownCustom(out *bytes.Buffer, linkHandler func(string) string) {
- name := cmd.CommandPath()
-
- short := cmd.Short
- long := cmd.Long
- if len(long) == 0 {
- long = short
- }
-
- fmt.Fprintf(out, "## %s\n\n", name)
- fmt.Fprintf(out, "%s\n\n", short)
- fmt.Fprintf(out, "### Synopsis\n\n")
- fmt.Fprintf(out, "\n%s\n\n", long)
-
- if cmd.Runnable() {
- fmt.Fprintf(out, "```\n%s\n```\n\n", cmd.UseLine())
- }
-
- if len(cmd.Example) > 0 {
- fmt.Fprintf(out, "### Examples\n\n")
- fmt.Fprintf(out, "```\n%s\n```\n\n", cmd.Example)
- }
-
- printOptions(out, cmd, name)
- if cmd.hasSeeAlso() {
- fmt.Fprintf(out, "### SEE ALSO\n")
- if cmd.HasParent() {
- parent := cmd.Parent()
- pname := parent.CommandPath()
- link := pname + ".md"
- link = strings.Replace(link, " ", "_", -1)
- fmt.Fprintf(out, "* [%s](%s)\t - %s\n", pname, linkHandler(link), parent.Short)
- cmd.VisitParents(func(c *Command) {
- if c.DisableAutoGenTag {
- cmd.DisableAutoGenTag = c.DisableAutoGenTag
- }
- })
- }
-
- children := cmd.Commands()
- sort.Sort(byName(children))
-
- for _, child := range children {
- if !child.IsAvailableCommand() || child == cmd.helpCommand {
- continue
- }
- cname := name + " " + child.Name()
- link := cname + ".md"
- link = strings.Replace(link, " ", "_", -1)
- fmt.Fprintf(out, "* [%s](%s)\t - %s\n", cname, linkHandler(link), child.Short)
- }
- fmt.Fprintf(out, "\n")
- }
- if !cmd.DisableAutoGenTag {
- fmt.Fprintf(out, "###### Auto generated by spf13/cobra on %s\n", time.Now().Format("2-Jan-2006"))
- }
-}
-
-func GenMarkdownTree(cmd *Command, dir string) {
- cmd.GenMarkdownTree(dir)
-}
-
-func (cmd *Command) GenMarkdownTree(dir string) {
- identity := func(s string) string { return s }
- emptyStr := func(s string) string { return "" }
- cmd.GenMarkdownTreeCustom(dir, emptyStr, identity)
-}
-
-func GenMarkdownTreeCustom(cmd *Command, dir string, filePrepender func(string) string, linkHandler func(string) string) {
- cmd.GenMarkdownTreeCustom(dir, filePrepender, linkHandler)
-}
-
-func (cmd *Command) GenMarkdownTreeCustom(dir string, filePrepender func(string) string, linkHandler func(string) string) {
- for _, c := range cmd.Commands() {
- if !c.IsAvailableCommand() || c == cmd.helpCommand {
- continue
- }
- c.GenMarkdownTreeCustom(dir, filePrepender, linkHandler)
- }
- out := new(bytes.Buffer)
-
- cmd.GenMarkdownCustom(out, linkHandler)
-
- filename := cmd.CommandPath()
- filename = dir + strings.Replace(filename, " ", "_", -1) + ".md"
- outFile, err := os.Create(filename)
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
- defer outFile.Close()
- _, err = outFile.WriteString(filePrepender(filename))
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
- _, err = outFile.Write(out.Bytes())
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
-}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.md b/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.md
deleted file mode 100644
index 3a0d55ab902a3bd63afced5766e5530e9e30b47f..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/md_docs.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# Generating Markdown Docs For Your Own cobra.Command
-
-## Generate markdown docs for the entire command tree
-
-This program can actually generate docs for the kubectl command in the kubernetes project
-
-```go
-package main
-
-import (
- "io/ioutil"
- "os"
-
- "github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd"
- "github.com/spf13/cobra"
-)
-
-func main() {
- kubectl := cmd.NewFactory(nil).NewKubectlCommand(os.Stdin, ioutil.Discard, ioutil.Discard)
- cobra.GenMarkdownTree(kubectl, "./")
-}
-```
-
-This will generate a whole series of files, one for each command in the tree, in the directory specified (in this case "./")
-
-## Generate markdown docs for a single command
-
-You may wish to have more control over the output, or only generate for a single command, instead of the entire command tree. If this is the case you may prefer to `GenMarkdown` instead of `GenMarkdownTree`
-
-```go
- out := new(bytes.Buffer)
- cobra.GenMarkdown(cmd, out)
-```
-
-This will write the markdown doc for ONLY "cmd" into the out, buffer.
-
-## Customize the output
-
-Both `GenMarkdown` and `GenMarkdownTree` have alternate versions with callbacks to get some control of the output:
-
-```go
-func GenMarkdownTreeCustom(cmd *Command, dir string, filePrepender func(string) string, linkHandler func(string) string) {
- //...
-}
-```
-
-```go
-func GenMarkdownCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string) {
- //...
-}
-```
-
-The `filePrepender` will prepend the return value given the full filepath to the rendered Markdown file. A common use case is to add front matter to use the generated documentation with [Hugo](http://gohugo.io/):
-
-```go
-const fmTemplate = `---
-date: %s
-title: "%s"
-slug: %s
-url: %s
----
-`
-
-filePrepender := func(filename string) string {
- now := time.Now().Format(time.RFC3339)
- name := filepath.Base(filename)
- base := strings.TrimSuffix(name, path.Ext(name))
- url := "/commands/" + strings.ToLower(base) + "/"
- return fmt.Sprintf(fmTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
-}
-```
-
-The `linkHandler` can be used to customize the rendered internal links to the commands, given a filename:
-
-```go
-linkHandler := func(name string) string {
- base := strings.TrimSuffix(name, path.Ext(name))
- return "/commands/" + strings.ToLower(base) + "/"
-}
-```
-
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt b/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt
deleted file mode 100644
index a009ba467ce285c479dc3f4f720d72417893e11b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
-
-Please consider promoting this project if you find it useful.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/LICENSE b/Godeps/_workspace/src/gopkg.in/yaml.v2/LICENSE
deleted file mode 100644
index a68e67f01b0cbbebb44224df30471217ee6ecdd1..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/LICENSE
+++ /dev/null
@@ -1,188 +0,0 @@
-
-Copyright (c) 2011-2014 - Canonical Inc.
-
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
- This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
- 0. Additional Definitions.
-
- As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
- "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
- An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
- A "Combined Work" is a work produced by combining or linking an
-Application with the Library. The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
- The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
- The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
- 1. Exception to Section 3 of the GNU GPL.
-
- You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
- 2. Conveying Modified Versions.
-
- If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
- a) under this License, provided that you make a good faith effort to
- ensure that, in the event an Application does not supply the
- function or data, the facility still operates, and performs
- whatever part of its purpose remains meaningful, or
-
- b) under the GNU GPL, with none of the additional permissions of
- this License applicable to that copy.
-
- 3. Object Code Incorporating Material from Library Header Files.
-
- The object code form of an Application may incorporate material from
-a header file that is part of the Library. You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
- a) Give prominent notice with each copy of the object code that the
- Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the object code with a copy of the GNU GPL and this license
- document.
-
- 4. Combined Works.
-
- You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
- a) Give prominent notice with each copy of the Combined Work that
- the Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the Combined Work with a copy of the GNU GPL and this license
- document.
-
- c) For a Combined Work that displays copyright notices during
- execution, include the copyright notice for the Library among
- these notices, as well as a reference directing the user to the
- copies of the GNU GPL and this license document.
-
- d) Do one of the following:
-
- 0) Convey the Minimal Corresponding Source under the terms of this
- License, and the Corresponding Application Code in a form
- suitable for, and under terms that permit, the user to
- recombine or relink the Application with a modified version of
- the Linked Version to produce a modified Combined Work, in the
- manner specified by section 6 of the GNU GPL for conveying
- Corresponding Source.
-
- 1) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (a) uses at run time
- a copy of the Library already present on the user's computer
- system, and (b) will operate properly with a modified version
- of the Library that is interface-compatible with the Linked
- Version.
-
- e) Provide Installation Information, but only if you would otherwise
- be required to provide such information under section 6 of the
- GNU GPL, and only to the extent that such information is
- necessary to install and execute a modified version of the
- Combined Work produced by recombining or relinking the
- Application with a modified version of the Linked Version. (If
- you use option 4d0, the Installation Information must accompany
- the Minimal Corresponding Source and Corresponding Application
- Code. If you use option 4d1, you must provide the Installation
- Information in the manner specified by section 6 of the GNU GPL
- for conveying Corresponding Source.)
-
- 5. Combined Libraries.
-
- You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
- a) Accompany the combined library with a copy of the same work based
- on the Library, uncombined with any other library facilities,
- conveyed under the terms of this License.
-
- b) Give prominent notice with the combined library that part of it
- is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-
- 6. Revised Versions of the GNU Lesser General Public License.
-
- The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
- If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/register.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/register.go
deleted file mode 100644
index 13b2ef7ba5754c7cc19aefb58914f83a26373196..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/register.go
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 api
-
-import (
- "k8s.io/kubernetes/pkg/api/meta"
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/runtime/serializer"
-)
-
-// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
-var Scheme = runtime.NewScheme()
-
-// Codecs provides access to encoding and decoding for the scheme
-var Codecs = serializer.NewCodecFactory(Scheme)
-
-// GroupName is the group name use in this package
-const GroupName = ""
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-// Unversiond is group version for unversioned API objects
-// TODO: this should be v1 probably
-var Unversioned = unversioned.GroupVersion{Group: "", Version: "v1"}
-
-// ParameterCodec handles versioning of objects that are converted to query parameters.
-var ParameterCodec = runtime.NewParameterCodec(Scheme)
-
-// Kind takes an unqualified kind and returns back a Group qualified GroupKind
-func Kind(kind string) unversioned.GroupKind {
- return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns back a Group qualified GroupResource
-func Resource(resource string) unversioned.GroupResource {
- return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-func AddToScheme(scheme *runtime.Scheme) {
- if err := Scheme.AddIgnoredConversionType(&unversioned.TypeMeta{}, &unversioned.TypeMeta{}); err != nil {
- panic(err)
- }
- scheme.AddKnownTypes(SchemeGroupVersion,
- &Pod{},
- &PodList{},
- &PodStatusResult{},
- &PodTemplate{},
- &PodTemplateList{},
- &ReplicationControllerList{},
- &ReplicationController{},
- &ServiceList{},
- &Service{},
- &ServiceProxyOptions{},
- &NodeList{},
- &Node{},
- &NodeProxyOptions{},
- &Endpoints{},
- &EndpointsList{},
- &Binding{},
- &Event{},
- &EventList{},
- &List{},
- &LimitRange{},
- &LimitRangeList{},
- &ResourceQuota{},
- &ResourceQuotaList{},
- &Namespace{},
- &NamespaceList{},
- &ServiceAccount{},
- &ServiceAccountList{},
- &Secret{},
- &SecretList{},
- &PersistentVolume{},
- &PersistentVolumeList{},
- &PersistentVolumeClaim{},
- &PersistentVolumeClaimList{},
- &DeleteOptions{},
- &ListOptions{},
- &PodAttachOptions{},
- &PodLogOptions{},
- &PodExecOptions{},
- &PodProxyOptions{},
- &ComponentStatus{},
- &ComponentStatusList{},
- &SerializedReference{},
- &RangeAllocation{},
- &ConfigMap{},
- &ConfigMapList{},
- )
-
- // Register Unversioned types under their own special group
- Scheme.AddUnversionedTypes(Unversioned,
- &unversioned.ExportOptions{},
- &unversioned.Status{},
- &unversioned.APIVersions{},
- &unversioned.APIGroupList{},
- &unversioned.APIGroup{},
- &unversioned.APIResourceList{},
- )
-}
-
-func (obj *Pod) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Pod) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodStatusResult) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *PodStatusResult) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodTemplate) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *PodTemplate) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodTemplateList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationController) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *ReplicationController) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationControllerList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Service) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Service) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Endpoints) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Endpoints) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *EndpointsList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Node) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Node) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NodeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NodeProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Binding) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Binding) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Event) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Event) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *EventList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *List) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ListOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *LimitRange) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *LimitRange) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *LimitRangeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ResourceQuota) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *ResourceQuota) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ResourceQuotaList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Namespace) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Namespace) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NamespaceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceAccount) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *ServiceAccount) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceAccountList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Secret) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *Secret) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SecretList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolume) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *PersistentVolume) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeClaim) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *PersistentVolumeClaim) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeClaimList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeleteOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodAttachOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodLogOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodExecOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ComponentStatus) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *ComponentStatus) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ComponentStatusList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SerializedReference) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *RangeAllocation) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *RangeAllocation) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ObjectReference) GetObjectKind() unversioned.ObjectKind { return obj }
-func (obj *ExportOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ConfigMap) GetObjectMeta() meta.Object { return &obj.ObjectMeta }
-func (obj *ConfigMap) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ConfigMapList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity.go
deleted file mode 100644
index aeb43c8976762c3ef1f13767375008370642165f..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity.go
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 resource
-
-import (
- "errors"
- "fmt"
- "math/big"
- "regexp"
- "strings"
-
- flag "github.com/spf13/pflag"
- "speter.net/go/exp/math/dec/inf"
-)
-
-// Quantity is a fixed-point representation of a number.
-// It provides convenient marshaling/unmarshaling in JSON and YAML,
-// in addition to String() and Int64() accessors.
-//
-// The serialization format is:
-//
-// <quantity> ::= <signedNumber><suffix>
-// (Note that <suffix> may be empty, from the "" case in <decimalSI>.)
-// <digit> ::= 0 | 1 | ... | 9
-// <digits> ::= <digit> | <digit><digits>
-// <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
-// <sign> ::= "+" | "-"
-// <signedNumber> ::= <number> | <sign><number>
-// <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI>
-// <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei
-// (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)
-// <decimalSI> ::= m | "" | k | M | G | T | P | E
-// (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
-// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
-//
-// 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: We reserve the right to amend this canonical format, perhaps to
-// allow 1.5 to be canonical.
-// TODO: Remove above disclaimer after all bikeshedding about format is over,
-// or after March 2015.
-//
-// 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.
-//
-// +protobuf=true
-// +protobuf.embed=QuantityProto
-// +protobuf.options.marshal=false
-// +protobuf.options.(gogoproto.goproto_stringer)=false
-type Quantity struct {
- // Amount is public, so you can manipulate it if the accessor
- // functions are not sufficient.
- Amount *inf.Dec
-
- // Change Format at will. See the comment for Canonicalize for
- // more details.
- Format
-}
-
-// Format lists the three possible formattings of a quantity.
-type Format string
-
-const (
- DecimalExponent = Format("DecimalExponent") // e.g., 12e6
- BinarySI = Format("BinarySI") // e.g., 12Mi (12 * 2^20)
- DecimalSI = Format("DecimalSI") // e.g., 12M (12 * 10^6)
-)
-
-// MustParse turns the given string into a quantity or panics; for tests
-// or others cases where you know the string is valid.
-func MustParse(str string) Quantity {
- q, err := ParseQuantity(str)
- if err != nil {
- panic(fmt.Errorf("cannot parse '%v': %v", str, err))
- }
- return *q
-}
-
-// Scale is used for getting and setting the base-10 scaled value.
-// Base-2 scales are omitted for mathematical simplicity.
-// See Quantity.ScaledValue for more details.
-type Scale int
-
-const (
- Nano Scale = -9
- Micro Scale = -6
- Milli Scale = -3
- Kilo Scale = 3
- Mega Scale = 6
- Giga Scale = 9
- Tera Scale = 12
- Peta Scale = 15
- Exa Scale = 18
-)
-
-const (
- // splitREString is used to separate a number from its suffix; as such,
- // this is overly permissive, but that's OK-- it will be checked later.
- splitREString = "^([+-]?[0-9.]+)([eEinumkKMGTP]*[-+]?[0-9]*)$"
-)
-
-var (
- // splitRE is used to get the various parts of a number.
- splitRE = regexp.MustCompile(splitREString)
-
- // Errors that could happen while parsing a string.
- ErrFormatWrong = errors.New("quantities must match the regular expression '" + splitREString + "'")
- ErrNumeric = errors.New("unable to parse numeric part of quantity")
- ErrSuffix = errors.New("unable to parse quantity's suffix")
-
- // Commonly needed big.Int values-- treat as read only!
- bigTen = big.NewInt(10)
- bigZero = big.NewInt(0)
- bigOne = big.NewInt(1)
- bigThousand = big.NewInt(1000)
- big1024 = big.NewInt(1024)
-
- // Commonly needed inf.Dec values-- treat as read only!
- decZero = inf.NewDec(0, 0)
- decOne = inf.NewDec(1, 0)
- decMinusOne = inf.NewDec(-1, 0)
- decThousand = inf.NewDec(1000, 0)
- dec1024 = inf.NewDec(1024, 0)
- decMinus1024 = inf.NewDec(-1024, 0)
-
- // Largest (in magnitude) number allowed.
- maxAllowed = inf.NewDec((1<<63)-1, 0) // == max int64
-
- // The maximum value we can represent milli-units for.
- // Compare with the return value of Quantity.Value() to
- // see if it's safe to use Quantity.MilliValue().
- MaxMilliValue = int64(((1 << 63) - 1) / 1000)
-)
-
-// ParseQuantity turns str into a Quantity, or returns an error.
-func ParseQuantity(str string) (*Quantity, error) {
- parts := splitRE.FindStringSubmatch(strings.TrimSpace(str))
- // regexp returns are entire match, followed by an entry for each () section.
- if len(parts) != 3 {
- return nil, ErrFormatWrong
- }
-
- amount := new(inf.Dec)
- if _, ok := amount.SetString(parts[1]); !ok {
- return nil, ErrNumeric
- }
-
- base, exponent, format, ok := quantitySuffixer.interpret(suffix(parts[2]))
- if !ok {
- return nil, ErrSuffix
- }
-
- // So that no one but us has to think about suffixes, remove it.
- if base == 10 {
- amount.SetScale(amount.Scale() + Scale(exponent).infScale())
- } else if base == 2 {
- // numericSuffix = 2 ** exponent
- numericSuffix := big.NewInt(1).Lsh(bigOne, uint(exponent))
- ub := amount.UnscaledBig()
- amount.SetUnscaledBig(ub.Mul(ub, numericSuffix))
- }
-
- // Cap at min/max bounds.
- sign := amount.Sign()
- if sign == -1 {
- amount.Neg(amount)
- }
-
- // This rounds non-zero values up to the minimum representable value, under the theory that
- // if you want some resources, you should get some resources, even if you asked for way too small
- // of an amount. Arguably, this should be inf.RoundHalfUp (normal rounding), but that would have
- // the side effect of rounding values < .5n to zero.
- if v, ok := amount.Unscaled(); v != int64(0) || !ok {
- amount.Round(amount, Nano.infScale(), inf.RoundUp)
- }
-
- // The max is just a simple cap.
- if amount.Cmp(maxAllowed) > 0 {
- amount.Set(maxAllowed)
- }
- if format == BinarySI && amount.Cmp(decOne) < 0 && amount.Cmp(decZero) > 0 {
- // This avoids rounding and hopefully confusion, too.
- format = DecimalSI
- }
- if sign == -1 {
- amount.Neg(amount)
- }
-
- return &Quantity{amount, format}, nil
-}
-
-// removeFactors divides in a loop; the return values have the property that
-// d == result * factor ^ times
-// d may be modified in place.
-// If d == 0, then the return values will be (0, 0)
-func removeFactors(d, factor *big.Int) (result *big.Int, times int) {
- q := big.NewInt(0)
- m := big.NewInt(0)
- for d.Cmp(bigZero) != 0 {
- q.DivMod(d, factor, m)
- if m.Cmp(bigZero) != 0 {
- break
- }
- times++
- d, q = q, d
- }
- return d, times
-}
-
-// Canonicalize returns the canonical form of q and its suffix (see comment on Quantity).
-//
-// Note about BinarySI:
-// * If q.Format is set to BinarySI and q.Amount represents a non-zero value between
-// -1 and +1, it will be emitted as if q.Format were DecimalSI.
-// * Otherwise, if q.Format is set to BinarySI, frational parts of q.Amount will be
-// rounded up. (1.1i becomes 2i.)
-func (q *Quantity) Canonicalize() (string, suffix) {
- if q.Amount == nil {
- return "0", ""
- }
-
- // zero is zero always
- if q.Amount.Cmp(&inf.Dec{}) == 0 {
- return "0", ""
- }
-
- format := q.Format
- switch format {
- case DecimalExponent, DecimalSI:
- case BinarySI:
- if q.Amount.Cmp(decMinus1024) > 0 && q.Amount.Cmp(dec1024) < 0 {
- // This avoids rounding and hopefully confusion, too.
- format = DecimalSI
- } else {
- tmp := &inf.Dec{}
- tmp.Round(q.Amount, 0, inf.RoundUp)
- if tmp.Cmp(q.Amount) != 0 {
- // Don't lose precision-- show as DecimalSI
- format = DecimalSI
- }
- }
- default:
- format = DecimalExponent
- }
-
- // TODO: If BinarySI formatting is requested but would cause rounding, upgrade to
- // one of the other formats.
- switch format {
- case DecimalExponent, DecimalSI:
- mantissa := q.Amount.UnscaledBig()
- exponent := int(-q.Amount.Scale())
- amount := big.NewInt(0).Set(mantissa)
- // move all factors of 10 into the exponent for easy reasoning
- amount, times := removeFactors(amount, bigTen)
- exponent += times
-
- // make sure exponent is a multiple of 3
- for exponent%3 != 0 {
- amount.Mul(amount, bigTen)
- exponent--
- }
-
- suffix, _ := quantitySuffixer.construct(10, exponent, format)
- number := amount.String()
- return number, suffix
- case BinarySI:
- tmp := &inf.Dec{}
- tmp.Round(q.Amount, 0, inf.RoundUp)
-
- amount, exponent := removeFactors(tmp.UnscaledBig(), big1024)
- suffix, _ := quantitySuffixer.construct(2, exponent*10, format)
- number := amount.String()
- return number, suffix
- }
- return "0", ""
-}
-
-// String formats the Quantity as a string.
-func (q *Quantity) String() string {
- number, suffix := q.Canonicalize()
- return number + string(suffix)
-}
-
-// Cmp compares q and y and returns:
-//
-// -1 if q < y
-// 0 if q == y
-// +1 if q > y
-//
-func (q *Quantity) Cmp(y Quantity) int {
- if q.Amount == nil {
- if y.Amount == nil {
- return 0
- }
- return -y.Amount.Sign()
- }
- if y.Amount == nil {
- return q.Amount.Sign()
- }
- return q.Amount.Cmp(y.Amount)
-}
-
-func (q *Quantity) Add(y Quantity) error {
- switch {
- case y.Amount == nil:
- // Adding 0: do nothing.
- case q.Amount == nil:
- q.Amount = &inf.Dec{}
- return q.Add(y)
- default:
- // we want to preserve the format of the non-zero value
- zero := &inf.Dec{}
- if q.Amount.Cmp(zero) == 0 && y.Amount.Cmp(zero) != 0 {
- q.Format = y.Format
- }
- q.Amount.Add(q.Amount, y.Amount)
- }
- return nil
-}
-
-func (q *Quantity) Sub(y Quantity) error {
- switch {
- case y.Amount == nil:
- // Subtracting 0: do nothing.
- case q.Amount == nil:
- q.Amount = &inf.Dec{}
- return q.Sub(y)
- default:
- // we want to preserve the format of the non-zero value
- zero := &inf.Dec{}
- if q.Amount.Cmp(zero) == 0 && y.Amount.Cmp(zero) != 0 {
- q.Format = y.Format
- }
- q.Amount.Sub(q.Amount, y.Amount)
- }
- return nil
-}
-
-// Neg sets q to the negative value of y.
-// It updates the format of q to match y.
-func (q *Quantity) Neg(y Quantity) error {
- switch {
- case y.Amount == nil:
- *q = y
- case q.Amount == nil:
- q.Amount = &inf.Dec{}
- fallthrough
- default:
- q.Amount.Neg(y.Amount)
- q.Format = y.Format
- }
- return nil
-}
-
-// MarshalJSON implements the json.Marshaller interface.
-func (q Quantity) MarshalJSON() ([]byte, error) {
- return []byte(`"` + q.String() + `"`), nil
-}
-
-// UnmarshalJSON implements the json.Unmarshaller interface.
-func (q *Quantity) UnmarshalJSON(value []byte) error {
- str := string(value)
- parsed, err := ParseQuantity(strings.Trim(str, `"`))
- if err != nil {
- return err
- }
- // This copy is safe because parsed will not be referred to again.
- *q = *parsed
- return nil
-}
-
-// NewQuantity returns a new Quantity representing the given
-// value in the given format.
-func NewQuantity(value int64, format Format) *Quantity {
- return &Quantity{
- Amount: inf.NewDec(value, 0),
- Format: format,
- }
-}
-
-// NewMilliQuantity returns a new Quantity representing the given
-// value * 1/1000 in the given format. Note that BinarySI formatting
-// will round fractional values, and will be changed to DecimalSI for
-// values x where (-1 < x < 1) && (x != 0).
-func NewMilliQuantity(value int64, format Format) *Quantity {
- return &Quantity{
- Amount: inf.NewDec(value, 3),
- Format: format,
- }
-}
-
-// NewScaledQuantity returns a new Quantity representing the given
-// value * 10^scale in DecimalSI format.
-func NewScaledQuantity(value int64, scale Scale) *Quantity {
- return &Quantity{
- Amount: inf.NewDec(value, scale.infScale()),
- Format: DecimalSI,
- }
-}
-
-// Value returns the value of q; any fractional part will be lost.
-func (q *Quantity) Value() int64 {
- return q.ScaledValue(0)
-}
-
-// MilliValue returns the value of ceil(q * 1000); this could overflow an int64;
-// if that's a concern, call Value() first to verify the number is small enough.
-func (q *Quantity) MilliValue() int64 {
- return q.ScaledValue(Milli)
-}
-
-// ScaledValue returns the value of ceil(q * 10^scale); this could overflow an int64.
-// To detect overflow, call Value() first and verify the expected magnitude.
-func (q *Quantity) ScaledValue(scale Scale) int64 {
- if q.Amount == nil {
- return 0
- }
- return scaledValue(q.Amount.UnscaledBig(), int(q.Amount.Scale()), int(scale.infScale()))
-}
-
-// Set sets q's value to be value.
-func (q *Quantity) Set(value int64) {
- q.SetScaled(value, 0)
-}
-
-// SetMilli sets q's value to be value * 1/1000.
-func (q *Quantity) SetMilli(value int64) {
- q.SetScaled(value, Milli)
-}
-
-// SetScaled sets q's value to be value * 10^scale
-func (q *Quantity) SetScaled(value int64, scale Scale) {
- if q.Amount == nil {
- q.Amount = &inf.Dec{}
- }
- q.Amount.SetUnscaled(value)
- q.Amount.SetScale(scale.infScale())
-}
-
-// Copy is a convenience function that makes a deep copy for you. Non-deep
-// copies of quantities share pointers and you will regret that.
-func (q *Quantity) Copy() *Quantity {
- if q.Amount == nil {
- return NewQuantity(0, q.Format)
- }
- tmp := &inf.Dec{}
- return &Quantity{
- Amount: tmp.Set(q.Amount),
- Format: q.Format,
- }
-}
-
-// qFlag is a helper type for the Flag function
-type qFlag struct {
- dest *Quantity
-}
-
-// Sets the value of the internal Quantity. (used by flag & pflag)
-func (qf qFlag) Set(val string) error {
- q, err := ParseQuantity(val)
- if err != nil {
- return err
- }
- // This copy is OK because q will not be referenced again.
- *qf.dest = *q
- return nil
-}
-
-// Converts the value of the internal Quantity to a string. (used by flag & pflag)
-func (qf qFlag) String() string {
- return qf.dest.String()
-}
-
-// States the type of flag this is (Quantity). (used by pflag)
-func (qf qFlag) Type() string {
- return "quantity"
-}
-
-// QuantityFlag is a helper that makes a quantity flag (using standard flag package).
-// Will panic if defaultValue is not a valid quantity.
-func QuantityFlag(flagName, defaultValue, description string) *Quantity {
- q := MustParse(defaultValue)
- flag.Var(NewQuantityFlagValue(&q), flagName, description)
- return &q
-}
-
-// NewQuantityFlagValue returns an object that can be used to back a flag,
-// pointing at the given Quantity variable.
-func NewQuantityFlagValue(q *Quantity) flag.Value {
- return qFlag{q}
-}
-
-// infScale adapts a Scale value to an inf.Scale value.
-func (s Scale) infScale() inf.Scale {
- return inf.Scale(-s) // inf.Scale is upside-down
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go
deleted file mode 100644
index 986d846083dc02d0b8a932b4ab4b8e12a1d518a5..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// +build proto
-
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 resource
-
-import (
- "math/big"
-
- "speter.net/go/exp/math/dec/inf"
-)
-
-// QuantityProto is a struct that is equivalent to Quantity, but intended for
-// protobuf marshalling/unmarshalling. It is generated into a serialization
-// that matches Quantity. Do not use in Go structs.
-//
-// +protobuf=true
-type QuantityProto struct {
- // The format of the quantity
- Format Format
- // The scale dimension of the value
- Scale int32
- // Bigint is serialized as a raw bytes array
- Bigint []byte
-}
-
-// ProtoTime returns the Time as a new ProtoTime value.
-func (q *Quantity) QuantityProto() *QuantityProto {
- if q == nil {
- return &QuantityProto{}
- }
- p := &QuantityProto{
- Format: q.Format,
- }
- if q.Amount != nil {
- p.Scale = int32(q.Amount.Scale())
- p.Bigint = q.Amount.UnscaledBig().Bytes()
- }
- return p
-}
-
-// Size implements the protobuf marshalling interface.
-func (q *Quantity) Size() (n int) { return q.QuantityProto().Size() }
-
-// Reset implements the protobuf marshalling interface.
-func (q *Quantity) Unmarshal(data []byte) error {
- p := QuantityProto{}
- if err := p.Unmarshal(data); err != nil {
- return err
- }
- q.Format = p.Format
- b := big.NewInt(0)
- b.SetBytes(p.Bigint)
- q.Amount = inf.NewDecBig(b, inf.Scale(p.Scale))
- return nil
-}
-
-// Marshal implements the protobuf marshalling interface.
-func (q *Quantity) Marshal() (data []byte, err error) {
- return q.QuantityProto().Marshal()
-}
-
-// MarshalTo implements the protobuf marshalling interface.
-func (q *Quantity) MarshalTo(data []byte) (int, error) {
- return q.QuantityProto().MarshalTo(data)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/service/util.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/service/util.go
deleted file mode 100644
index a77e5b9c70b4d091b337cbd9e6ae046f5dc01bb3..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/service/util.go
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors All rights reserved.
-
-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 service
-
-import (
- "fmt"
- "strings"
-
- netsets "k8s.io/kubernetes/pkg/util/net/sets"
-)
-
-const (
- defaultLoadBalancerSourceRanges = "0.0.0.0/0"
-)
-
-// IsAllowAll checks whether the netsets.IPNet allows traffic from 0.0.0.0/0
-func IsAllowAll(ipnets netsets.IPNet) bool {
- for _, s := range ipnets.StringSlice() {
- if s == "0.0.0.0/0" {
- return true
- }
- }
- return false
-}
-
-// GetLoadBalancerSourceRanges verifies and parses the AnnotationLoadBalancerSourceRangesKey annotation from a service,
-// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
-func GetLoadBalancerSourceRanges(annotations map[string]string) (netsets.IPNet, error) {
- val := annotations[AnnotationLoadBalancerSourceRangesKey]
- val = strings.TrimSpace(val)
- if val == "" {
- val = defaultLoadBalancerSourceRanges
- }
- specs := strings.Split(val, ",")
- ipnets, err := netsets.ParseIPNets(specs...)
- if err != nil {
- return nil, fmt.Errorf("Service annotation %s:%s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", AnnotationLoadBalancerSourceRangesKey, val)
- }
- return ipnets, nil
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/register.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/register.go
deleted file mode 100644
index babc21dfe84e55add0b0c47b2887d84e6b795829..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/register.go
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 unversioned
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = GroupVersion{Group: "", Version: ""}
-
-// Kind takes an unqualified kind and returns back a Group qualified GroupKind
-func Kind(kind string) GroupKind {
- return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) SetGroupVersionKind(gvk *GroupVersionKind) {
- obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
-}
-
-// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) GroupVersionKind() *GroupVersionKind {
- return FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
-}
-
-func (obj *Status) GetObjectKind() ObjectKind { return &obj.TypeMeta }
-func (obj *APIVersions) GetObjectKind() ObjectKind { return &obj.TypeMeta }
-func (obj *APIGroupList) GetObjectKind() ObjectKind { return &obj.TypeMeta }
-func (obj *APIGroup) GetObjectKind() ObjectKind { return &obj.TypeMeta }
-func (obj *APIResourceList) GetObjectKind() ObjectKind { return &obj.TypeMeta }
-func (obj *ExportOptions) GetObjectKind() ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go
deleted file mode 100644
index 1252bf4e6e575ecc0731e2089c3a53ad9101a041..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go
+++ /dev/null
@@ -1,2776 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1
-
-import (
- time "time"
-
- api "k8s.io/kubernetes/pkg/api"
- resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- conversion "k8s.io/kubernetes/pkg/conversion"
- runtime "k8s.io/kubernetes/pkg/runtime"
- intstr "k8s.io/kubernetes/pkg/util/intstr"
- inf "speter.net/go/exp/math/dec/inf"
-)
-
-func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error {
- if in.Amount != nil {
- if newVal, err := c.DeepCopy(in.Amount); err != nil {
- return err
- } else {
- out.Amount = newVal.(*inf.Dec)
- }
- } else {
- out.Amount = nil
- }
- out.Format = in.Format
- return nil
-}
-
-func deepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
- out.SelfLink = in.SelfLink
- out.ResourceVersion = in.ResourceVersion
- return nil
-}
-
-func deepCopy_unversioned_Time(in unversioned.Time, out *unversioned.Time, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.Time); err != nil {
- return err
- } else {
- out.Time = newVal.(time.Time)
- }
- return nil
-}
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1_AWSElasticBlockStoreVolumeSource(in AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_AzureFileVolumeSource(in AzureFileVolumeSource, out *AzureFileVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_Binding(in Binding, out *Binding, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectReference(in.Target, &out.Target, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Capabilities(in Capabilities, out *Capabilities, c *conversion.Cloner) error {
- if in.Add != nil {
- out.Add = make([]Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = in.Add[i]
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = in.Drop[i]
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func deepCopy_v1_CephFSVolumeSource(in CephFSVolumeSource, out *CephFSVolumeSource, c *conversion.Cloner) error {
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_CinderVolumeSource(in CinderVolumeSource, out *CinderVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ComponentCondition(in ComponentCondition, out *ComponentCondition, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Status = in.Status
- out.Message = in.Message
- out.Error = in.Error
- return nil
-}
-
-func deepCopy_v1_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Conditions != nil {
- out.Conditions = make([]ComponentCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := deepCopy_v1_ComponentCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- return nil
-}
-
-func deepCopy_v1_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ComponentStatus, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_ComponentStatus(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ConfigMap(in ConfigMap, out *ConfigMap, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Data != nil {
- out.Data = make(map[string]string)
- for key, val := range in.Data {
- out.Data[key] = val
- }
- } else {
- out.Data = nil
- }
- return nil
-}
-
-func deepCopy_v1_ConfigMapKeySelector(in ConfigMapKeySelector, out *ConfigMapKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_ConfigMapList(in ConfigMapList, out *ConfigMapList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ConfigMap, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_ConfigMap(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ConfigMapVolumeSource(in ConfigMapVolumeSource, out *ConfigMapVolumeSource, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_KeyToPath(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_Container(in Container, out *Container, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := deepCopy_v1_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]EnvVar, len(in.Env))
- for i := range in.Env {
- if err := deepCopy_v1_EnvVar(in.Env[i], &out.Env[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := deepCopy_v1_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(Probe)
- if err := deepCopy_v1_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(Probe)
- if err := deepCopy_v1_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- if in.Lifecycle != nil {
- out.Lifecycle = new(Lifecycle)
- if err := deepCopy_v1_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = in.ImagePullPolicy
- if in.SecurityContext != nil {
- out.SecurityContext = new(SecurityContext)
- if err := deepCopy_v1_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func deepCopy_v1_ContainerImage(in ContainerImage, out *ContainerImage, c *conversion.Cloner) error {
- if in.Names != nil {
- out.Names = make([]string, len(in.Names))
- for i := range in.Names {
- out.Names[i] = in.Names[i]
- }
- } else {
- out.Names = nil
- }
- out.SizeBytes = in.SizeBytes
- return nil
-}
-
-func deepCopy_v1_ContainerPort(in ContainerPort, out *ContainerPort, c *conversion.Cloner) error {
- out.Name = in.Name
- out.HostPort = in.HostPort
- out.ContainerPort = in.ContainerPort
- out.Protocol = in.Protocol
- out.HostIP = in.HostIP
- return nil
-}
-
-func deepCopy_v1_ContainerState(in ContainerState, out *ContainerState, c *conversion.Cloner) error {
- if in.Waiting != nil {
- out.Waiting = new(ContainerStateWaiting)
- if err := deepCopy_v1_ContainerStateWaiting(*in.Waiting, out.Waiting, c); err != nil {
- return err
- }
- } else {
- out.Waiting = nil
- }
- if in.Running != nil {
- out.Running = new(ContainerStateRunning)
- if err := deepCopy_v1_ContainerStateRunning(*in.Running, out.Running, c); err != nil {
- return err
- }
- } else {
- out.Running = nil
- }
- if in.Terminated != nil {
- out.Terminated = new(ContainerStateTerminated)
- if err := deepCopy_v1_ContainerStateTerminated(*in.Terminated, out.Terminated, c); err != nil {
- return err
- }
- } else {
- out.Terminated = nil
- }
- return nil
-}
-
-func deepCopy_v1_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_ContainerStateTerminated(in ContainerStateTerminated, out *ContainerStateTerminated, c *conversion.Cloner) error {
- out.ExitCode = in.ExitCode
- out.Signal = in.Signal
- out.Reason = in.Reason
- out.Message = in.Message
- if err := deepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.FinishedAt, &out.FinishedAt, c); err != nil {
- return err
- }
- out.ContainerID = in.ContainerID
- return nil
-}
-
-func deepCopy_v1_ContainerStateWaiting(in ContainerStateWaiting, out *ContainerStateWaiting, c *conversion.Cloner) error {
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func deepCopy_v1_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *conversion.Cloner) error {
- out.Name = in.Name
- if err := deepCopy_v1_ContainerState(in.State, &out.State, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ContainerState(in.LastTerminationState, &out.LastTerminationState, c); err != nil {
- return err
- }
- out.Ready = in.Ready
- out.RestartCount = in.RestartCount
- out.Image = in.Image
- out.ImageID = in.ImageID
- out.ContainerID = in.ContainerID
- return nil
-}
-
-func deepCopy_v1_DaemonEndpoint(in DaemonEndpoint, out *DaemonEndpoint, c *conversion.Cloner) error {
- out.Port = in.Port
- return nil
-}
-
-func deepCopy_v1_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if in.GracePeriodSeconds != nil {
- out.GracePeriodSeconds = new(int64)
- *out.GracePeriodSeconds = *in.GracePeriodSeconds
- } else {
- out.GracePeriodSeconds = nil
- }
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeFile(in DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_v1_ObjectFieldSelector(in.FieldRef, &out.FieldRef, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeSource(in DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, c *conversion.Cloner) error {
- if in.Items != nil {
- out.Items = make([]DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_DownwardAPIVolumeFile(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVolumeSource, c *conversion.Cloner) error {
- out.Medium = in.Medium
- return nil
-}
-
-func deepCopy_v1_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error {
- out.IP = in.IP
- if in.TargetRef != nil {
- out.TargetRef = new(ObjectReference)
- if err := deepCopy_v1_ObjectReference(*in.TargetRef, out.TargetRef, c); err != nil {
- return err
- }
- } else {
- out.TargetRef = nil
- }
- return nil
-}
-
-func deepCopy_v1_EndpointPort(in EndpointPort, out *EndpointPort, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Port = in.Port
- out.Protocol = in.Protocol
- return nil
-}
-
-func deepCopy_v1_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conversion.Cloner) error {
- if in.Addresses != nil {
- out.Addresses = make([]EndpointAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := deepCopy_v1_EndpointAddress(in.Addresses[i], &out.Addresses[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Addresses = nil
- }
- if in.NotReadyAddresses != nil {
- out.NotReadyAddresses = make([]EndpointAddress, len(in.NotReadyAddresses))
- for i := range in.NotReadyAddresses {
- if err := deepCopy_v1_EndpointAddress(in.NotReadyAddresses[i], &out.NotReadyAddresses[i], c); err != nil {
- return err
- }
- }
- } else {
- out.NotReadyAddresses = nil
- }
- if in.Ports != nil {
- out.Ports = make([]EndpointPort, len(in.Ports))
- for i := range in.Ports {
- if err := deepCopy_v1_EndpointPort(in.Ports[i], &out.Ports[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- return nil
-}
-
-func deepCopy_v1_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Subsets != nil {
- out.Subsets = make([]EndpointSubset, len(in.Subsets))
- for i := range in.Subsets {
- if err := deepCopy_v1_EndpointSubset(in.Subsets[i], &out.Subsets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Subsets = nil
- }
- return nil
-}
-
-func deepCopy_v1_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Endpoints, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Endpoints(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_EnvVar(in EnvVar, out *EnvVar, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- if in.ValueFrom != nil {
- out.ValueFrom = new(EnvVarSource)
- if err := deepCopy_v1_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func deepCopy_v1_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion.Cloner) error {
- if in.FieldRef != nil {
- out.FieldRef = new(ObjectFieldSelector)
- if err := deepCopy_v1_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(ConfigMapKeySelector)
- if err := deepCopy_v1_ConfigMapKeySelector(*in.ConfigMapKeyRef, out.ConfigMapKeyRef, c); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(SecretKeySelector)
- if err := deepCopy_v1_SecretKeySelector(*in.SecretKeyRef, out.SecretKeyRef, c); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func deepCopy_v1_Event(in Event, out *Event, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectReference(in.InvolvedObject, &out.InvolvedObject, c); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- if err := deepCopy_v1_EventSource(in.Source, &out.Source, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil {
- return err
- }
- out.Count = in.Count
- out.Type = in.Type
- return nil
-}
-
-func deepCopy_v1_EventList(in EventList, out *EventList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Event, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Event(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_EventSource(in EventSource, out *EventSource, c *conversion.Cloner) error {
- out.Component = in.Component
- out.Host = in.Host
- return nil
-}
-
-func deepCopy_v1_ExecAction(in ExecAction, out *ExecAction, c *conversion.Cloner) error {
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func deepCopy_v1_ExportOptions(in ExportOptions, out *ExportOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Export = in.Export
- out.Exact = in.Exact
- return nil
-}
-
-func deepCopy_v1_FCVolumeSource(in FCVolumeSource, out *FCVolumeSource, c *conversion.Cloner) error {
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = *in.Lun
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_FlexVolumeSource(in FlexVolumeSource, out *FlexVolumeSource, c *conversion.Cloner) error {
- out.Driver = in.Driver
- out.FSType = in.FSType
- if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func deepCopy_v1_FlockerVolumeSource(in FlockerVolumeSource, out *FlockerVolumeSource, c *conversion.Cloner) error {
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func deepCopy_v1_GCEPersistentDiskVolumeSource(in GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, c *conversion.Cloner) error {
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_GitRepoVolumeSource(in GitRepoVolumeSource, out *GitRepoVolumeSource, c *conversion.Cloner) error {
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func deepCopy_v1_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *GlusterfsVolumeSource, c *conversion.Cloner) error {
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = in.Scheme
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := deepCopy_v1_HTTPHeader(in.HTTPHeaders[i], &out.HTTPHeaders[i], c); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func deepCopy_v1_HTTPHeader(in HTTPHeader, out *HTTPHeader, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func deepCopy_v1_Handler(in Handler, out *Handler, c *conversion.Cloner) error {
- if in.Exec != nil {
- out.Exec = new(ExecAction)
- if err := deepCopy_v1_ExecAction(*in.Exec, out.Exec, c); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- if in.HTTPGet != nil {
- out.HTTPGet = new(HTTPGetAction)
- if err := deepCopy_v1_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- if in.TCPSocket != nil {
- out.TCPSocket = new(TCPSocketAction)
- if err := deepCopy_v1_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func deepCopy_v1_HostPathVolumeSource(in HostPathVolumeSource, out *HostPathVolumeSource, c *conversion.Cloner) error {
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_ISCSIVolumeSource(in ISCSIVolumeSource, out *ISCSIVolumeSource, c *conversion.Cloner) error {
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = in.Lun
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_KeyToPath(in KeyToPath, out *KeyToPath, c *conversion.Cloner) error {
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner) error {
- if in.PostStart != nil {
- out.PostStart = new(Handler)
- if err := deepCopy_v1_Handler(*in.PostStart, out.PostStart, c); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- if in.PreStop != nil {
- out.PreStop = new(Handler)
- if err := deepCopy_v1_Handler(*in.PreStop, out.PreStop, c); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func deepCopy_v1_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_LimitRangeSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conversion.Cloner) error {
- out.Type = in.Type
- if in.Max != nil {
- out.Max = make(ResourceList)
- for key, val := range in.Max {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Max[key] = *newVal
- }
- } else {
- out.Max = nil
- }
- if in.Min != nil {
- out.Min = make(ResourceList)
- for key, val := range in.Min {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Min[key] = *newVal
- }
- } else {
- out.Min = nil
- }
- if in.Default != nil {
- out.Default = make(ResourceList)
- for key, val := range in.Default {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Default[key] = *newVal
- }
- } else {
- out.Default = nil
- }
- if in.DefaultRequest != nil {
- out.DefaultRequest = make(ResourceList)
- for key, val := range in.DefaultRequest {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.DefaultRequest[key] = *newVal
- }
- } else {
- out.DefaultRequest = nil
- }
- if in.MaxLimitRequestRatio != nil {
- out.MaxLimitRequestRatio = make(ResourceList)
- for key, val := range in.MaxLimitRequestRatio {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.MaxLimitRequestRatio[key] = *newVal
- }
- } else {
- out.MaxLimitRequestRatio = nil
- }
- return nil
-}
-
-func deepCopy_v1_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]LimitRange, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_LimitRange(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conversion.Cloner) error {
- if in.Limits != nil {
- out.Limits = make([]LimitRangeItem, len(in.Limits))
- for i := range in.Limits {
- if err := deepCopy_v1_LimitRangeItem(in.Limits[i], &out.Limits[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Limits = nil
- }
- return nil
-}
-
-func deepCopy_v1_List(in List, out *List, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]runtime.RawExtension, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_runtime_RawExtension(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.LabelSelector = in.LabelSelector
- out.FieldSelector = in.FieldSelector
- out.Watch = in.Watch
- out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
- return nil
-}
-
-func deepCopy_v1_LoadBalancerIngress(in LoadBalancerIngress, out *LoadBalancerIngress, c *conversion.Cloner) error {
- out.IP = in.IP
- out.Hostname = in.Hostname
- return nil
-}
-
-func deepCopy_v1_LoadBalancerStatus(in LoadBalancerStatus, out *LoadBalancerStatus, c *conversion.Cloner) error {
- if in.Ingress != nil {
- out.Ingress = make([]LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := deepCopy_v1_LoadBalancerIngress(in.Ingress[i], &out.Ingress[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ingress = nil
- }
- return nil
-}
-
-func deepCopy_v1_LocalObjectReference(in LocalObjectReference, out *LocalObjectReference, c *conversion.Cloner) error {
- out.Name = in.Name
- return nil
-}
-
-func deepCopy_v1_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *conversion.Cloner) error {
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_NamespaceSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_NamespaceStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Namespace, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Namespace(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_NamespaceSpec(in NamespaceSpec, out *NamespaceSpec, c *conversion.Cloner) error {
- if in.Finalizers != nil {
- out.Finalizers = make([]FinalizerName, len(in.Finalizers))
- for i := range in.Finalizers {
- out.Finalizers[i] = in.Finalizers[i]
- }
- } else {
- out.Finalizers = nil
- }
- return nil
-}
-
-func deepCopy_v1_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *conversion.Cloner) error {
- out.Phase = in.Phase
- return nil
-}
-
-func deepCopy_v1_Node(in Node, out *Node, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_NodeSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_NodeStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_NodeAddress(in NodeAddress, out *NodeAddress, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Address = in.Address
- return nil
-}
-
-func deepCopy_v1_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Status = in.Status
- if err := deepCopy_unversioned_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func deepCopy_v1_NodeDaemonEndpoints(in NodeDaemonEndpoints, out *NodeDaemonEndpoints, c *conversion.Cloner) error {
- if err := deepCopy_v1_DaemonEndpoint(in.KubeletEndpoint, &out.KubeletEndpoint, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Node, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Node(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_NodeProxyOptions(in NodeProxyOptions, out *NodeProxyOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_NodeSpec(in NodeSpec, out *NodeSpec, c *conversion.Cloner) error {
- out.PodCIDR = in.PodCIDR
- out.ExternalID = in.ExternalID
- out.ProviderID = in.ProviderID
- out.Unschedulable = in.Unschedulable
- return nil
-}
-
-func deepCopy_v1_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Cloner) error {
- if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Capacity[key] = *newVal
- }
- } else {
- out.Capacity = nil
- }
- if in.Allocatable != nil {
- out.Allocatable = make(ResourceList)
- for key, val := range in.Allocatable {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Allocatable[key] = *newVal
- }
- } else {
- out.Allocatable = nil
- }
- out.Phase = in.Phase
- if in.Conditions != nil {
- out.Conditions = make([]NodeCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := deepCopy_v1_NodeCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- if in.Addresses != nil {
- out.Addresses = make([]NodeAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := deepCopy_v1_NodeAddress(in.Addresses[i], &out.Addresses[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Addresses = nil
- }
- if err := deepCopy_v1_NodeDaemonEndpoints(in.DaemonEndpoints, &out.DaemonEndpoints, c); err != nil {
- return err
- }
- if err := deepCopy_v1_NodeSystemInfo(in.NodeInfo, &out.NodeInfo, c); err != nil {
- return err
- }
- if in.Images != nil {
- out.Images = make([]ContainerImage, len(in.Images))
- for i := range in.Images {
- if err := deepCopy_v1_ContainerImage(in.Images[i], &out.Images[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Images = nil
- }
- return nil
-}
-
-func deepCopy_v1_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conversion.Cloner) error {
- out.MachineID = in.MachineID
- out.SystemUUID = in.SystemUUID
- out.BootID = in.BootID
- out.KernelVersion = in.KernelVersion
- out.OSImage = in.OSImage
- out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
- out.KubeletVersion = in.KubeletVersion
- out.KubeProxyVersion = in.KubeProxyVersion
- return nil
-}
-
-func deepCopy_v1_ObjectFieldSelector(in ObjectFieldSelector, out *ObjectFieldSelector, c *conversion.Cloner) error {
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func deepCopy_v1_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Cloner) error {
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := deepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
- return err
- }
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func deepCopy_v1_ObjectReference(in ObjectReference, out *ObjectReference, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.Namespace = in.Namespace
- out.Name = in.Name
- out.UID = in.UID
- out.APIVersion = in.APIVersion
- out.ResourceVersion = in.ResourceVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func deepCopy_v1_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PersistentVolumeSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PersistentVolumeStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PersistentVolumeClaimSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PersistentVolumeClaimStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]PersistentVolumeClaim, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_PersistentVolumeClaim(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, c *conversion.Cloner) error {
- if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = in.AccessModes[i]
- }
- } else {
- out.AccessModes = nil
- }
- if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
- return err
- }
- out.VolumeName = in.VolumeName
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, c *conversion.Cloner) error {
- out.Phase = in.Phase
- if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = in.AccessModes[i]
- }
- } else {
- out.AccessModes = nil
- }
- if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Capacity[key] = *newVal
- }
- } else {
- out.Capacity = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error {
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]PersistentVolume, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_PersistentVolume(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeSource(in PersistentVolumeSource, out *PersistentVolumeSource, c *conversion.Cloner) error {
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
- if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
- if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- if in.HostPath != nil {
- out.HostPath = new(HostPathVolumeSource)
- if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- if in.Glusterfs != nil {
- out.Glusterfs = new(GlusterfsVolumeSource)
- if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- if in.NFS != nil {
- out.NFS = new(NFSVolumeSource)
- if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- if in.RBD != nil {
- out.RBD = new(RBDVolumeSource)
- if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- if in.ISCSI != nil {
- out.ISCSI = new(ISCSIVolumeSource)
- if err := deepCopy_v1_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- if in.Cinder != nil {
- out.Cinder = new(CinderVolumeSource)
- if err := deepCopy_v1_CinderVolumeSource(*in.Cinder, out.Cinder, c); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- if in.CephFS != nil {
- out.CephFS = new(CephFSVolumeSource)
- if err := deepCopy_v1_CephFSVolumeSource(*in.CephFS, out.CephFS, c); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- if in.FC != nil {
- out.FC = new(FCVolumeSource)
- if err := deepCopy_v1_FCVolumeSource(*in.FC, out.FC, c); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- if in.Flocker != nil {
- out.Flocker = new(FlockerVolumeSource)
- if err := deepCopy_v1_FlockerVolumeSource(*in.Flocker, out.Flocker, c); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- if in.FlexVolume != nil {
- out.FlexVolume = new(FlexVolumeSource)
- if err := deepCopy_v1_FlexVolumeSource(*in.FlexVolume, out.FlexVolume, c); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- if in.AzureFile != nil {
- out.AzureFile = new(AzureFileVolumeSource)
- if err := deepCopy_v1_AzureFileVolumeSource(*in.AzureFile, out.AzureFile, c); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentVolumeSpec, c *conversion.Cloner) error {
- if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Capacity[key] = *newVal
- }
- } else {
- out.Capacity = nil
- }
- if err := deepCopy_v1_PersistentVolumeSource(in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil {
- return err
- }
- if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = in.AccessModes[i]
- }
- } else {
- out.AccessModes = nil
- }
- if in.ClaimRef != nil {
- out.ClaimRef = new(ObjectReference)
- if err := deepCopy_v1_ObjectReference(*in.ClaimRef, out.ClaimRef, c); err != nil {
- return err
- }
- } else {
- out.ClaimRef = nil
- }
- out.PersistentVolumeReclaimPolicy = in.PersistentVolumeReclaimPolicy
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeStatus(in PersistentVolumeStatus, out *PersistentVolumeStatus, c *conversion.Cloner) error {
- out.Phase = in.Phase
- out.Message = in.Message
- out.Reason = in.Reason
- return nil
-}
-
-func deepCopy_v1_Pod(in Pod, out *Pod, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_PodAttachOptions(in PodAttachOptions, out *PodAttachOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Stdin = in.Stdin
- out.Stdout = in.Stdout
- out.Stderr = in.Stderr
- out.TTY = in.TTY
- out.Container = in.Container
- return nil
-}
-
-func deepCopy_v1_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Status = in.Status
- if err := deepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func deepCopy_v1_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Stdin = in.Stdin
- out.Stdout = in.Stdout
- out.Stderr = in.Stderr
- out.TTY = in.TTY
- out.Container = in.Container
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodList(in PodList, out *PodList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Pod, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Pod(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Container = in.Container
- out.Follow = in.Follow
- out.Previous = in.Previous
- if in.SinceSeconds != nil {
- out.SinceSeconds = new(int64)
- *out.SinceSeconds = *in.SinceSeconds
- } else {
- out.SinceSeconds = nil
- }
- if in.SinceTime != nil {
- out.SinceTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.SinceTime, out.SinceTime, c); err != nil {
- return err
- }
- } else {
- out.SinceTime = nil
- }
- out.Timestamps = in.Timestamps
- if in.TailLines != nil {
- out.TailLines = new(int64)
- *out.TailLines = *in.TailLines
- } else {
- out.TailLines = nil
- }
- if in.LimitBytes != nil {
- out.LimitBytes = new(int64)
- *out.LimitBytes = *in.LimitBytes
- } else {
- out.LimitBytes = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_PodSecurityContext(in PodSecurityContext, out *PodSecurityContext, c *conversion.Cloner) error {
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.SupplementalGroups != nil {
- out.SupplementalGroups = make([]int64, len(in.SupplementalGroups))
- for i := range in.SupplementalGroups {
- out.SupplementalGroups[i] = in.SupplementalGroups[i]
- }
- } else {
- out.SupplementalGroups = nil
- }
- if in.FSGroup != nil {
- out.FSGroup = new(int64)
- *out.FSGroup = *in.FSGroup
- } else {
- out.FSGroup = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error {
- if in.Volumes != nil {
- out.Volumes = make([]Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := deepCopy_v1_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]Container, len(in.Containers))
- for i := range in.Containers {
- if err := deepCopy_v1_Container(in.Containers[i], &out.Containers[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = in.RestartPolicy
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = in.DNSPolicy
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- out.DeprecatedServiceAccount = in.DeprecatedServiceAccount
- out.NodeName = in.NodeName
- out.HostNetwork = in.HostNetwork
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if in.SecurityContext != nil {
- out.SecurityContext = new(PodSecurityContext)
- if err := deepCopy_v1_PodSecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := deepCopy_v1_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner) error {
- out.Phase = in.Phase
- if in.Conditions != nil {
- out.Conditions = make([]PodCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := deepCopy_v1_PodCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- out.Message = in.Message
- out.Reason = in.Reason
- out.HostIP = in.HostIP
- out.PodIP = in.PodIP
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.StartTime, out.StartTime, c); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- if in.ContainerStatuses != nil {
- out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses))
- for i := range in.ContainerStatuses {
- if err := deepCopy_v1_ContainerStatus(in.ContainerStatuses[i], &out.ContainerStatuses[i], c); err != nil {
- return err
- }
- }
- } else {
- out.ContainerStatuses = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]PodTemplate, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_PodTemplate(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *conversion.Cloner) error {
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Probe(in Probe, out *Probe, c *conversion.Cloner) error {
- if err := deepCopy_v1_Handler(in.Handler, &out.Handler, c); err != nil {
- return err
- }
- out.InitialDelaySeconds = in.InitialDelaySeconds
- out.TimeoutSeconds = in.TimeoutSeconds
- out.PeriodSeconds = in.PeriodSeconds
- out.SuccessThreshold = in.SuccessThreshold
- out.FailureThreshold = in.FailureThreshold
- return nil
-}
-
-func deepCopy_v1_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *conversion.Cloner) error {
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- out.Range = in.Range
- if in.Data != nil {
- out.Data = make([]uint8, len(in.Data))
- for i := range in.Data {
- out.Data[i] = in.Data[i]
- }
- } else {
- out.Data = nil
- }
- return nil
-}
-
-func deepCopy_v1_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ReplicationControllerSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ReplicationControllerStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ReplicationController, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_ReplicationController(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ReplicationControllerSpec(in ReplicationControllerSpec, out *ReplicationControllerSpec, c *conversion.Cloner) error {
- if in.Replicas != nil {
- out.Replicas = new(int32)
- *out.Replicas = *in.Replicas
- } else {
- out.Replicas = nil
- }
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
- if in.Template != nil {
- out.Template = new(PodTemplateSpec)
- if err := deepCopy_v1_PodTemplateSpec(*in.Template, out.Template, c); err != nil {
- return err
- }
- } else {
- out.Template = nil
- }
- return nil
-}
-
-func deepCopy_v1_ReplicationControllerStatus(in ReplicationControllerStatus, out *ReplicationControllerStatus, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- out.FullyLabeledReplicas = in.FullyLabeledReplicas
- out.ObservedGeneration = in.ObservedGeneration
- return nil
-}
-
-func deepCopy_v1_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ResourceQuotaSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ResourceQuotaStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ResourceQuota, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_ResourceQuota(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec, c *conversion.Cloner) error {
- if in.Hard != nil {
- out.Hard = make(ResourceList)
- for key, val := range in.Hard {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Hard[key] = *newVal
- }
- } else {
- out.Hard = nil
- }
- if in.Scopes != nil {
- out.Scopes = make([]ResourceQuotaScope, len(in.Scopes))
- for i := range in.Scopes {
- out.Scopes[i] = in.Scopes[i]
- }
- } else {
- out.Scopes = nil
- }
- return nil
-}
-
-func deepCopy_v1_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuotaStatus, c *conversion.Cloner) error {
- if in.Hard != nil {
- out.Hard = make(ResourceList)
- for key, val := range in.Hard {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Hard[key] = *newVal
- }
- } else {
- out.Hard = nil
- }
- if in.Used != nil {
- out.Used = make(ResourceList)
- for key, val := range in.Used {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Used[key] = *newVal
- }
- } else {
- out.Used = nil
- }
- return nil
-}
-
-func deepCopy_v1_ResourceRequirements(in ResourceRequirements, out *ResourceRequirements, c *conversion.Cloner) error {
- if in.Limits != nil {
- out.Limits = make(ResourceList)
- for key, val := range in.Limits {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Limits[key] = *newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(ResourceList)
- for key, val := range in.Requests {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Requests[key] = *newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func deepCopy_v1_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conversion.Cloner) error {
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func deepCopy_v1_Secret(in Secret, out *Secret, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Data != nil {
- out.Data = make(map[string][]uint8)
- for key, val := range in.Data {
- if newVal, err := c.DeepCopy(val); err != nil {
- return err
- } else {
- out.Data[key] = newVal.([]uint8)
- }
- }
- } else {
- out.Data = nil
- }
- out.Type = in.Type
- return nil
-}
-
-func deepCopy_v1_SecretKeySelector(in SecretKeySelector, out *SecretKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Secret, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Secret(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- return nil
-}
-
-func deepCopy_v1_SecurityContext(in SecurityContext, out *SecurityContext, c *conversion.Cloner) error {
- if in.Capabilities != nil {
- out.Capabilities = new(Capabilities)
- if err := deepCopy_v1_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func deepCopy_v1_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectReference(in.Reference, &out.Reference, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Service(in Service, out *Service, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ServiceSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ServiceStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Secrets != nil {
- out.Secrets = make([]ObjectReference, len(in.Secrets))
- for i := range in.Secrets {
- if err := deepCopy_v1_ObjectReference(in.Secrets[i], &out.Secrets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Secrets = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := deepCopy_v1_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func deepCopy_v1_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ServiceAccount, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_ServiceAccount(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Service, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Service(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Protocol = in.Protocol
- out.Port = in.Port
- if err := deepCopy_intstr_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil {
- return err
- }
- out.NodePort = in.NodePort
- return nil
-}
-
-func deepCopy_v1_ServiceProxyOptions(in ServiceProxyOptions, out *ServiceProxyOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cloner) error {
- if in.Ports != nil {
- out.Ports = make([]ServicePort, len(in.Ports))
- for i := range in.Ports {
- if err := deepCopy_v1_ServicePort(in.Ports[i], &out.Ports[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
- out.ClusterIP = in.ClusterIP
- out.Type = in.Type
- if in.ExternalIPs != nil {
- out.ExternalIPs = make([]string, len(in.ExternalIPs))
- for i := range in.ExternalIPs {
- out.ExternalIPs[i] = in.ExternalIPs[i]
- }
- } else {
- out.ExternalIPs = nil
- }
- if in.DeprecatedPublicIPs != nil {
- out.DeprecatedPublicIPs = make([]string, len(in.DeprecatedPublicIPs))
- for i := range in.DeprecatedPublicIPs {
- out.DeprecatedPublicIPs[i] = in.DeprecatedPublicIPs[i]
- }
- } else {
- out.DeprecatedPublicIPs = nil
- }
- out.SessionAffinity = in.SessionAffinity
- out.LoadBalancerIP = in.LoadBalancerIP
- return nil
-}
-
-func deepCopy_v1_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *conversion.Cloner) error {
- if err := deepCopy_v1_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error {
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Volume(in Volume, out *Volume, c *conversion.Cloner) error {
- out.Name = in.Name
- if err := deepCopy_v1_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cloner) error {
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func deepCopy_v1_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion.Cloner) error {
- if in.HostPath != nil {
- out.HostPath = new(HostPathVolumeSource)
- if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- if in.EmptyDir != nil {
- out.EmptyDir = new(EmptyDirVolumeSource)
- if err := deepCopy_v1_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
- if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
- if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- if in.GitRepo != nil {
- out.GitRepo = new(GitRepoVolumeSource)
- if err := deepCopy_v1_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- if in.Secret != nil {
- out.Secret = new(SecretVolumeSource)
- if err := deepCopy_v1_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- if in.NFS != nil {
- out.NFS = new(NFSVolumeSource)
- if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- if in.ISCSI != nil {
- out.ISCSI = new(ISCSIVolumeSource)
- if err := deepCopy_v1_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- if in.Glusterfs != nil {
- out.Glusterfs = new(GlusterfsVolumeSource)
- if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(PersistentVolumeClaimVolumeSource)
- if err := deepCopy_v1_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaim, out.PersistentVolumeClaim, c); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- if in.RBD != nil {
- out.RBD = new(RBDVolumeSource)
- if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- if in.FlexVolume != nil {
- out.FlexVolume = new(FlexVolumeSource)
- if err := deepCopy_v1_FlexVolumeSource(*in.FlexVolume, out.FlexVolume, c); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- if in.Cinder != nil {
- out.Cinder = new(CinderVolumeSource)
- if err := deepCopy_v1_CinderVolumeSource(*in.Cinder, out.Cinder, c); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- if in.CephFS != nil {
- out.CephFS = new(CephFSVolumeSource)
- if err := deepCopy_v1_CephFSVolumeSource(*in.CephFS, out.CephFS, c); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- if in.Flocker != nil {
- out.Flocker = new(FlockerVolumeSource)
- if err := deepCopy_v1_FlockerVolumeSource(*in.Flocker, out.Flocker, c); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(DownwardAPIVolumeSource)
- if err := deepCopy_v1_DownwardAPIVolumeSource(*in.DownwardAPI, out.DownwardAPI, c); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- if in.FC != nil {
- out.FC = new(FCVolumeSource)
- if err := deepCopy_v1_FCVolumeSource(*in.FC, out.FC, c); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- if in.AzureFile != nil {
- out.AzureFile = new(AzureFileVolumeSource)
- if err := deepCopy_v1_AzureFileVolumeSource(*in.AzureFile, out.AzureFile, c); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- if in.ConfigMap != nil {
- out.ConfigMap = new(ConfigMapVolumeSource)
- if err := deepCopy_v1_ConfigMapVolumeSource(*in.ConfigMap, out.ConfigMap, c); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func deepCopy_runtime_RawExtension(in runtime.RawExtension, out *runtime.RawExtension, c *conversion.Cloner) error {
- if in.RawJSON != nil {
- out.RawJSON = make([]uint8, len(in.RawJSON))
- for i := range in.RawJSON {
- out.RawJSON[i] = in.RawJSON[i]
- }
- } else {
- out.RawJSON = nil
- }
- if newVal, err := c.DeepCopy(in.Object); err != nil {
- return err
- } else if newVal == nil {
- out.Object = nil
- } else {
- out.Object = newVal.(runtime.Object)
- }
- return nil
-}
-
-func deepCopy_intstr_IntOrString(in intstr.IntOrString, out *intstr.IntOrString, c *conversion.Cloner) error {
- out.Type = in.Type
- out.IntVal = in.IntVal
- out.StrVal = in.StrVal
- return nil
-}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_resource_Quantity,
- deepCopy_unversioned_ListMeta,
- deepCopy_unversioned_Time,
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1_AWSElasticBlockStoreVolumeSource,
- deepCopy_v1_AzureFileVolumeSource,
- deepCopy_v1_Binding,
- deepCopy_v1_Capabilities,
- deepCopy_v1_CephFSVolumeSource,
- deepCopy_v1_CinderVolumeSource,
- deepCopy_v1_ComponentCondition,
- deepCopy_v1_ComponentStatus,
- deepCopy_v1_ComponentStatusList,
- deepCopy_v1_ConfigMap,
- deepCopy_v1_ConfigMapKeySelector,
- deepCopy_v1_ConfigMapList,
- deepCopy_v1_ConfigMapVolumeSource,
- deepCopy_v1_Container,
- deepCopy_v1_ContainerImage,
- deepCopy_v1_ContainerPort,
- deepCopy_v1_ContainerState,
- deepCopy_v1_ContainerStateRunning,
- deepCopy_v1_ContainerStateTerminated,
- deepCopy_v1_ContainerStateWaiting,
- deepCopy_v1_ContainerStatus,
- deepCopy_v1_DaemonEndpoint,
- deepCopy_v1_DeleteOptions,
- deepCopy_v1_DownwardAPIVolumeFile,
- deepCopy_v1_DownwardAPIVolumeSource,
- deepCopy_v1_EmptyDirVolumeSource,
- deepCopy_v1_EndpointAddress,
- deepCopy_v1_EndpointPort,
- deepCopy_v1_EndpointSubset,
- deepCopy_v1_Endpoints,
- deepCopy_v1_EndpointsList,
- deepCopy_v1_EnvVar,
- deepCopy_v1_EnvVarSource,
- deepCopy_v1_Event,
- deepCopy_v1_EventList,
- deepCopy_v1_EventSource,
- deepCopy_v1_ExecAction,
- deepCopy_v1_ExportOptions,
- deepCopy_v1_FCVolumeSource,
- deepCopy_v1_FlexVolumeSource,
- deepCopy_v1_FlockerVolumeSource,
- deepCopy_v1_GCEPersistentDiskVolumeSource,
- deepCopy_v1_GitRepoVolumeSource,
- deepCopy_v1_GlusterfsVolumeSource,
- deepCopy_v1_HTTPGetAction,
- deepCopy_v1_HTTPHeader,
- deepCopy_v1_Handler,
- deepCopy_v1_HostPathVolumeSource,
- deepCopy_v1_ISCSIVolumeSource,
- deepCopy_v1_KeyToPath,
- deepCopy_v1_Lifecycle,
- deepCopy_v1_LimitRange,
- deepCopy_v1_LimitRangeItem,
- deepCopy_v1_LimitRangeList,
- deepCopy_v1_LimitRangeSpec,
- deepCopy_v1_List,
- deepCopy_v1_ListOptions,
- deepCopy_v1_LoadBalancerIngress,
- deepCopy_v1_LoadBalancerStatus,
- deepCopy_v1_LocalObjectReference,
- deepCopy_v1_NFSVolumeSource,
- deepCopy_v1_Namespace,
- deepCopy_v1_NamespaceList,
- deepCopy_v1_NamespaceSpec,
- deepCopy_v1_NamespaceStatus,
- deepCopy_v1_Node,
- deepCopy_v1_NodeAddress,
- deepCopy_v1_NodeCondition,
- deepCopy_v1_NodeDaemonEndpoints,
- deepCopy_v1_NodeList,
- deepCopy_v1_NodeProxyOptions,
- deepCopy_v1_NodeSpec,
- deepCopy_v1_NodeStatus,
- deepCopy_v1_NodeSystemInfo,
- deepCopy_v1_ObjectFieldSelector,
- deepCopy_v1_ObjectMeta,
- deepCopy_v1_ObjectReference,
- deepCopy_v1_PersistentVolume,
- deepCopy_v1_PersistentVolumeClaim,
- deepCopy_v1_PersistentVolumeClaimList,
- deepCopy_v1_PersistentVolumeClaimSpec,
- deepCopy_v1_PersistentVolumeClaimStatus,
- deepCopy_v1_PersistentVolumeClaimVolumeSource,
- deepCopy_v1_PersistentVolumeList,
- deepCopy_v1_PersistentVolumeSource,
- deepCopy_v1_PersistentVolumeSpec,
- deepCopy_v1_PersistentVolumeStatus,
- deepCopy_v1_Pod,
- deepCopy_v1_PodAttachOptions,
- deepCopy_v1_PodCondition,
- deepCopy_v1_PodExecOptions,
- deepCopy_v1_PodList,
- deepCopy_v1_PodLogOptions,
- deepCopy_v1_PodProxyOptions,
- deepCopy_v1_PodSecurityContext,
- deepCopy_v1_PodSpec,
- deepCopy_v1_PodStatus,
- deepCopy_v1_PodStatusResult,
- deepCopy_v1_PodTemplate,
- deepCopy_v1_PodTemplateList,
- deepCopy_v1_PodTemplateSpec,
- deepCopy_v1_Probe,
- deepCopy_v1_RBDVolumeSource,
- deepCopy_v1_RangeAllocation,
- deepCopy_v1_ReplicationController,
- deepCopy_v1_ReplicationControllerList,
- deepCopy_v1_ReplicationControllerSpec,
- deepCopy_v1_ReplicationControllerStatus,
- deepCopy_v1_ResourceQuota,
- deepCopy_v1_ResourceQuotaList,
- deepCopy_v1_ResourceQuotaSpec,
- deepCopy_v1_ResourceQuotaStatus,
- deepCopy_v1_ResourceRequirements,
- deepCopy_v1_SELinuxOptions,
- deepCopy_v1_Secret,
- deepCopy_v1_SecretKeySelector,
- deepCopy_v1_SecretList,
- deepCopy_v1_SecretVolumeSource,
- deepCopy_v1_SecurityContext,
- deepCopy_v1_SerializedReference,
- deepCopy_v1_Service,
- deepCopy_v1_ServiceAccount,
- deepCopy_v1_ServiceAccountList,
- deepCopy_v1_ServiceList,
- deepCopy_v1_ServicePort,
- deepCopy_v1_ServiceProxyOptions,
- deepCopy_v1_ServiceSpec,
- deepCopy_v1_ServiceStatus,
- deepCopy_v1_TCPSocketAction,
- deepCopy_v1_Volume,
- deepCopy_v1_VolumeMount,
- deepCopy_v1_VolumeSource,
- deepCopy_runtime_RawExtension,
- deepCopy_intstr_IntOrString,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/defaults.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/defaults.go
deleted file mode 100644
index 2dac9940da987469d370fde937712271796f0967..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/defaults.go
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1
-
-import (
- "k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/util"
- "k8s.io/kubernetes/pkg/util/intstr"
- "k8s.io/kubernetes/pkg/util/parsers"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) {
- scheme.AddDefaultingFuncs(
- func(obj *PodExecOptions) {
- obj.Stdout = true
- obj.Stderr = true
- },
- func(obj *PodAttachOptions) {
- obj.Stdout = true
- obj.Stderr = true
- },
- func(obj *ReplicationController) {
- var labels map[string]string
- if obj.Spec.Template != nil {
- labels = obj.Spec.Template.Labels
- }
- // TODO: support templates defined elsewhere when we support them in the API
- if labels != nil {
- if len(obj.Spec.Selector) == 0 {
- obj.Spec.Selector = labels
- }
- if len(obj.Labels) == 0 {
- obj.Labels = labels
- }
- }
- if obj.Spec.Replicas == nil {
- obj.Spec.Replicas = new(int32)
- *obj.Spec.Replicas = 1
- }
- },
- func(obj *Volume) {
- if util.AllPtrFieldsNil(&obj.VolumeSource) {
- obj.VolumeSource = VolumeSource{
- EmptyDir: &EmptyDirVolumeSource{},
- }
- }
- },
- func(obj *ContainerPort) {
- if obj.Protocol == "" {
- obj.Protocol = ProtocolTCP
- }
- },
- func(obj *Container) {
- if obj.ImagePullPolicy == "" {
- _, tag := parsers.ParseImageName(obj.Image)
- // Check image tag
-
- if tag == "latest" {
- obj.ImagePullPolicy = PullAlways
- } else {
- obj.ImagePullPolicy = PullIfNotPresent
- }
- }
- if obj.TerminationMessagePath == "" {
- obj.TerminationMessagePath = TerminationMessagePathDefault
- }
- },
- func(obj *ServiceSpec) {
- if obj.SessionAffinity == "" {
- obj.SessionAffinity = ServiceAffinityNone
- }
- if obj.Type == "" {
- obj.Type = ServiceTypeClusterIP
- }
- for i := range obj.Ports {
- sp := &obj.Ports[i]
- if sp.Protocol == "" {
- sp.Protocol = ProtocolTCP
- }
- if sp.TargetPort == intstr.FromInt(0) || sp.TargetPort == intstr.FromString("") {
- sp.TargetPort = intstr.FromInt(int(sp.Port))
- }
- }
- },
- func(obj *Pod) {
- // If limits are specified, but requests are not, default requests to limits
- // This is done here rather than a more specific defaulting pass on ResourceRequirements
- // because we only want this defaulting semantic to take place on a Pod and not a PodTemplate
- for i := range obj.Spec.Containers {
- // set requests to limits if requests are not specified, but limits are
- if obj.Spec.Containers[i].Resources.Limits != nil {
- if obj.Spec.Containers[i].Resources.Requests == nil {
- obj.Spec.Containers[i].Resources.Requests = make(ResourceList)
- }
- for key, value := range obj.Spec.Containers[i].Resources.Limits {
- if _, exists := obj.Spec.Containers[i].Resources.Requests[key]; !exists {
- obj.Spec.Containers[i].Resources.Requests[key] = *(value.Copy())
- }
- }
- }
- }
- },
- func(obj *PodSpec) {
- if obj.DNSPolicy == "" {
- obj.DNSPolicy = DNSClusterFirst
- }
- if obj.RestartPolicy == "" {
- obj.RestartPolicy = RestartPolicyAlways
- }
- if obj.HostNetwork {
- defaultHostNetworkPorts(&obj.Containers)
- }
- if obj.SecurityContext == nil {
- obj.SecurityContext = &PodSecurityContext{}
- }
- if obj.TerminationGracePeriodSeconds == nil {
- period := int64(DefaultTerminationGracePeriodSeconds)
- obj.TerminationGracePeriodSeconds = &period
- }
- },
- func(obj *Probe) {
- if obj.TimeoutSeconds == 0 {
- obj.TimeoutSeconds = 1
- }
- if obj.PeriodSeconds == 0 {
- obj.PeriodSeconds = 10
- }
- if obj.SuccessThreshold == 0 {
- obj.SuccessThreshold = 1
- }
- if obj.FailureThreshold == 0 {
- obj.FailureThreshold = 3
- }
- },
- func(obj *Secret) {
- if obj.Type == "" {
- obj.Type = SecretTypeOpaque
- }
- },
- func(obj *PersistentVolume) {
- if obj.Status.Phase == "" {
- obj.Status.Phase = VolumePending
- }
- if obj.Spec.PersistentVolumeReclaimPolicy == "" {
- obj.Spec.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimRetain
- }
- },
- func(obj *PersistentVolumeClaim) {
- if obj.Status.Phase == "" {
- obj.Status.Phase = ClaimPending
- }
- },
- func(obj *ISCSIVolumeSource) {
- if obj.ISCSIInterface == "" {
- obj.ISCSIInterface = "default"
- }
- },
- func(obj *Endpoints) {
- for i := range obj.Subsets {
- ss := &obj.Subsets[i]
- for i := range ss.Ports {
- ep := &ss.Ports[i]
- if ep.Protocol == "" {
- ep.Protocol = ProtocolTCP
- }
- }
- }
- },
- func(obj *HTTPGetAction) {
- if obj.Path == "" {
- obj.Path = "/"
- }
- if obj.Scheme == "" {
- obj.Scheme = URISchemeHTTP
- }
- },
- func(obj *NamespaceStatus) {
- if obj.Phase == "" {
- obj.Phase = NamespaceActive
- }
- },
- func(obj *Node) {
- if obj.Spec.ExternalID == "" {
- obj.Spec.ExternalID = obj.Name
- }
- },
- func(obj *NodeStatus) {
- if obj.Allocatable == nil && obj.Capacity != nil {
- obj.Allocatable = make(ResourceList, len(obj.Capacity))
- for key, value := range obj.Capacity {
- obj.Allocatable[key] = *(value.Copy())
- }
- obj.Allocatable = obj.Capacity
- }
- },
- func(obj *ObjectFieldSelector) {
- if obj.APIVersion == "" {
- obj.APIVersion = "v1"
- }
- },
- func(obj *LimitRangeItem) {
- // for container limits, we apply default values
- if obj.Type == LimitTypeContainer {
-
- if obj.Default == nil {
- obj.Default = make(ResourceList)
- }
- if obj.DefaultRequest == nil {
- obj.DefaultRequest = make(ResourceList)
- }
-
- // If a default limit is unspecified, but the max is specified, default the limit to the max
- for key, value := range obj.Max {
- if _, exists := obj.Default[key]; !exists {
- obj.Default[key] = *(value.Copy())
- }
- }
- // If a default limit is specified, but the default request is not, default request to limit
- for key, value := range obj.Default {
- if _, exists := obj.DefaultRequest[key]; !exists {
- obj.DefaultRequest[key] = *(value.Copy())
- }
- }
- // If a default request is not specified, but the min is provided, default request to the min
- for key, value := range obj.Min {
- if _, exists := obj.DefaultRequest[key]; !exists {
- obj.DefaultRequest[key] = *(value.Copy())
- }
- }
- }
- },
- func(obj *ConfigMap) {
- if obj.Data == nil {
- obj.Data = make(map[string]string)
- }
- },
- )
-}
-
-// With host networking default all container ports to host ports.
-func defaultHostNetworkPorts(containers *[]Container) {
- for i := range *containers {
- for j := range (*containers)[i].Ports {
- if (*containers)[i].Ports[j].HostPort == 0 {
- (*containers)[i].Ports[j].HostPort = (*containers)[i].Ports[j].ContainerPort
- }
- }
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/register.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/register.go
deleted file mode 100644
index 760836e37a439c687a35c67819d387bada52eaad..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/register.go
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1
-
-import (
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-// GroupName is the group name use in this package
-const GroupName = ""
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1"}
-
-func AddToScheme(scheme *runtime.Scheme) {
- // Add the API to Scheme.
- addKnownTypes(scheme)
- addConversionFuncs(scheme)
- addDefaultingFuncs(scheme)
-}
-
-// Adds the list of known types to api.Scheme.
-func addKnownTypes(scheme *runtime.Scheme) {
- scheme.AddKnownTypes(SchemeGroupVersion,
- &Pod{},
- &PodList{},
- &PodStatusResult{},
- &PodTemplate{},
- &PodTemplateList{},
- &ReplicationController{},
- &ReplicationControllerList{},
- &Service{},
- &ServiceProxyOptions{},
- &ServiceList{},
- &Endpoints{},
- &EndpointsList{},
- &Node{},
- &NodeList{},
- &NodeProxyOptions{},
- &Binding{},
- &Event{},
- &EventList{},
- &List{},
- &LimitRange{},
- &LimitRangeList{},
- &ResourceQuota{},
- &ResourceQuotaList{},
- &Namespace{},
- &NamespaceList{},
- &Secret{},
- &SecretList{},
- &ServiceAccount{},
- &ServiceAccountList{},
- &PersistentVolume{},
- &PersistentVolumeList{},
- &PersistentVolumeClaim{},
- &PersistentVolumeClaimList{},
- &DeleteOptions{},
- &ExportOptions{},
- &ListOptions{},
- &PodAttachOptions{},
- &PodLogOptions{},
- &PodExecOptions{},
- &PodProxyOptions{},
- &ComponentStatus{},
- &ComponentStatusList{},
- &SerializedReference{},
- &RangeAllocation{},
- &ConfigMap{},
- &ConfigMapList{},
- )
-
- // Add common types
- scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.Status{})
-}
-
-func (obj *Pod) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodStatusResult) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodTemplate) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodTemplateList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationController) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationControllerList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Service) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Endpoints) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *EndpointsList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Node) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NodeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NodeProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Binding) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Event) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *EventList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *List) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *LimitRange) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *LimitRangeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ResourceQuota) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ResourceQuotaList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Namespace) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *NamespaceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Secret) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SecretList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceAccount) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceAccountList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolume) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeClaim) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PersistentVolumeClaimList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeleteOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ListOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodAttachOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodLogOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodExecOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ServiceProxyOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ComponentStatus) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ComponentStatusList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SerializedReference) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *RangeAllocation) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ExportOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ConfigMap) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ConfigMapList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go
deleted file mode 100644
index 034a94d1e168db59eecd500741fb9abf4f436793..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package authorization
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go
deleted file mode 100644
index ccf024c8bffef792a65a2abca50885ef3fe2796d..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1beta1
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go
deleted file mode 100644
index 7302ebca69615b77c4f457a2364756d34fce97ce..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go
+++ /dev/null
@@ -1,794 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED BY codecgen.
-// ************************************************************
-
-package autoscaling
-
-import (
- "errors"
- "fmt"
- codec1978 "github.com/ugorji/go/codec"
- pkg2_api "k8s.io/kubernetes/pkg/api"
- pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- pkg3_types "k8s.io/kubernetes/pkg/types"
- "reflect"
- "runtime"
- time "time"
-)
-
-const (
- // ----- content types ----
- codecSelferC_UTF81234 = 1
- codecSelferC_RAW1234 = 0
- // ----- value types used ----
- codecSelferValueTypeArray1234 = 10
- codecSelferValueTypeMap1234 = 9
- // ----- containerStateValues ----
- codecSelfer_containerMapKey1234 = 2
- codecSelfer_containerMapValue1234 = 3
- codecSelfer_containerMapEnd1234 = 4
- codecSelfer_containerArrayElem1234 = 6
- codecSelfer_containerArrayEnd1234 = 7
-)
-
-var (
- codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
- codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
-)
-
-type codecSelfer1234 struct{}
-
-func init() {
- if codec1978.GenVersion != 5 {
- _, file, _, _ := runtime.Caller(0)
- err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
- 5, codec1978.GenVersion, file)
- panic(err)
- }
- if false { // reference the types, but skip this branch at build/run time
- var v0 pkg2_api.ObjectMeta
- var v1 pkg1_unversioned.TypeMeta
- var v2 pkg3_types.UID
- var v3 time.Time
- _, _, _, _ = v0, v1, v2, v3
- }
-}
-
-func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *Scale) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "spec":
- if r.TryDecodeAsNil() {
- x.Spec = ScaleSpec{}
- } else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
- }
- case "status":
- if r.TryDecodeAsNil() {
- x.Status = ScaleStatus{}
- } else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
- }
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Spec = ScaleSpec{}
- } else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Status = ScaleStatus{}
- } else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *ScaleSpec) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Replicas != 0
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- } else {
- r.EncodeInt(0)
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *ScaleSpec) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *ScaleSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "replicas":
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *ScaleSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
- } else {
- yyb5 = r.CheckBreak()
- }
- if yyb5 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
- } else {
- yyb5 = r.CheckBreak()
- }
- if yyb5 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *ScaleStatus) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[1] = x.Selector != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
- } else {
- yynn2 = 1
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Selector))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("selector"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Selector))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *ScaleStatus) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "replicas":
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "selector":
- if r.TryDecodeAsNil() {
- x.Selector = ""
- } else {
- x.Selector = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Selector = ""
- } else {
- x.Selector = string(r.DecodeString())
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.go
deleted file mode 100644
index 99080a8a6606819933f5c2ca6b75924a54212ff9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/types.go
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors All rights reserved.
-
-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 autoscaling
-
-import (
- "k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/api/unversioned"
-)
-
-// Scale represents a scaling request for a resource.
-type Scale struct {
- unversioned.TypeMeta `json:",inline"`
- // Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.
- api.ObjectMeta `json:"metadata,omitempty"`
-
- // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
- Spec ScaleSpec `json:"spec,omitempty"`
-
- // current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.
- Status ScaleStatus `json:"status,omitempty"`
-}
-
-// ScaleSpec describes the attributes of a scale subresource.
-type ScaleSpec struct {
- // desired number of instances for the scaled object.
- Replicas int `json:"replicas,omitempty"`
-}
-
-// ScaleStatus represents the current status of a scale subresource.
-type ScaleStatus struct {
- // actual number of observed instances of the scaled object.
- Replicas int `json:"replicas"`
-
- // 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: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector string `json:"selector,omitempty"`
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion.go
deleted file mode 100644
index 286ce3fe8a4d168bcb989bd6f4b0fcfbbd4bb7e7..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion.go
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1
-
-import (
- "reflect"
-
- "k8s.io/kubernetes/pkg/apis/extensions"
- "k8s.io/kubernetes/pkg/conversion"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-func addConversionFuncs(scheme *runtime.Scheme) {
- // Add non-generated conversion functions
- err := scheme.AddConversionFuncs(
- Convert_extensions_SubresourceReference_To_v1_CrossVersionObjectReference,
- Convert_v1_CrossVersionObjectReference_To_extensions_SubresourceReference,
- Convert_extensions_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec,
- Convert_v1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
-
-func Convert_extensions_SubresourceReference_To_v1_CrossVersionObjectReference(in *extensions.SubresourceReference, out *CrossVersionObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.SubresourceReference))(in)
- }
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func Convert_v1_CrossVersionObjectReference_To_extensions_SubresourceReference(in *CrossVersionObjectReference, out *extensions.SubresourceReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*CrossVersionObjectReference))(in)
- }
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- out.Subresource = "scale"
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *extensions.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerSpec))(in)
- }
- if err := Convert_extensions_SubresourceReference_To_v1_CrossVersionObjectReference(&in.ScaleRef, &out.ScaleTargetRef, s); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int32)
- *out.MinReplicas = int32(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int32(in.MaxReplicas)
- if in.CPUUtilization != nil {
- out.TargetCPUUtilizationPercentage = new(int32)
- *out.TargetCPUUtilizationPercentage = int32(in.CPUUtilization.TargetPercentage)
- }
- return nil
-}
-
-func Convert_v1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *extensions.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerSpec))(in)
- }
- if err := Convert_v1_CrossVersionObjectReference_To_extensions_SubresourceReference(&in.ScaleTargetRef, &out.ScaleRef, s); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int)
- *out.MinReplicas = int(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int(in.MaxReplicas)
- if in.TargetCPUUtilizationPercentage != nil {
- out.CPUUtilization = &extensions.CPUTargetUtilization{TargetPercentage: int(*in.TargetCPUUtilizationPercentage)}
- }
- return nil
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go
deleted file mode 100644
index f55d38fd948da9921b83b2afce190ce97f780b9a..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go
+++ /dev/null
@@ -1,455 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
-
-package v1
-
-import (
- reflect "reflect"
-
- api "k8s.io/kubernetes/pkg/api"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
- extensions "k8s.io/kubernetes/pkg/apis/extensions"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- return autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in, out, s)
-}
-
-func autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- return autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in, out, s)
-}
-
-func autoConvert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *Scale, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*autoscaling.Scale))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *Scale, s conversion.Scope) error {
- return autoConvert_autoscaling_Scale_To_v1_Scale(in, out, s)
-}
-
-func autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*autoscaling.ScaleSpec))(in)
- }
- out.Replicas = int32(in.Replicas)
- return nil
-}
-
-func Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
- return autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in, out, s)
-}
-
-func autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*autoscaling.ScaleStatus))(in)
- }
- out.Replicas = int32(in.Replicas)
- out.Selector = in.Selector
- return nil
-}
-
-func Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
- return autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in, out, s)
-}
-
-func autoConvert_v1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *extensions.HorizontalPodAutoscaler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscaler))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *extensions.HorizontalPodAutoscaler, s conversion.Scope) error {
- return autoConvert_v1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in, out, s)
-}
-
-func autoConvert_v1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *extensions.HorizontalPodAutoscalerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *extensions.HorizontalPodAutoscalerList, s conversion.Scope) error {
- return autoConvert_v1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in, out, s)
-}
-
-func autoConvert_v1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *extensions.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerSpec))(in)
- }
- // in.ScaleTargetRef has no peer in out
- if in.MinReplicas != nil {
- out.MinReplicas = new(int)
- *out.MinReplicas = int(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int(in.MaxReplicas)
- // in.TargetCPUUtilizationPercentage has no peer in out
- return nil
-}
-
-func autoConvert_v1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *extensions.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerStatus))(in)
- }
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastScaleTime, out.LastScaleTime, s); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = int(in.CurrentReplicas)
- out.DesiredReplicas = int(in.DesiredReplicas)
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int)
- *out.CurrentCPUUtilizationPercentage = int(*in.CurrentCPUUtilizationPercentage)
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func Convert_v1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *extensions.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- return autoConvert_v1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in, out, s)
-}
-
-func autoConvert_v1_Scale_To_autoscaling_Scale(in *Scale, out *autoscaling.Scale, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Scale))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Scale_To_autoscaling_Scale(in *Scale, out *autoscaling.Scale, s conversion.Scope) error {
- return autoConvert_v1_Scale_To_autoscaling_Scale(in, out, s)
-}
-
-func autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ScaleSpec))(in)
- }
- out.Replicas = int(in.Replicas)
- return nil
-}
-
-func Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
- return autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
-}
-
-func autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ScaleStatus))(in)
- }
- out.Replicas = int(in.Replicas)
- out.Selector = in.Selector
- return nil
-}
-
-func Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
- return autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *extensions.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscaler))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *extensions.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *extensions.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *extensions.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *extensions.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerSpec))(in)
- }
- // in.ScaleRef has no peer in out
- if in.MinReplicas != nil {
- out.MinReplicas = new(int32)
- *out.MinReplicas = int32(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int32(in.MaxReplicas)
- // in.CPUUtilization has no peer in out
- return nil
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *extensions.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerStatus))(in)
- }
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastScaleTime, out.LastScaleTime, s); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = int32(in.CurrentReplicas)
- out.DesiredReplicas = int32(in.DesiredReplicas)
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int32)
- *out.CurrentCPUUtilizationPercentage = int32(*in.CurrentCPUUtilizationPercentage)
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *extensions.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in, out, s)
-}
-
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_api_ObjectMeta_To_v1_ObjectMeta,
- autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec,
- autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus,
- autoConvert_autoscaling_Scale_To_v1_Scale,
- autoConvert_extensions_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList,
- autoConvert_extensions_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec,
- autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus,
- autoConvert_extensions_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler,
- autoConvert_v1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList,
- autoConvert_v1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec,
- autoConvert_v1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus,
- autoConvert_v1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler,
- autoConvert_v1_ObjectMeta_To_api_ObjectMeta,
- autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec,
- autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus,
- autoConvert_v1_Scale_To_autoscaling_Scale,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go
deleted file mode 100644
index a71749abb83a33868328438e67fedf2f6698e1d2..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1
-
-import (
- time "time"
-
- api "k8s.io/kubernetes/pkg/api"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func deepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
- out.SelfLink = in.SelfLink
- out.ResourceVersion = in.ResourceVersion
- return nil
-}
-
-func deepCopy_unversioned_Time(in unversioned.Time, out *unversioned.Time, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.Time); err != nil {
- return err
- } else {
- out.Time = newVal.(time.Time)
- }
- return nil
-}
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1_ObjectMeta(in v1.ObjectMeta, out *v1.ObjectMeta, c *conversion.Cloner) error {
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := deepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
- return err
- }
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func deepCopy_v1_CrossVersionObjectReference(in CrossVersionObjectReference, out *CrossVersionObjectReference, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_HorizontalPodAutoscalerStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_HorizontalPodAutoscaler(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
- if err := deepCopy_v1_CrossVersionObjectReference(in.ScaleTargetRef, &out.ScaleTargetRef, c); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int32)
- *out.MinReplicas = *in.MinReplicas
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = in.MaxReplicas
- if in.TargetCPUUtilizationPercentage != nil {
- out.TargetCPUUtilizationPercentage = new(int32)
- *out.TargetCPUUtilizationPercentage = *in.TargetCPUUtilizationPercentage
- } else {
- out.TargetCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func deepCopy_v1_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.LastScaleTime, out.LastScaleTime, c); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = in.CurrentReplicas
- out.DesiredReplicas = in.DesiredReplicas
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int32)
- *out.CurrentCPUUtilizationPercentage = *in.CurrentCPUUtilizationPercentage
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func deepCopy_v1_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ScaleStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- return nil
-}
-
-func deepCopy_v1_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- out.Selector = in.Selector
- return nil
-}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_unversioned_ListMeta,
- deepCopy_unversioned_Time,
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1_ObjectMeta,
- deepCopy_v1_CrossVersionObjectReference,
- deepCopy_v1_HorizontalPodAutoscaler,
- deepCopy_v1_HorizontalPodAutoscalerList,
- deepCopy_v1_HorizontalPodAutoscalerSpec,
- deepCopy_v1_HorizontalPodAutoscalerStatus,
- deepCopy_v1_Scale,
- deepCopy_v1_ScaleSpec,
- deepCopy_v1_ScaleStatus,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go
deleted file mode 100644
index 55d346a6193276de2d60c8a0b85df89a808d803d..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package batch
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go
deleted file mode 100644
index c1a77ee8e9207c218820572bfc9eca95cb704632..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1
-
-import (
- "fmt"
-
- "k8s.io/kubernetes/pkg/api"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- "k8s.io/kubernetes/pkg/conversion"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-func addConversionFuncs(scheme *runtime.Scheme) {
- // Add non-generated conversion functions
- err := scheme.AddConversionFuncs(
- Convert_api_PodSpec_To_v1_PodSpec,
- Convert_v1_PodSpec_To_api_PodSpec,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-
- err = api.Scheme.AddFieldLabelConversionFunc("batch/v1", "Job",
- func(label, value string) (string, string, error) {
- switch label {
- case "metadata.name", "metadata.namespace", "status.successful":
- return label, value, nil
- default:
- return "", "", fmt.Errorf("field label not supported: %s", label)
- }
- })
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
-
-// The following two PodSpec conversions functions where copied from pkg/api/conversion.go
-// for the generated functions to work properly.
-// This should be fixed: https://github.com/kubernetes/kubernetes/issues/12977
-func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *v1.PodSpec, s conversion.Scope) error {
- return v1.Convert_api_PodSpec_To_v1_PodSpec(in, out, s)
-}
-
-func Convert_v1_PodSpec_To_api_PodSpec(in *v1.PodSpec, out *api.PodSpec, s conversion.Scope) error {
- return v1.Convert_v1_PodSpec_To_api_PodSpec(in, out, s)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go
deleted file mode 100644
index 9a7b4876f60d6277ca34be9a2b6f06a33aff959c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go
+++ /dev/null
@@ -1,3065 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
-
-package v1
-
-import (
- reflect "reflect"
-
- api "k8s.io/kubernetes/pkg/api"
- resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- extensions "k8s.io/kubernetes/pkg/apis/extensions"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AWSElasticBlockStoreVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = int32(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- return autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in, out, s)
-}
-
-func autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AzureFileVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, s conversion.Scope) error {
- return autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in, out, s)
-}
-
-func autoConvert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *v1.Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Capabilities))(in)
- }
- if in.Add != nil {
- out.Add = make([]v1.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = v1.Capability(in.Add[i])
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]v1.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = v1.Capability(in.Drop[i])
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func Convert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *v1.Capabilities, s conversion.Scope) error {
- return autoConvert_api_Capabilities_To_v1_Capabilities(in, out, s)
-}
-
-func autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *v1.CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *v1.CephFSVolumeSource, s conversion.Scope) error {
- return autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in, out, s)
-}
-
-func autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolumeSource, out *v1.CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CinderVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolumeSource, out *v1.CinderVolumeSource, s conversion.Scope) error {
- return autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapKeySelector))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, s conversion.Scope) error {
- return autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in, out, s)
-}
-
-func autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapVolumeSource))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]v1.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_KeyToPath_To_v1_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in, out, s)
-}
-
-func autoConvert_api_Container_To_v1_Container(in *api.Container, out *v1.Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]v1.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_api_ContainerPort_To_v1_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]v1.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_api_EnvVar_To_v1_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := Convert_api_ResourceRequirements_To_v1_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]v1.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_api_VolumeMount_To_v1_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(v1.Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(v1.Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- // unable to generate simple pointer conversion for api.Lifecycle -> v1.Lifecycle
- if in.Lifecycle != nil {
- out.Lifecycle = new(v1.Lifecycle)
- if err := Convert_api_Lifecycle_To_v1_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = v1.PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for api.SecurityContext -> v1.SecurityContext
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.SecurityContext)
- if err := Convert_api_SecurityContext_To_v1_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func Convert_api_Container_To_v1_Container(in *api.Container, out *v1.Container, s conversion.Scope) error {
- return autoConvert_api_Container_To_v1_Container(in, out, s)
-}
-
-func autoConvert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *v1.ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerPort))(in)
- }
- out.Name = in.Name
- out.HostPort = int32(in.HostPort)
- out.ContainerPort = int32(in.ContainerPort)
- out.Protocol = v1.Protocol(in.Protocol)
- out.HostIP = in.HostIP
- return nil
-}
-
-func Convert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *v1.ContainerPort, s conversion.Scope) error {
- return autoConvert_api_ContainerPort_To_v1_ContainerPort(in, out, s)
-}
-
-func autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in, out, s)
-}
-
-func autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeSource))(in)
- }
- if in.Items != nil {
- out.Items = make([]v1.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in, out, s)
-}
-
-func autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EmptyDirVolumeSource))(in)
- }
- out.Medium = v1.StorageMedium(in.Medium)
- return nil
-}
-
-func Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, s conversion.Scope) error {
- return autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in, out, s)
-}
-
-func autoConvert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *v1.EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVar))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- // unable to generate simple pointer conversion for api.EnvVarSource -> v1.EnvVarSource
- if in.ValueFrom != nil {
- out.ValueFrom = new(v1.EnvVarSource)
- if err := Convert_api_EnvVarSource_To_v1_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func Convert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *v1.EnvVar, s conversion.Scope) error {
- return autoConvert_api_EnvVar_To_v1_EnvVar(in, out, s)
-}
-
-func autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *v1.EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVarSource))(in)
- }
- // unable to generate simple pointer conversion for api.ObjectFieldSelector -> v1.ObjectFieldSelector
- if in.FieldRef != nil {
- out.FieldRef = new(v1.ObjectFieldSelector)
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- // unable to generate simple pointer conversion for api.ConfigMapKeySelector -> v1.ConfigMapKeySelector
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(v1.ConfigMapKeySelector)
- if err := Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- // unable to generate simple pointer conversion for api.SecretKeySelector -> v1.SecretKeySelector
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(v1.SecretKeySelector)
- if err := Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func Convert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *v1.EnvVarSource, s conversion.Scope) error {
- return autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in, out, s)
-}
-
-func autoConvert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *v1.ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *v1.ExecAction, s conversion.Scope) error {
- return autoConvert_api_ExecAction_To_v1_ExecAction(in, out, s)
-}
-
-func autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *v1.FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = int32(*in.Lun)
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *v1.FCVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in, out, s)
-}
-
-func autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *v1.FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlexVolumeSource))(in)
- }
- out.Driver = in.Driver
- out.FSType = in.FSType
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *v1.FlexVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in, out, s)
-}
-
-func autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVolumeSource, out *v1.FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlockerVolumeSource))(in)
- }
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVolumeSource, out *v1.FlockerVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *api.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GCEPersistentDiskVolumeSource))(in)
- }
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = int32(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *api.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GitRepoVolumeSource))(in)
- }
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GlusterfsVolumeSource))(in)
- }
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in, out, s)
-}
-
-func autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *v1.HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPGetAction))(in)
- }
- out.Path = in.Path
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = v1.URIScheme(in.Scheme)
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]v1.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_api_HTTPHeader_To_v1_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *v1.HTTPGetAction, s conversion.Scope) error {
- return autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in, out, s)
-}
-
-func autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *v1.HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPHeader))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func Convert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *v1.HTTPHeader, s conversion.Scope) error {
- return autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in, out, s)
-}
-
-func autoConvert_api_Handler_To_v1_Handler(in *api.Handler, out *v1.Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Handler))(in)
- }
- // unable to generate simple pointer conversion for api.ExecAction -> v1.ExecAction
- if in.Exec != nil {
- out.Exec = new(v1.ExecAction)
- if err := Convert_api_ExecAction_To_v1_ExecAction(in.Exec, out.Exec, s); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- // unable to generate simple pointer conversion for api.HTTPGetAction -> v1.HTTPGetAction
- if in.HTTPGet != nil {
- out.HTTPGet = new(v1.HTTPGetAction)
- if err := Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- // unable to generate simple pointer conversion for api.TCPSocketAction -> v1.TCPSocketAction
- if in.TCPSocket != nil {
- out.TCPSocket = new(v1.TCPSocketAction)
- if err := Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func Convert_api_Handler_To_v1_Handler(in *api.Handler, out *v1.Handler, s conversion.Scope) error {
- return autoConvert_api_Handler_To_v1_Handler(in, out, s)
-}
-
-func autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPathVolumeSource, out *v1.HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HostPathVolumeSource))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPathVolumeSource, out *v1.HostPathVolumeSource, s conversion.Scope) error {
- return autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ISCSIVolumeSource))(in)
- }
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = int32(in.Lun)
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, s conversion.Scope) error {
- return autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in, out, s)
-}
-
-func autoConvert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *v1.KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.KeyToPath))(in)
- }
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *v1.KeyToPath, s conversion.Scope) error {
- return autoConvert_api_KeyToPath_To_v1_KeyToPath(in, out, s)
-}
-
-func autoConvert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *v1.Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Lifecycle))(in)
- }
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
- if in.PostStart != nil {
- out.PostStart = new(v1.Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PostStart, out.PostStart, s); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
- if in.PreStop != nil {
- out.PreStop = new(v1.Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PreStop, out.PreStop, s); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func Convert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *v1.Lifecycle, s conversion.Scope) error {
- return autoConvert_api_Lifecycle_To_v1_Lifecycle(in, out, s)
-}
-
-func autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalObjectReference, out *v1.LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LocalObjectReference))(in)
- }
- out.Name = in.Name
- return nil
-}
-
-func Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalObjectReference, out *v1.LocalObjectReference, s conversion.Scope) error {
- return autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in, out, s)
-}
-
-func autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource, out *v1.NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NFSVolumeSource))(in)
- }
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource, out *v1.NFSVolumeSource, s conversion.Scope) error {
- return autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFieldSelector, out *v1.ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectFieldSelector))(in)
- }
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFieldSelector, out *v1.ObjectFieldSelector, s conversion.Scope) error {
- return autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in, out, s)
-}
-
-func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- return autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in, out, s)
-}
-
-func autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *api.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimVolumeSource))(in)
- }
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *api.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- return autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in, out, s)
-}
-
-func autoConvert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *v1.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodSpec))(in)
- }
- if in.Volumes != nil {
- out.Volumes = make([]v1.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_api_Volume_To_v1_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]v1.Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_api_Container_To_v1_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = v1.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = v1.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- out.NodeName = in.NodeName
- // unable to generate simple pointer conversion for api.PodSecurityContext -> v1.PodSecurityContext
- if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]v1.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *v1.PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodTemplateSpec))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *v1.PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in, out, s)
-}
-
-func autoConvert_api_Probe_To_v1_Probe(in *api.Probe, out *v1.Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Probe))(in)
- }
- if err := Convert_api_Handler_To_v1_Handler(&in.Handler, &out.Handler, s); err != nil {
- return err
- }
- out.InitialDelaySeconds = int32(in.InitialDelaySeconds)
- out.TimeoutSeconds = int32(in.TimeoutSeconds)
- out.PeriodSeconds = int32(in.PeriodSeconds)
- out.SuccessThreshold = int32(in.SuccessThreshold)
- out.FailureThreshold = int32(in.FailureThreshold)
- return nil
-}
-
-func Convert_api_Probe_To_v1_Probe(in *api.Probe, out *v1.Probe, s conversion.Scope) error {
- return autoConvert_api_Probe_To_v1_Probe(in, out, s)
-}
-
-func autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *v1.RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.RBDVolumeSource))(in)
- }
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *v1.RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *v1.ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceRequirements))(in)
- }
- if in.Limits != nil {
- out.Limits = make(v1.ResourceList)
- for key, val := range in.Limits {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Limits[v1.ResourceName(key)] = newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(v1.ResourceList)
- for key, val := range in.Requests {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Requests[v1.ResourceName(key)] = newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func Convert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *v1.ResourceRequirements, s conversion.Scope) error {
- return autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in, out, s)
-}
-
-func autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *v1.SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SELinuxOptions))(in)
- }
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *v1.SELinuxOptions, s conversion.Scope) error {
- return autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in, out, s)
-}
-
-func autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *v1.SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretKeySelector))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *v1.SecretKeySelector, s conversion.Scope) error {
- return autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in, out, s)
-}
-
-func autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *v1.SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *v1.SecretVolumeSource, s conversion.Scope) error {
- return autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in, out, s)
-}
-
-func autoConvert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *v1.SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecurityContext))(in)
- }
- // unable to generate simple pointer conversion for api.Capabilities -> v1.Capabilities
- if in.Capabilities != nil {
- out.Capabilities = new(v1.Capabilities)
- if err := Convert_api_Capabilities_To_v1_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for api.SELinuxOptions -> v1.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func Convert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *v1.SecurityContext, s conversion.Scope) error {
- return autoConvert_api_SecurityContext_To_v1_SecurityContext(in, out, s)
-}
-
-func autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *v1.TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.TCPSocketAction))(in)
- }
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *v1.TCPSocketAction, s conversion.Scope) error {
- return autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in, out, s)
-}
-
-func autoConvert_api_Volume_To_v1_Volume(in *api.Volume, out *v1.Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Volume))(in)
- }
- out.Name = in.Name
- if err := Convert_api_VolumeSource_To_v1_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_Volume_To_v1_Volume(in *api.Volume, out *v1.Volume, s conversion.Scope) error {
- return autoConvert_api_Volume_To_v1_Volume(in, out, s)
-}
-
-func autoConvert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *v1.VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeMount))(in)
- }
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func Convert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *v1.VolumeMount, s conversion.Scope) error {
- return autoConvert_api_VolumeMount_To_v1_VolumeMount(in, out, s)
-}
-
-func autoConvert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *v1.VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for api.HostPathVolumeSource -> v1.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(v1.HostPathVolumeSource)
- if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for api.EmptyDirVolumeSource -> v1.EmptyDirVolumeSource
- if in.EmptyDir != nil {
- out.EmptyDir = new(v1.EmptyDirVolumeSource)
- if err := Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- // unable to generate simple pointer conversion for api.GCEPersistentDiskVolumeSource -> v1.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(v1.GCEPersistentDiskVolumeSource)
- if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for api.AWSElasticBlockStoreVolumeSource -> v1.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(v1.AWSElasticBlockStoreVolumeSource)
- if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for api.GitRepoVolumeSource -> v1.GitRepoVolumeSource
- if in.GitRepo != nil {
- out.GitRepo = new(v1.GitRepoVolumeSource)
- if err := Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- // unable to generate simple pointer conversion for api.SecretVolumeSource -> v1.SecretVolumeSource
- if in.Secret != nil {
- out.Secret = new(v1.SecretVolumeSource)
- if err := Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- // unable to generate simple pointer conversion for api.NFSVolumeSource -> v1.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(v1.NFSVolumeSource)
- if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for api.ISCSIVolumeSource -> v1.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(v1.ISCSIVolumeSource)
- if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for api.GlusterfsVolumeSource -> v1.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(v1.GlusterfsVolumeSource)
- if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for api.PersistentVolumeClaimVolumeSource -> v1.PersistentVolumeClaimVolumeSource
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(v1.PersistentVolumeClaimVolumeSource)
- if err := Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- // unable to generate simple pointer conversion for api.RBDVolumeSource -> v1.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(v1.RBDVolumeSource)
- if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for api.FlexVolumeSource -> v1.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(v1.FlexVolumeSource)
- if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for api.CinderVolumeSource -> v1.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(v1.CinderVolumeSource)
- if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for api.CephFSVolumeSource -> v1.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(v1.CephFSVolumeSource)
- if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for api.FlockerVolumeSource -> v1.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(v1.FlockerVolumeSource)
- if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for api.DownwardAPIVolumeSource -> v1.DownwardAPIVolumeSource
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(v1.DownwardAPIVolumeSource)
- if err := Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- // unable to generate simple pointer conversion for api.FCVolumeSource -> v1.FCVolumeSource
- if in.FC != nil {
- out.FC = new(v1.FCVolumeSource)
- if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for api.AzureFileVolumeSource -> v1.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(v1.AzureFileVolumeSource)
- if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- // unable to generate simple pointer conversion for api.ConfigMapVolumeSource -> v1.ConfigMapVolumeSource
- if in.ConfigMap != nil {
- out.ConfigMap = new(v1.ConfigMapVolumeSource)
- if err := Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func Convert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *v1.VolumeSource, s conversion.Scope) error {
- return autoConvert_api_VolumeSource_To_v1_VolumeSource(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*unversioned.LabelSelector))(in)
- }
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(&in.MatchExpressions[i], &out.MatchExpressions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func Convert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
- return autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*unversioned.LabelSelectorRequirement))(in)
- }
- out.Key = in.Key
- out.Operator = LabelSelectorOperator(in.Operator)
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
- return autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *v1.AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.AWSElasticBlockStoreVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *v1.AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *v1.AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.AzureFileVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *v1.AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Capabilities_To_api_Capabilities(in *v1.Capabilities, out *api.Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Capabilities))(in)
- }
- if in.Add != nil {
- out.Add = make([]api.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = api.Capability(in.Add[i])
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]api.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = api.Capability(in.Drop[i])
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func Convert_v1_Capabilities_To_api_Capabilities(in *v1.Capabilities, out *api.Capabilities, s conversion.Scope) error {
- return autoConvert_v1_Capabilities_To_api_Capabilities(in, out, s)
-}
-
-func autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *v1.CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *v1.CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *v1.CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.CinderVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *v1.CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *v1.ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ConfigMapKeySelector))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *v1.ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *v1.ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ConfigMapVolumeSource))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_KeyToPath_To_api_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *v1.ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Container_To_api_Container(in *v1.Container, out *api.Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]api.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_v1_ContainerPort_To_api_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]api.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_v1_EnvVar_To_api_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]api.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_v1_VolumeMount_To_api_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Lifecycle -> api.Lifecycle
- if in.Lifecycle != nil {
- out.Lifecycle = new(api.Lifecycle)
- if err := Convert_v1_Lifecycle_To_api_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = api.PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for v1.SecurityContext -> api.SecurityContext
- if in.SecurityContext != nil {
- out.SecurityContext = new(api.SecurityContext)
- if err := Convert_v1_SecurityContext_To_api_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func Convert_v1_Container_To_api_Container(in *v1.Container, out *api.Container, s conversion.Scope) error {
- return autoConvert_v1_Container_To_api_Container(in, out, s)
-}
-
-func autoConvert_v1_ContainerPort_To_api_ContainerPort(in *v1.ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ContainerPort))(in)
- }
- out.Name = in.Name
- out.HostPort = int(in.HostPort)
- out.ContainerPort = int(in.ContainerPort)
- out.Protocol = api.Protocol(in.Protocol)
- out.HostIP = in.HostIP
- return nil
-}
-
-func Convert_v1_ContainerPort_To_api_ContainerPort(in *v1.ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- return autoConvert_v1_ContainerPort_To_api_ContainerPort(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *v1.DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *v1.DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *v1.DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.DownwardAPIVolumeSource))(in)
- }
- if in.Items != nil {
- out.Items = make([]api.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *v1.DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *v1.EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EmptyDirVolumeSource))(in)
- }
- out.Medium = api.StorageMedium(in.Medium)
- return nil
-}
-
-func Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *v1.EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EnvVar_To_api_EnvVar(in *v1.EnvVar, out *api.EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EnvVar))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- // unable to generate simple pointer conversion for v1.EnvVarSource -> api.EnvVarSource
- if in.ValueFrom != nil {
- out.ValueFrom = new(api.EnvVarSource)
- if err := Convert_v1_EnvVarSource_To_api_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVar_To_api_EnvVar(in *v1.EnvVar, out *api.EnvVar, s conversion.Scope) error {
- return autoConvert_v1_EnvVar_To_api_EnvVar(in, out, s)
-}
-
-func autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in *v1.EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EnvVarSource))(in)
- }
- // unable to generate simple pointer conversion for v1.ObjectFieldSelector -> api.ObjectFieldSelector
- if in.FieldRef != nil {
- out.FieldRef = new(api.ObjectFieldSelector)
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- // unable to generate simple pointer conversion for v1.ConfigMapKeySelector -> api.ConfigMapKeySelector
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(api.ConfigMapKeySelector)
- if err := Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- // unable to generate simple pointer conversion for v1.SecretKeySelector -> api.SecretKeySelector
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(api.SecretKeySelector)
- if err := Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVarSource_To_api_EnvVarSource(in *v1.EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- return autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in, out, s)
-}
-
-func autoConvert_v1_ExecAction_To_api_ExecAction(in *v1.ExecAction, out *api.ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_v1_ExecAction_To_api_ExecAction(in *v1.ExecAction, out *api.ExecAction, s conversion.Scope) error {
- return autoConvert_v1_ExecAction_To_api_ExecAction(in, out, s)
-}
-
-func autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in *v1.FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int)
- *out.Lun = int(*in.Lun)
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in *v1.FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *v1.FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FlexVolumeSource))(in)
- }
- out.Driver = in.Driver
- out.FSType = in.FSType
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *v1.FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *v1.FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FlockerVolumeSource))(in)
- }
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *v1.FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *v1.GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GCEPersistentDiskVolumeSource))(in)
- }
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *v1.GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *v1.GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GitRepoVolumeSource))(in)
- }
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *v1.GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *v1.GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GlusterfsVolumeSource))(in)
- }
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *v1.GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in *v1.HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HTTPGetAction))(in)
- }
- out.Path = in.Path
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = api.URIScheme(in.Scheme)
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]api.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_v1_HTTPHeader_To_api_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in *v1.HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- return autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in, out, s)
-}
-
-func autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in *v1.HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HTTPHeader))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func Convert_v1_HTTPHeader_To_api_HTTPHeader(in *v1.HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- return autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in, out, s)
-}
-
-func autoConvert_v1_Handler_To_api_Handler(in *v1.Handler, out *api.Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Handler))(in)
- }
- // unable to generate simple pointer conversion for v1.ExecAction -> api.ExecAction
- if in.Exec != nil {
- out.Exec = new(api.ExecAction)
- if err := Convert_v1_ExecAction_To_api_ExecAction(in.Exec, out.Exec, s); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- // unable to generate simple pointer conversion for v1.HTTPGetAction -> api.HTTPGetAction
- if in.HTTPGet != nil {
- out.HTTPGet = new(api.HTTPGetAction)
- if err := Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- // unable to generate simple pointer conversion for v1.TCPSocketAction -> api.TCPSocketAction
- if in.TCPSocket != nil {
- out.TCPSocket = new(api.TCPSocketAction)
- if err := Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func Convert_v1_Handler_To_api_Handler(in *v1.Handler, out *api.Handler, s conversion.Scope) error {
- return autoConvert_v1_Handler_To_api_Handler(in, out, s)
-}
-
-func autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *v1.HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HostPathVolumeSource))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *v1.HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *v1.ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ISCSIVolumeSource))(in)
- }
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = int(in.Lun)
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *v1.ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_KeyToPath_To_api_KeyToPath(in *v1.KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.KeyToPath))(in)
- }
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_KeyToPath_To_api_KeyToPath(in *v1.KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- return autoConvert_v1_KeyToPath_To_api_KeyToPath(in, out, s)
-}
-
-func autoConvert_v1_Lifecycle_To_api_Lifecycle(in *v1.Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Lifecycle))(in)
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PostStart != nil {
- out.PostStart = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PostStart, out.PostStart, s); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PreStop != nil {
- out.PreStop = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PreStop, out.PreStop, s); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func Convert_v1_Lifecycle_To_api_Lifecycle(in *v1.Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- return autoConvert_v1_Lifecycle_To_api_Lifecycle(in, out, s)
-}
-
-func autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in *v1.LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.LocalObjectReference))(in)
- }
- out.Name = in.Name
- return nil
-}
-
-func Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in *v1.LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- return autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in, out, s)
-}
-
-func autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *v1.NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.NFSVolumeSource))(in)
- }
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *v1.NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *v1.ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ObjectFieldSelector))(in)
- }
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *v1.ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- return autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in, out, s)
-}
-
-func autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- return autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in, out, s)
-}
-
-func autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *v1.PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PersistentVolumeClaimVolumeSource))(in)
- }
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *v1.PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_PodSpec_To_api_PodSpec(in *v1.PodSpec, out *api.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PodSpec))(in)
- }
- if in.Volumes != nil {
- out.Volumes = make([]api.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_v1_Volume_To_api_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]api.Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_v1_Container_To_api_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = api.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = api.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- // in.DeprecatedServiceAccount has no peer in out
- out.NodeName = in.NodeName
- // in.HostNetwork has no peer in out
- // in.HostPID has no peer in out
- // in.HostIPC has no peer in out
- // unable to generate simple pointer conversion for v1.PodSecurityContext -> api.PodSecurityContext
- if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]api.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *v1.PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PodTemplateSpec))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *v1.PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in, out, s)
-}
-
-func autoConvert_v1_Probe_To_api_Probe(in *v1.Probe, out *api.Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Probe))(in)
- }
- if err := Convert_v1_Handler_To_api_Handler(&in.Handler, &out.Handler, s); err != nil {
- return err
- }
- out.InitialDelaySeconds = int(in.InitialDelaySeconds)
- out.TimeoutSeconds = int(in.TimeoutSeconds)
- out.PeriodSeconds = int(in.PeriodSeconds)
- out.SuccessThreshold = int(in.SuccessThreshold)
- out.FailureThreshold = int(in.FailureThreshold)
- return nil
-}
-
-func Convert_v1_Probe_To_api_Probe(in *v1.Probe, out *api.Probe, s conversion.Scope) error {
- return autoConvert_v1_Probe_To_api_Probe(in, out, s)
-}
-
-func autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *v1.RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.RBDVolumeSource))(in)
- }
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *v1.RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in *v1.ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ResourceRequirements))(in)
- }
- if in.Limits != nil {
- out.Limits = make(api.ResourceList)
- for key, val := range in.Limits {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Limits[api.ResourceName(key)] = newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(api.ResourceList)
- for key, val := range in.Requests {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Requests[api.ResourceName(key)] = newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func Convert_v1_ResourceRequirements_To_api_ResourceRequirements(in *v1.ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- return autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in, out, s)
-}
-
-func autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in *v1.SELinuxOptions, out *api.SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SELinuxOptions))(in)
- }
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in *v1.SELinuxOptions, out *api.SELinuxOptions, s conversion.Scope) error {
- return autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in, out, s)
-}
-
-func autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in *v1.SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecretKeySelector))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in *v1.SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
- return autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in, out, s)
-}
-
-func autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *v1.SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecretVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *v1.SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_SecurityContext_To_api_SecurityContext(in *v1.SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecurityContext))(in)
- }
- // unable to generate simple pointer conversion for v1.Capabilities -> api.Capabilities
- if in.Capabilities != nil {
- out.Capabilities = new(api.Capabilities)
- if err := Convert_v1_Capabilities_To_api_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for v1.SELinuxOptions -> api.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(api.SELinuxOptions)
- if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func Convert_v1_SecurityContext_To_api_SecurityContext(in *v1.SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- return autoConvert_v1_SecurityContext_To_api_SecurityContext(in, out, s)
-}
-
-func autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in *v1.TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.TCPSocketAction))(in)
- }
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in *v1.TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
- return autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in, out, s)
-}
-
-func autoConvert_v1_Volume_To_api_Volume(in *v1.Volume, out *api.Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Volume))(in)
- }
- out.Name = in.Name
- if err := Convert_v1_VolumeSource_To_api_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Volume_To_api_Volume(in *v1.Volume, out *api.Volume, s conversion.Scope) error {
- return autoConvert_v1_Volume_To_api_Volume(in, out, s)
-}
-
-func autoConvert_v1_VolumeMount_To_api_VolumeMount(in *v1.VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.VolumeMount))(in)
- }
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func Convert_v1_VolumeMount_To_api_VolumeMount(in *v1.VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
- return autoConvert_v1_VolumeMount_To_api_VolumeMount(in, out, s)
-}
-
-func autoConvert_v1_VolumeSource_To_api_VolumeSource(in *v1.VolumeSource, out *api.VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for v1.HostPathVolumeSource -> api.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(api.HostPathVolumeSource)
- if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for v1.EmptyDirVolumeSource -> api.EmptyDirVolumeSource
- if in.EmptyDir != nil {
- out.EmptyDir = new(api.EmptyDirVolumeSource)
- if err := Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- // unable to generate simple pointer conversion for v1.GCEPersistentDiskVolumeSource -> api.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(api.GCEPersistentDiskVolumeSource)
- if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for v1.AWSElasticBlockStoreVolumeSource -> api.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(api.AWSElasticBlockStoreVolumeSource)
- if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for v1.GitRepoVolumeSource -> api.GitRepoVolumeSource
- if in.GitRepo != nil {
- out.GitRepo = new(api.GitRepoVolumeSource)
- if err := Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- // unable to generate simple pointer conversion for v1.SecretVolumeSource -> api.SecretVolumeSource
- if in.Secret != nil {
- out.Secret = new(api.SecretVolumeSource)
- if err := Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- // unable to generate simple pointer conversion for v1.NFSVolumeSource -> api.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(api.NFSVolumeSource)
- if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for v1.ISCSIVolumeSource -> api.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(api.ISCSIVolumeSource)
- if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for v1.GlusterfsVolumeSource -> api.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(api.GlusterfsVolumeSource)
- if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for v1.PersistentVolumeClaimVolumeSource -> api.PersistentVolumeClaimVolumeSource
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(api.PersistentVolumeClaimVolumeSource)
- if err := Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- // unable to generate simple pointer conversion for v1.RBDVolumeSource -> api.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(api.RBDVolumeSource)
- if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for v1.FlexVolumeSource -> api.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(api.FlexVolumeSource)
- if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for v1.CinderVolumeSource -> api.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(api.CinderVolumeSource)
- if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for v1.CephFSVolumeSource -> api.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(api.CephFSVolumeSource)
- if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for v1.FlockerVolumeSource -> api.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(api.FlockerVolumeSource)
- if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for v1.DownwardAPIVolumeSource -> api.DownwardAPIVolumeSource
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(api.DownwardAPIVolumeSource)
- if err := Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- // unable to generate simple pointer conversion for v1.FCVolumeSource -> api.FCVolumeSource
- if in.FC != nil {
- out.FC = new(api.FCVolumeSource)
- if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for v1.AzureFileVolumeSource -> api.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(api.AzureFileVolumeSource)
- if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- // unable to generate simple pointer conversion for v1.ConfigMapVolumeSource -> api.ConfigMapVolumeSource
- if in.ConfigMap != nil {
- out.ConfigMap = new(api.ConfigMapVolumeSource)
- if err := Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func Convert_v1_VolumeSource_To_api_VolumeSource(in *v1.VolumeSource, out *api.VolumeSource, s conversion.Scope) error {
- return autoConvert_v1_VolumeSource_To_api_VolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Job_To_extensions_Job(in *Job, out *extensions.Job, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Job))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_JobSpec_To_extensions_JobSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_JobStatus_To_extensions_JobStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Job_To_extensions_Job(in *Job, out *extensions.Job, s conversion.Scope) error {
- return autoConvert_v1_Job_To_extensions_Job(in, out, s)
-}
-
-func autoConvert_v1_JobCondition_To_extensions_JobCondition(in *JobCondition, out *extensions.JobCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobCondition))(in)
- }
- out.Type = extensions.JobConditionType(in.Type)
- out.Status = api.ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_v1_JobCondition_To_extensions_JobCondition(in *JobCondition, out *extensions.JobCondition, s conversion.Scope) error {
- return autoConvert_v1_JobCondition_To_extensions_JobCondition(in, out, s)
-}
-
-func autoConvert_v1_JobList_To_extensions_JobList(in *JobList, out *extensions.JobList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.Job, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Job_To_extensions_Job(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_JobList_To_extensions_JobList(in *JobList, out *extensions.JobList, s conversion.Scope) error {
- return autoConvert_v1_JobList_To_extensions_JobList(in, out, s)
-}
-
-func autoConvert_v1_JobSpec_To_extensions_JobSpec(in *JobSpec, out *extensions.JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int)
- *out.Parallelism = int(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int)
- *out.Completions = int(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- // unable to generate simple pointer conversion for v1.LabelSelector -> unversioned.LabelSelector
- if in.Selector != nil {
- out.Selector = new(unversioned.LabelSelector)
- if err := Convert_v1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if in.ManualSelector != nil {
- out.ManualSelector = new(bool)
- *out.ManualSelector = *in.ManualSelector
- } else {
- out.ManualSelector = nil
- }
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_JobSpec_To_extensions_JobSpec(in *JobSpec, out *extensions.JobSpec, s conversion.Scope) error {
- return autoConvert_v1_JobSpec_To_extensions_JobSpec(in, out, s)
-}
-
-func autoConvert_v1_JobStatus_To_extensions_JobStatus(in *JobStatus, out *extensions.JobStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobStatus))(in)
- }
- if in.Conditions != nil {
- out.Conditions = make([]extensions.JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_v1_JobCondition_To_extensions_JobCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.CompletionTime, out.CompletionTime, s); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = int(in.Active)
- out.Succeeded = int(in.Succeeded)
- out.Failed = int(in.Failed)
- return nil
-}
-
-func Convert_v1_JobStatus_To_extensions_JobStatus(in *JobStatus, out *extensions.JobStatus, s conversion.Scope) error {
- return autoConvert_v1_JobStatus_To_extensions_JobStatus(in, out, s)
-}
-
-func autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LabelSelector))(in)
- }
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]unversioned.LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&in.MatchExpressions[i], &out.MatchExpressions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func Convert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
- return autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
-}
-
-func autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LabelSelectorRequirement))(in)
- }
- out.Key = in.Key
- out.Operator = unversioned.LabelSelectorOperator(in.Operator)
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
- return autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_extensions_Job_To_v1_Job(in *extensions.Job, out *Job, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.Job))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_JobStatus_To_v1_JobStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_Job_To_v1_Job(in *extensions.Job, out *Job, s conversion.Scope) error {
- return autoConvert_extensions_Job_To_v1_Job(in, out, s)
-}
-
-func autoConvert_extensions_JobCondition_To_v1_JobCondition(in *extensions.JobCondition, out *JobCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobCondition))(in)
- }
- out.Type = JobConditionType(in.Type)
- out.Status = v1.ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_extensions_JobCondition_To_v1_JobCondition(in *extensions.JobCondition, out *JobCondition, s conversion.Scope) error {
- return autoConvert_extensions_JobCondition_To_v1_JobCondition(in, out, s)
-}
-
-func autoConvert_extensions_JobList_To_v1_JobList(in *extensions.JobList, out *JobList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Job, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_Job_To_v1_Job(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_JobList_To_v1_JobList(in *extensions.JobList, out *JobList, s conversion.Scope) error {
- return autoConvert_extensions_JobList_To_v1_JobList(in, out, s)
-}
-
-func autoConvert_extensions_JobSpec_To_v1_JobSpec(in *extensions.JobSpec, out *JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int32)
- *out.Parallelism = int32(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int32)
- *out.Completions = int32(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1.LabelSelector
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := Convert_unversioned_LabelSelector_To_v1_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if in.ManualSelector != nil {
- out.ManualSelector = new(bool)
- *out.ManualSelector = *in.ManualSelector
- } else {
- out.ManualSelector = nil
- }
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_JobSpec_To_v1_JobSpec(in *extensions.JobSpec, out *JobSpec, s conversion.Scope) error {
- return autoConvert_extensions_JobSpec_To_v1_JobSpec(in, out, s)
-}
-
-func autoConvert_extensions_JobStatus_To_v1_JobStatus(in *extensions.JobStatus, out *JobStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobStatus))(in)
- }
- if in.Conditions != nil {
- out.Conditions = make([]JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_extensions_JobCondition_To_v1_JobCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.CompletionTime, out.CompletionTime, s); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = int32(in.Active)
- out.Succeeded = int32(in.Succeeded)
- out.Failed = int32(in.Failed)
- return nil
-}
-
-func Convert_extensions_JobStatus_To_v1_JobStatus(in *extensions.JobStatus, out *JobStatus, s conversion.Scope) error {
- return autoConvert_extensions_JobStatus_To_v1_JobStatus(in, out, s)
-}
-
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource,
- autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource,
- autoConvert_api_Capabilities_To_v1_Capabilities,
- autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource,
- autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource,
- autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector,
- autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource,
- autoConvert_api_ContainerPort_To_v1_ContainerPort,
- autoConvert_api_Container_To_v1_Container,
- autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile,
- autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource,
- autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource,
- autoConvert_api_EnvVarSource_To_v1_EnvVarSource,
- autoConvert_api_EnvVar_To_v1_EnvVar,
- autoConvert_api_ExecAction_To_v1_ExecAction,
- autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource,
- autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource,
- autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource,
- autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource,
- autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource,
- autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource,
- autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction,
- autoConvert_api_HTTPHeader_To_v1_HTTPHeader,
- autoConvert_api_Handler_To_v1_Handler,
- autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource,
- autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource,
- autoConvert_api_KeyToPath_To_v1_KeyToPath,
- autoConvert_api_Lifecycle_To_v1_Lifecycle,
- autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference,
- autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource,
- autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector,
- autoConvert_api_ObjectMeta_To_v1_ObjectMeta,
- autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource,
- autoConvert_api_PodSpec_To_v1_PodSpec,
- autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec,
- autoConvert_api_Probe_To_v1_Probe,
- autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource,
- autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements,
- autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions,
- autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector,
- autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource,
- autoConvert_api_SecurityContext_To_v1_SecurityContext,
- autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction,
- autoConvert_api_VolumeMount_To_v1_VolumeMount,
- autoConvert_api_VolumeSource_To_v1_VolumeSource,
- autoConvert_api_Volume_To_v1_Volume,
- autoConvert_extensions_JobCondition_To_v1_JobCondition,
- autoConvert_extensions_JobList_To_v1_JobList,
- autoConvert_extensions_JobSpec_To_v1_JobSpec,
- autoConvert_extensions_JobStatus_To_v1_JobStatus,
- autoConvert_extensions_Job_To_v1_Job,
- autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement,
- autoConvert_unversioned_LabelSelector_To_v1_LabelSelector,
- autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource,
- autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource,
- autoConvert_v1_Capabilities_To_api_Capabilities,
- autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource,
- autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource,
- autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector,
- autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource,
- autoConvert_v1_ContainerPort_To_api_ContainerPort,
- autoConvert_v1_Container_To_api_Container,
- autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile,
- autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource,
- autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource,
- autoConvert_v1_EnvVarSource_To_api_EnvVarSource,
- autoConvert_v1_EnvVar_To_api_EnvVar,
- autoConvert_v1_ExecAction_To_api_ExecAction,
- autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource,
- autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource,
- autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource,
- autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource,
- autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource,
- autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource,
- autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction,
- autoConvert_v1_HTTPHeader_To_api_HTTPHeader,
- autoConvert_v1_Handler_To_api_Handler,
- autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource,
- autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource,
- autoConvert_v1_JobCondition_To_extensions_JobCondition,
- autoConvert_v1_JobList_To_extensions_JobList,
- autoConvert_v1_JobSpec_To_extensions_JobSpec,
- autoConvert_v1_JobStatus_To_extensions_JobStatus,
- autoConvert_v1_Job_To_extensions_Job,
- autoConvert_v1_KeyToPath_To_api_KeyToPath,
- autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
- autoConvert_v1_LabelSelector_To_unversioned_LabelSelector,
- autoConvert_v1_Lifecycle_To_api_Lifecycle,
- autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference,
- autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource,
- autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector,
- autoConvert_v1_ObjectMeta_To_api_ObjectMeta,
- autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource,
- autoConvert_v1_PodSpec_To_api_PodSpec,
- autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec,
- autoConvert_v1_Probe_To_api_Probe,
- autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource,
- autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements,
- autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions,
- autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector,
- autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource,
- autoConvert_v1_SecurityContext_To_api_SecurityContext,
- autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction,
- autoConvert_v1_VolumeMount_To_api_VolumeMount,
- autoConvert_v1_VolumeSource_To_api_VolumeSource,
- autoConvert_v1_Volume_To_api_Volume,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go
deleted file mode 100644
index 3ddbd6d2b7a272172638bd25d4a646ce9f3c449a..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go
+++ /dev/null
@@ -1,1233 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1
-
-import (
- time "time"
-
- api "k8s.io/kubernetes/pkg/api"
- resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- conversion "k8s.io/kubernetes/pkg/conversion"
- intstr "k8s.io/kubernetes/pkg/util/intstr"
- inf "speter.net/go/exp/math/dec/inf"
-)
-
-func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error {
- if in.Amount != nil {
- if newVal, err := c.DeepCopy(in.Amount); err != nil {
- return err
- } else {
- out.Amount = newVal.(*inf.Dec)
- }
- } else {
- out.Amount = nil
- }
- out.Format = in.Format
- return nil
-}
-
-func deepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
- out.SelfLink = in.SelfLink
- out.ResourceVersion = in.ResourceVersion
- return nil
-}
-
-func deepCopy_unversioned_Time(in unversioned.Time, out *unversioned.Time, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.Time); err != nil {
- return err
- } else {
- out.Time = newVal.(time.Time)
- }
- return nil
-}
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1_AWSElasticBlockStoreVolumeSource(in v1.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_AzureFileVolumeSource(in v1.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_Capabilities(in v1.Capabilities, out *v1.Capabilities, c *conversion.Cloner) error {
- if in.Add != nil {
- out.Add = make([]v1.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = in.Add[i]
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]v1.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = in.Drop[i]
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func deepCopy_v1_CephFSVolumeSource(in v1.CephFSVolumeSource, out *v1.CephFSVolumeSource, c *conversion.Cloner) error {
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_CinderVolumeSource(in v1.CinderVolumeSource, out *v1.CinderVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ConfigMapKeySelector(in v1.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_ConfigMapVolumeSource(in v1.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]v1.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_KeyToPath(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_Container(in v1.Container, out *v1.Container, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]v1.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := deepCopy_v1_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]v1.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := deepCopy_v1_EnvVar(in.Env[i], &out.Env[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]v1.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := deepCopy_v1_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(v1.Probe)
- if err := deepCopy_v1_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(v1.Probe)
- if err := deepCopy_v1_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- if in.Lifecycle != nil {
- out.Lifecycle = new(v1.Lifecycle)
- if err := deepCopy_v1_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = in.ImagePullPolicy
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.SecurityContext)
- if err := deepCopy_v1_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func deepCopy_v1_ContainerPort(in v1.ContainerPort, out *v1.ContainerPort, c *conversion.Cloner) error {
- out.Name = in.Name
- out.HostPort = in.HostPort
- out.ContainerPort = in.ContainerPort
- out.Protocol = in.Protocol
- out.HostIP = in.HostIP
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeFile(in v1.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_v1_ObjectFieldSelector(in.FieldRef, &out.FieldRef, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeSource(in v1.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, c *conversion.Cloner) error {
- if in.Items != nil {
- out.Items = make([]v1.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_DownwardAPIVolumeFile(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_EmptyDirVolumeSource(in v1.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, c *conversion.Cloner) error {
- out.Medium = in.Medium
- return nil
-}
-
-func deepCopy_v1_EnvVar(in v1.EnvVar, out *v1.EnvVar, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- if in.ValueFrom != nil {
- out.ValueFrom = new(v1.EnvVarSource)
- if err := deepCopy_v1_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func deepCopy_v1_EnvVarSource(in v1.EnvVarSource, out *v1.EnvVarSource, c *conversion.Cloner) error {
- if in.FieldRef != nil {
- out.FieldRef = new(v1.ObjectFieldSelector)
- if err := deepCopy_v1_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(v1.ConfigMapKeySelector)
- if err := deepCopy_v1_ConfigMapKeySelector(*in.ConfigMapKeyRef, out.ConfigMapKeyRef, c); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(v1.SecretKeySelector)
- if err := deepCopy_v1_SecretKeySelector(*in.SecretKeyRef, out.SecretKeyRef, c); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func deepCopy_v1_ExecAction(in v1.ExecAction, out *v1.ExecAction, c *conversion.Cloner) error {
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func deepCopy_v1_FCVolumeSource(in v1.FCVolumeSource, out *v1.FCVolumeSource, c *conversion.Cloner) error {
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = *in.Lun
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_FlexVolumeSource(in v1.FlexVolumeSource, out *v1.FlexVolumeSource, c *conversion.Cloner) error {
- out.Driver = in.Driver
- out.FSType = in.FSType
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func deepCopy_v1_FlockerVolumeSource(in v1.FlockerVolumeSource, out *v1.FlockerVolumeSource, c *conversion.Cloner) error {
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func deepCopy_v1_GCEPersistentDiskVolumeSource(in v1.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, c *conversion.Cloner) error {
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_GitRepoVolumeSource(in v1.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, c *conversion.Cloner) error {
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func deepCopy_v1_GlusterfsVolumeSource(in v1.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, c *conversion.Cloner) error {
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_HTTPGetAction(in v1.HTTPGetAction, out *v1.HTTPGetAction, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = in.Scheme
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]v1.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := deepCopy_v1_HTTPHeader(in.HTTPHeaders[i], &out.HTTPHeaders[i], c); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func deepCopy_v1_HTTPHeader(in v1.HTTPHeader, out *v1.HTTPHeader, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func deepCopy_v1_Handler(in v1.Handler, out *v1.Handler, c *conversion.Cloner) error {
- if in.Exec != nil {
- out.Exec = new(v1.ExecAction)
- if err := deepCopy_v1_ExecAction(*in.Exec, out.Exec, c); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- if in.HTTPGet != nil {
- out.HTTPGet = new(v1.HTTPGetAction)
- if err := deepCopy_v1_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- if in.TCPSocket != nil {
- out.TCPSocket = new(v1.TCPSocketAction)
- if err := deepCopy_v1_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func deepCopy_v1_HostPathVolumeSource(in v1.HostPathVolumeSource, out *v1.HostPathVolumeSource, c *conversion.Cloner) error {
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_ISCSIVolumeSource(in v1.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, c *conversion.Cloner) error {
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = in.Lun
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_KeyToPath(in v1.KeyToPath, out *v1.KeyToPath, c *conversion.Cloner) error {
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_Lifecycle(in v1.Lifecycle, out *v1.Lifecycle, c *conversion.Cloner) error {
- if in.PostStart != nil {
- out.PostStart = new(v1.Handler)
- if err := deepCopy_v1_Handler(*in.PostStart, out.PostStart, c); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- if in.PreStop != nil {
- out.PreStop = new(v1.Handler)
- if err := deepCopy_v1_Handler(*in.PreStop, out.PreStop, c); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func deepCopy_v1_LocalObjectReference(in v1.LocalObjectReference, out *v1.LocalObjectReference, c *conversion.Cloner) error {
- out.Name = in.Name
- return nil
-}
-
-func deepCopy_v1_NFSVolumeSource(in v1.NFSVolumeSource, out *v1.NFSVolumeSource, c *conversion.Cloner) error {
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ObjectFieldSelector(in v1.ObjectFieldSelector, out *v1.ObjectFieldSelector, c *conversion.Cloner) error {
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func deepCopy_v1_ObjectMeta(in v1.ObjectMeta, out *v1.ObjectMeta, c *conversion.Cloner) error {
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := deepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
- return err
- }
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimVolumeSource(in v1.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error {
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_PodSecurityContext(in v1.PodSecurityContext, out *v1.PodSecurityContext, c *conversion.Cloner) error {
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.SupplementalGroups != nil {
- out.SupplementalGroups = make([]int64, len(in.SupplementalGroups))
- for i := range in.SupplementalGroups {
- out.SupplementalGroups[i] = in.SupplementalGroups[i]
- }
- } else {
- out.SupplementalGroups = nil
- }
- if in.FSGroup != nil {
- out.FSGroup = new(int64)
- *out.FSGroup = *in.FSGroup
- } else {
- out.FSGroup = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodSpec(in v1.PodSpec, out *v1.PodSpec, c *conversion.Cloner) error {
- if in.Volumes != nil {
- out.Volumes = make([]v1.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := deepCopy_v1_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]v1.Container, len(in.Containers))
- for i := range in.Containers {
- if err := deepCopy_v1_Container(in.Containers[i], &out.Containers[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = in.RestartPolicy
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = in.DNSPolicy
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- out.DeprecatedServiceAccount = in.DeprecatedServiceAccount
- out.NodeName = in.NodeName
- out.HostNetwork = in.HostNetwork
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.PodSecurityContext)
- if err := deepCopy_v1_PodSecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]v1.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := deepCopy_v1_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodTemplateSpec(in v1.PodTemplateSpec, out *v1.PodTemplateSpec, c *conversion.Cloner) error {
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Probe(in v1.Probe, out *v1.Probe, c *conversion.Cloner) error {
- if err := deepCopy_v1_Handler(in.Handler, &out.Handler, c); err != nil {
- return err
- }
- out.InitialDelaySeconds = in.InitialDelaySeconds
- out.TimeoutSeconds = in.TimeoutSeconds
- out.PeriodSeconds = in.PeriodSeconds
- out.SuccessThreshold = in.SuccessThreshold
- out.FailureThreshold = in.FailureThreshold
- return nil
-}
-
-func deepCopy_v1_RBDVolumeSource(in v1.RBDVolumeSource, out *v1.RBDVolumeSource, c *conversion.Cloner) error {
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ResourceRequirements(in v1.ResourceRequirements, out *v1.ResourceRequirements, c *conversion.Cloner) error {
- if in.Limits != nil {
- out.Limits = make(v1.ResourceList)
- for key, val := range in.Limits {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Limits[key] = *newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(v1.ResourceList)
- for key, val := range in.Requests {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Requests[key] = *newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func deepCopy_v1_SELinuxOptions(in v1.SELinuxOptions, out *v1.SELinuxOptions, c *conversion.Cloner) error {
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func deepCopy_v1_SecretKeySelector(in v1.SecretKeySelector, out *v1.SecretKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_SecretVolumeSource(in v1.SecretVolumeSource, out *v1.SecretVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- return nil
-}
-
-func deepCopy_v1_SecurityContext(in v1.SecurityContext, out *v1.SecurityContext, c *conversion.Cloner) error {
- if in.Capabilities != nil {
- out.Capabilities = new(v1.Capabilities)
- if err := deepCopy_v1_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func deepCopy_v1_TCPSocketAction(in v1.TCPSocketAction, out *v1.TCPSocketAction, c *conversion.Cloner) error {
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Volume(in v1.Volume, out *v1.Volume, c *conversion.Cloner) error {
- out.Name = in.Name
- if err := deepCopy_v1_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_VolumeMount(in v1.VolumeMount, out *v1.VolumeMount, c *conversion.Cloner) error {
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func deepCopy_v1_VolumeSource(in v1.VolumeSource, out *v1.VolumeSource, c *conversion.Cloner) error {
- if in.HostPath != nil {
- out.HostPath = new(v1.HostPathVolumeSource)
- if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- if in.EmptyDir != nil {
- out.EmptyDir = new(v1.EmptyDirVolumeSource)
- if err := deepCopy_v1_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(v1.GCEPersistentDiskVolumeSource)
- if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(v1.AWSElasticBlockStoreVolumeSource)
- if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- if in.GitRepo != nil {
- out.GitRepo = new(v1.GitRepoVolumeSource)
- if err := deepCopy_v1_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- if in.Secret != nil {
- out.Secret = new(v1.SecretVolumeSource)
- if err := deepCopy_v1_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- if in.NFS != nil {
- out.NFS = new(v1.NFSVolumeSource)
- if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- if in.ISCSI != nil {
- out.ISCSI = new(v1.ISCSIVolumeSource)
- if err := deepCopy_v1_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- if in.Glusterfs != nil {
- out.Glusterfs = new(v1.GlusterfsVolumeSource)
- if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(v1.PersistentVolumeClaimVolumeSource)
- if err := deepCopy_v1_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaim, out.PersistentVolumeClaim, c); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- if in.RBD != nil {
- out.RBD = new(v1.RBDVolumeSource)
- if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- if in.FlexVolume != nil {
- out.FlexVolume = new(v1.FlexVolumeSource)
- if err := deepCopy_v1_FlexVolumeSource(*in.FlexVolume, out.FlexVolume, c); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- if in.Cinder != nil {
- out.Cinder = new(v1.CinderVolumeSource)
- if err := deepCopy_v1_CinderVolumeSource(*in.Cinder, out.Cinder, c); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- if in.CephFS != nil {
- out.CephFS = new(v1.CephFSVolumeSource)
- if err := deepCopy_v1_CephFSVolumeSource(*in.CephFS, out.CephFS, c); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- if in.Flocker != nil {
- out.Flocker = new(v1.FlockerVolumeSource)
- if err := deepCopy_v1_FlockerVolumeSource(*in.Flocker, out.Flocker, c); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(v1.DownwardAPIVolumeSource)
- if err := deepCopy_v1_DownwardAPIVolumeSource(*in.DownwardAPI, out.DownwardAPI, c); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- if in.FC != nil {
- out.FC = new(v1.FCVolumeSource)
- if err := deepCopy_v1_FCVolumeSource(*in.FC, out.FC, c); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- if in.AzureFile != nil {
- out.AzureFile = new(v1.AzureFileVolumeSource)
- if err := deepCopy_v1_AzureFileVolumeSource(*in.AzureFile, out.AzureFile, c); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- if in.ConfigMap != nil {
- out.ConfigMap = new(v1.ConfigMapVolumeSource)
- if err := deepCopy_v1_ConfigMapVolumeSource(*in.ConfigMap, out.ConfigMap, c); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func deepCopy_v1_Job(in Job, out *Job, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_JobSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1_JobStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Status = in.Status
- if err := deepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func deepCopy_v1_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Job, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_Job(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
- if in.Parallelism != nil {
- out.Parallelism = new(int32)
- *out.Parallelism = *in.Parallelism
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int32)
- *out.Completions = *in.Completions
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := deepCopy_v1_LabelSelector(*in.Selector, out.Selector, c); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if in.ManualSelector != nil {
- out.ManualSelector = new(bool)
- *out.ManualSelector = *in.ManualSelector
- } else {
- out.ManualSelector = nil
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
- if in.Conditions != nil {
- out.Conditions = make([]JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := deepCopy_v1_JobCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.StartTime, out.StartTime, c); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.CompletionTime, out.CompletionTime, c); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = in.Active
- out.Succeeded = in.Succeeded
- out.Failed = in.Failed
- return nil
-}
-
-func deepCopy_v1_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := deepCopy_v1_LabelSelectorRequirement(in.MatchExpressions[i], &out.MatchExpressions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func deepCopy_v1_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
- out.Key = in.Key
- out.Operator = in.Operator
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func deepCopy_intstr_IntOrString(in intstr.IntOrString, out *intstr.IntOrString, c *conversion.Cloner) error {
- out.Type = in.Type
- out.IntVal = in.IntVal
- out.StrVal = in.StrVal
- return nil
-}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_resource_Quantity,
- deepCopy_unversioned_ListMeta,
- deepCopy_unversioned_Time,
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1_AWSElasticBlockStoreVolumeSource,
- deepCopy_v1_AzureFileVolumeSource,
- deepCopy_v1_Capabilities,
- deepCopy_v1_CephFSVolumeSource,
- deepCopy_v1_CinderVolumeSource,
- deepCopy_v1_ConfigMapKeySelector,
- deepCopy_v1_ConfigMapVolumeSource,
- deepCopy_v1_Container,
- deepCopy_v1_ContainerPort,
- deepCopy_v1_DownwardAPIVolumeFile,
- deepCopy_v1_DownwardAPIVolumeSource,
- deepCopy_v1_EmptyDirVolumeSource,
- deepCopy_v1_EnvVar,
- deepCopy_v1_EnvVarSource,
- deepCopy_v1_ExecAction,
- deepCopy_v1_FCVolumeSource,
- deepCopy_v1_FlexVolumeSource,
- deepCopy_v1_FlockerVolumeSource,
- deepCopy_v1_GCEPersistentDiskVolumeSource,
- deepCopy_v1_GitRepoVolumeSource,
- deepCopy_v1_GlusterfsVolumeSource,
- deepCopy_v1_HTTPGetAction,
- deepCopy_v1_HTTPHeader,
- deepCopy_v1_Handler,
- deepCopy_v1_HostPathVolumeSource,
- deepCopy_v1_ISCSIVolumeSource,
- deepCopy_v1_KeyToPath,
- deepCopy_v1_Lifecycle,
- deepCopy_v1_LocalObjectReference,
- deepCopy_v1_NFSVolumeSource,
- deepCopy_v1_ObjectFieldSelector,
- deepCopy_v1_ObjectMeta,
- deepCopy_v1_PersistentVolumeClaimVolumeSource,
- deepCopy_v1_PodSecurityContext,
- deepCopy_v1_PodSpec,
- deepCopy_v1_PodTemplateSpec,
- deepCopy_v1_Probe,
- deepCopy_v1_RBDVolumeSource,
- deepCopy_v1_ResourceRequirements,
- deepCopy_v1_SELinuxOptions,
- deepCopy_v1_SecretKeySelector,
- deepCopy_v1_SecretVolumeSource,
- deepCopy_v1_SecurityContext,
- deepCopy_v1_TCPSocketAction,
- deepCopy_v1_Volume,
- deepCopy_v1_VolumeMount,
- deepCopy_v1_VolumeSource,
- deepCopy_v1_Job,
- deepCopy_v1_JobCondition,
- deepCopy_v1_JobList,
- deepCopy_v1_JobSpec,
- deepCopy_v1_JobStatus,
- deepCopy_v1_LabelSelector,
- deepCopy_v1_LabelSelectorRequirement,
- deepCopy_intstr_IntOrString,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go
deleted file mode 100644
index c9a7b31e2f01a78c91911c15eaef4632e0f596b5..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package componentconfig
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go
deleted file mode 100644
index af35c7d3884d4fbc2026eb69db56a9cc72f2a51c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 v1alpha1
-
-import (
- "time"
-
- "k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/kubelet/qos"
- "k8s.io/kubernetes/pkg/master/ports"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) {
- scheme.AddDefaultingFuncs(
- func(obj *KubeProxyConfiguration) {
- if obj.BindAddress == "" {
- obj.BindAddress = "0.0.0.0"
- }
- if obj.HealthzPort == 0 {
- obj.HealthzPort = 10249
- }
- if obj.HealthzBindAddress == "" {
- obj.HealthzBindAddress = "127.0.0.1"
- }
- if obj.OOMScoreAdj == nil {
- temp := int32(qos.KubeProxyOOMScoreAdj)
- obj.OOMScoreAdj = &temp
- }
- if obj.ResourceContainer == "" {
- obj.ResourceContainer = "/kube-proxy"
- }
- if obj.IPTablesSyncPeriod.Duration == 0 {
- obj.IPTablesSyncPeriod = unversioned.Duration{30 * time.Second}
- }
- zero := unversioned.Duration{}
- if obj.UDPIdleTimeout == zero {
- obj.UDPIdleTimeout = unversioned.Duration{250 * time.Millisecond}
- }
- if obj.ConntrackMax == 0 {
- obj.ConntrackMax = 256 * 1024 // 4x default (64k)
- }
- if obj.IPTablesMasqueradeBit == nil {
- temp := int32(14)
- obj.IPTablesMasqueradeBit = &temp
- }
- if obj.ConntrackTCPEstablishedTimeout == zero {
- obj.ConntrackTCPEstablishedTimeout = unversioned.Duration{Duration: 24 * time.Hour} // 1 day (1/5 default)
- }
- },
- func(obj *KubeSchedulerConfiguration) {
- if obj.Port == 0 {
- obj.Port = ports.SchedulerPort
- }
- if obj.Address == "" {
- obj.Address = "0.0.0.0"
- }
- if obj.AlgorithmProvider == "" {
- obj.AlgorithmProvider = "DefaultProvider"
- }
- if obj.KubeAPIQPS == 0 {
- obj.KubeAPIQPS = 50.0
- }
- if obj.KubeAPIBurst == 0 {
- obj.KubeAPIBurst = 100
- }
- if obj.SchedulerName == "" {
- obj.SchedulerName = api.DefaultSchedulerName
- }
- },
- func(obj *LeaderElectionConfiguration) {
- zero := unversioned.Duration{}
- if obj.LeaseDuration == zero {
- obj.LeaseDuration = unversioned.Duration{15 * time.Second}
- }
- if obj.RenewDeadline == zero {
- obj.RenewDeadline = unversioned.Duration{10 * time.Second}
- }
- if obj.RetryPeriod == zero {
- obj.RetryPeriod = unversioned.Duration{2 * time.Second}
- }
- },
- )
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go
deleted file mode 100644
index ff5898cfe0d993740639ed78d8cf4370f13561ff..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package extensions
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/register.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/register.go
deleted file mode 100644
index 057940d1612a1c16d1148393a1f703c082510cc3..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/register.go
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 extensions
-
-import (
- "k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-// GroupName is the group name use in this package
-const GroupName = "extensions"
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-// Kind takes an unqualified kind and returns back a Group qualified GroupKind
-func Kind(kind string) unversioned.GroupKind {
- return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns back a Group qualified GroupResource
-func Resource(resource string) unversioned.GroupResource {
- return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-func AddToScheme(scheme *runtime.Scheme) {
- // Add the API to Scheme.
- addKnownTypes(scheme)
-}
-
-// Adds the list of known types to api.Scheme.
-func addKnownTypes(scheme *runtime.Scheme) {
- // TODO this gets cleaned up when the types are fixed
- scheme.AddKnownTypes(SchemeGroupVersion,
- &Deployment{},
- &DeploymentList{},
- &DeploymentRollback{},
- &HorizontalPodAutoscaler{},
- &HorizontalPodAutoscalerList{},
- &Job{},
- &JobList{},
- &ReplicationControllerDummy{},
- &Scale{},
- &ThirdPartyResource{},
- &ThirdPartyResourceList{},
- &DaemonSetList{},
- &DaemonSet{},
- &ThirdPartyResourceData{},
- &ThirdPartyResourceDataList{},
- &Ingress{},
- &IngressList{},
- &api.ListOptions{},
- &ReplicaSet{},
- &ReplicaSetList{},
- &api.ExportOptions{},
- &PodSecurityPolicy{},
- &PodSecurityPolicyList{},
- )
-}
-
-func (obj *Deployment) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeploymentList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeploymentRollback) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *HorizontalPodAutoscaler) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *HorizontalPodAutoscalerList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Job) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *JobList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationControllerDummy) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Scale) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResource) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DaemonSet) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DaemonSetList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceData) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceDataList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Ingress) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *IngressList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicaSet) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicaSetList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodSecurityPolicy) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodSecurityPolicyList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go
deleted file mode 100644
index 26ba97ece0cbcc86be1f43dd456c530553b3e9fb..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go
+++ /dev/null
@@ -1,5320 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
-
-package v1beta1
-
-import (
- reflect "reflect"
-
- api "k8s.io/kubernetes/pkg/api"
- resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- extensions "k8s.io/kubernetes/pkg/apis/extensions"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AWSElasticBlockStoreVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = int32(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- return autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in, out, s)
-}
-
-func autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AzureFileVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, s conversion.Scope) error {
- return autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in, out, s)
-}
-
-func autoConvert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *v1.Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Capabilities))(in)
- }
- if in.Add != nil {
- out.Add = make([]v1.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = v1.Capability(in.Add[i])
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]v1.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = v1.Capability(in.Drop[i])
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func Convert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *v1.Capabilities, s conversion.Scope) error {
- return autoConvert_api_Capabilities_To_v1_Capabilities(in, out, s)
-}
-
-func autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *v1.CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *v1.CephFSVolumeSource, s conversion.Scope) error {
- return autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in, out, s)
-}
-
-func autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolumeSource, out *v1.CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CinderVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolumeSource, out *v1.CinderVolumeSource, s conversion.Scope) error {
- return autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapKeySelector))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, s conversion.Scope) error {
- return autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in, out, s)
-}
-
-func autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapVolumeSource))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]v1.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_KeyToPath_To_v1_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in, out, s)
-}
-
-func autoConvert_api_Container_To_v1_Container(in *api.Container, out *v1.Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]v1.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_api_ContainerPort_To_v1_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]v1.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_api_EnvVar_To_v1_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := Convert_api_ResourceRequirements_To_v1_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]v1.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_api_VolumeMount_To_v1_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(v1.Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(v1.Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- // unable to generate simple pointer conversion for api.Lifecycle -> v1.Lifecycle
- if in.Lifecycle != nil {
- out.Lifecycle = new(v1.Lifecycle)
- if err := Convert_api_Lifecycle_To_v1_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = v1.PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for api.SecurityContext -> v1.SecurityContext
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.SecurityContext)
- if err := Convert_api_SecurityContext_To_v1_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func Convert_api_Container_To_v1_Container(in *api.Container, out *v1.Container, s conversion.Scope) error {
- return autoConvert_api_Container_To_v1_Container(in, out, s)
-}
-
-func autoConvert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *v1.ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerPort))(in)
- }
- out.Name = in.Name
- out.HostPort = int32(in.HostPort)
- out.ContainerPort = int32(in.ContainerPort)
- out.Protocol = v1.Protocol(in.Protocol)
- out.HostIP = in.HostIP
- return nil
-}
-
-func Convert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *v1.ContainerPort, s conversion.Scope) error {
- return autoConvert_api_ContainerPort_To_v1_ContainerPort(in, out, s)
-}
-
-func autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in, out, s)
-}
-
-func autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeSource))(in)
- }
- if in.Items != nil {
- out.Items = make([]v1.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in, out, s)
-}
-
-func autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EmptyDirVolumeSource))(in)
- }
- out.Medium = v1.StorageMedium(in.Medium)
- return nil
-}
-
-func Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, s conversion.Scope) error {
- return autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in, out, s)
-}
-
-func autoConvert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *v1.EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVar))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- // unable to generate simple pointer conversion for api.EnvVarSource -> v1.EnvVarSource
- if in.ValueFrom != nil {
- out.ValueFrom = new(v1.EnvVarSource)
- if err := Convert_api_EnvVarSource_To_v1_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func Convert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *v1.EnvVar, s conversion.Scope) error {
- return autoConvert_api_EnvVar_To_v1_EnvVar(in, out, s)
-}
-
-func autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *v1.EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVarSource))(in)
- }
- // unable to generate simple pointer conversion for api.ObjectFieldSelector -> v1.ObjectFieldSelector
- if in.FieldRef != nil {
- out.FieldRef = new(v1.ObjectFieldSelector)
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- // unable to generate simple pointer conversion for api.ConfigMapKeySelector -> v1.ConfigMapKeySelector
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(v1.ConfigMapKeySelector)
- if err := Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- // unable to generate simple pointer conversion for api.SecretKeySelector -> v1.SecretKeySelector
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(v1.SecretKeySelector)
- if err := Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func Convert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *v1.EnvVarSource, s conversion.Scope) error {
- return autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in, out, s)
-}
-
-func autoConvert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *v1.ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *v1.ExecAction, s conversion.Scope) error {
- return autoConvert_api_ExecAction_To_v1_ExecAction(in, out, s)
-}
-
-func autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *v1.FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = int32(*in.Lun)
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *v1.FCVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in, out, s)
-}
-
-func autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *v1.FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlexVolumeSource))(in)
- }
- out.Driver = in.Driver
- out.FSType = in.FSType
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *v1.FlexVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in, out, s)
-}
-
-func autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVolumeSource, out *v1.FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlockerVolumeSource))(in)
- }
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVolumeSource, out *v1.FlockerVolumeSource, s conversion.Scope) error {
- return autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *api.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GCEPersistentDiskVolumeSource))(in)
- }
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = int32(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *api.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GitRepoVolumeSource))(in)
- }
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in, out, s)
-}
-
-func autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GlusterfsVolumeSource))(in)
- }
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, s conversion.Scope) error {
- return autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in, out, s)
-}
-
-func autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *v1.HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPGetAction))(in)
- }
- out.Path = in.Path
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = v1.URIScheme(in.Scheme)
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]v1.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_api_HTTPHeader_To_v1_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *v1.HTTPGetAction, s conversion.Scope) error {
- return autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in, out, s)
-}
-
-func autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *v1.HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPHeader))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func Convert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *v1.HTTPHeader, s conversion.Scope) error {
- return autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in, out, s)
-}
-
-func autoConvert_api_Handler_To_v1_Handler(in *api.Handler, out *v1.Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Handler))(in)
- }
- // unable to generate simple pointer conversion for api.ExecAction -> v1.ExecAction
- if in.Exec != nil {
- out.Exec = new(v1.ExecAction)
- if err := Convert_api_ExecAction_To_v1_ExecAction(in.Exec, out.Exec, s); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- // unable to generate simple pointer conversion for api.HTTPGetAction -> v1.HTTPGetAction
- if in.HTTPGet != nil {
- out.HTTPGet = new(v1.HTTPGetAction)
- if err := Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- // unable to generate simple pointer conversion for api.TCPSocketAction -> v1.TCPSocketAction
- if in.TCPSocket != nil {
- out.TCPSocket = new(v1.TCPSocketAction)
- if err := Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func Convert_api_Handler_To_v1_Handler(in *api.Handler, out *v1.Handler, s conversion.Scope) error {
- return autoConvert_api_Handler_To_v1_Handler(in, out, s)
-}
-
-func autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPathVolumeSource, out *v1.HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HostPathVolumeSource))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPathVolumeSource, out *v1.HostPathVolumeSource, s conversion.Scope) error {
- return autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ISCSIVolumeSource))(in)
- }
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = int32(in.Lun)
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, s conversion.Scope) error {
- return autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in, out, s)
-}
-
-func autoConvert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *v1.KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.KeyToPath))(in)
- }
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *v1.KeyToPath, s conversion.Scope) error {
- return autoConvert_api_KeyToPath_To_v1_KeyToPath(in, out, s)
-}
-
-func autoConvert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *v1.Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Lifecycle))(in)
- }
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
- if in.PostStart != nil {
- out.PostStart = new(v1.Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PostStart, out.PostStart, s); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
- if in.PreStop != nil {
- out.PreStop = new(v1.Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PreStop, out.PreStop, s); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func Convert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *v1.Lifecycle, s conversion.Scope) error {
- return autoConvert_api_Lifecycle_To_v1_Lifecycle(in, out, s)
-}
-
-func autoConvert_api_ListOptions_To_v1beta1_ListOptions(in *api.ListOptions, out *ListOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ListOptions))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_labels_Selector_To_string(&in.LabelSelector, &out.LabelSelector, s); err != nil {
- return err
- }
- if err := api.Convert_fields_Selector_To_string(&in.FieldSelector, &out.FieldSelector, s); err != nil {
- return err
- }
- out.Watch = in.Watch
- out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
- return nil
-}
-
-func Convert_api_ListOptions_To_v1beta1_ListOptions(in *api.ListOptions, out *ListOptions, s conversion.Scope) error {
- return autoConvert_api_ListOptions_To_v1beta1_ListOptions(in, out, s)
-}
-
-func autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *api.LoadBalancerIngress, out *v1.LoadBalancerIngress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LoadBalancerIngress))(in)
- }
- out.IP = in.IP
- out.Hostname = in.Hostname
- return nil
-}
-
-func Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *api.LoadBalancerIngress, out *v1.LoadBalancerIngress, s conversion.Scope) error {
- return autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in, out, s)
-}
-
-func autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *api.LoadBalancerStatus, out *v1.LoadBalancerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LoadBalancerStatus))(in)
- }
- if in.Ingress != nil {
- out.Ingress = make([]v1.LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ingress = nil
- }
- return nil
-}
-
-func Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *api.LoadBalancerStatus, out *v1.LoadBalancerStatus, s conversion.Scope) error {
- return autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in, out, s)
-}
-
-func autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalObjectReference, out *v1.LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LocalObjectReference))(in)
- }
- out.Name = in.Name
- return nil
-}
-
-func Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalObjectReference, out *v1.LocalObjectReference, s conversion.Scope) error {
- return autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in, out, s)
-}
-
-func autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource, out *v1.NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NFSVolumeSource))(in)
- }
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource, out *v1.NFSVolumeSource, s conversion.Scope) error {
- return autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFieldSelector, out *v1.ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectFieldSelector))(in)
- }
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFieldSelector, out *v1.ObjectFieldSelector, s conversion.Scope) error {
- return autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in, out, s)
-}
-
-func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *v1.ObjectMeta, s conversion.Scope) error {
- return autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in, out, s)
-}
-
-func autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *api.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimVolumeSource))(in)
- }
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *api.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- return autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in, out, s)
-}
-
-func autoConvert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *v1.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodSpec))(in)
- }
- if in.Volumes != nil {
- out.Volumes = make([]v1.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_api_Volume_To_v1_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]v1.Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_api_Container_To_v1_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = v1.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = v1.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- out.NodeName = in.NodeName
- // unable to generate simple pointer conversion for api.PodSecurityContext -> v1.PodSecurityContext
- if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]v1.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *v1.PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodTemplateSpec))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *v1.PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in, out, s)
-}
-
-func autoConvert_api_Probe_To_v1_Probe(in *api.Probe, out *v1.Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Probe))(in)
- }
- if err := Convert_api_Handler_To_v1_Handler(&in.Handler, &out.Handler, s); err != nil {
- return err
- }
- out.InitialDelaySeconds = int32(in.InitialDelaySeconds)
- out.TimeoutSeconds = int32(in.TimeoutSeconds)
- out.PeriodSeconds = int32(in.PeriodSeconds)
- out.SuccessThreshold = int32(in.SuccessThreshold)
- out.FailureThreshold = int32(in.FailureThreshold)
- return nil
-}
-
-func Convert_api_Probe_To_v1_Probe(in *api.Probe, out *v1.Probe, s conversion.Scope) error {
- return autoConvert_api_Probe_To_v1_Probe(in, out, s)
-}
-
-func autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *v1.RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.RBDVolumeSource))(in)
- }
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *v1.RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in, out, s)
-}
-
-func autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *v1.ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceRequirements))(in)
- }
- if in.Limits != nil {
- out.Limits = make(v1.ResourceList)
- for key, val := range in.Limits {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Limits[v1.ResourceName(key)] = newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(v1.ResourceList)
- for key, val := range in.Requests {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Requests[v1.ResourceName(key)] = newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func Convert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *v1.ResourceRequirements, s conversion.Scope) error {
- return autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in, out, s)
-}
-
-func autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *v1.SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SELinuxOptions))(in)
- }
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *v1.SELinuxOptions, s conversion.Scope) error {
- return autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in, out, s)
-}
-
-func autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *v1.SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretKeySelector))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *v1.SecretKeySelector, s conversion.Scope) error {
- return autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in, out, s)
-}
-
-func autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *v1.SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *v1.SecretVolumeSource, s conversion.Scope) error {
- return autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in, out, s)
-}
-
-func autoConvert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *v1.SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecurityContext))(in)
- }
- // unable to generate simple pointer conversion for api.Capabilities -> v1.Capabilities
- if in.Capabilities != nil {
- out.Capabilities = new(v1.Capabilities)
- if err := Convert_api_Capabilities_To_v1_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for api.SELinuxOptions -> v1.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func Convert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *v1.SecurityContext, s conversion.Scope) error {
- return autoConvert_api_SecurityContext_To_v1_SecurityContext(in, out, s)
-}
-
-func autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *v1.TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.TCPSocketAction))(in)
- }
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *v1.TCPSocketAction, s conversion.Scope) error {
- return autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in, out, s)
-}
-
-func autoConvert_api_Volume_To_v1_Volume(in *api.Volume, out *v1.Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Volume))(in)
- }
- out.Name = in.Name
- if err := Convert_api_VolumeSource_To_v1_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_Volume_To_v1_Volume(in *api.Volume, out *v1.Volume, s conversion.Scope) error {
- return autoConvert_api_Volume_To_v1_Volume(in, out, s)
-}
-
-func autoConvert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *v1.VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeMount))(in)
- }
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func Convert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *v1.VolumeMount, s conversion.Scope) error {
- return autoConvert_api_VolumeMount_To_v1_VolumeMount(in, out, s)
-}
-
-func autoConvert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *v1.VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for api.HostPathVolumeSource -> v1.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(v1.HostPathVolumeSource)
- if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for api.EmptyDirVolumeSource -> v1.EmptyDirVolumeSource
- if in.EmptyDir != nil {
- out.EmptyDir = new(v1.EmptyDirVolumeSource)
- if err := Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- // unable to generate simple pointer conversion for api.GCEPersistentDiskVolumeSource -> v1.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(v1.GCEPersistentDiskVolumeSource)
- if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for api.AWSElasticBlockStoreVolumeSource -> v1.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(v1.AWSElasticBlockStoreVolumeSource)
- if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for api.GitRepoVolumeSource -> v1.GitRepoVolumeSource
- if in.GitRepo != nil {
- out.GitRepo = new(v1.GitRepoVolumeSource)
- if err := Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- // unable to generate simple pointer conversion for api.SecretVolumeSource -> v1.SecretVolumeSource
- if in.Secret != nil {
- out.Secret = new(v1.SecretVolumeSource)
- if err := Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- // unable to generate simple pointer conversion for api.NFSVolumeSource -> v1.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(v1.NFSVolumeSource)
- if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for api.ISCSIVolumeSource -> v1.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(v1.ISCSIVolumeSource)
- if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for api.GlusterfsVolumeSource -> v1.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(v1.GlusterfsVolumeSource)
- if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for api.PersistentVolumeClaimVolumeSource -> v1.PersistentVolumeClaimVolumeSource
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(v1.PersistentVolumeClaimVolumeSource)
- if err := Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- // unable to generate simple pointer conversion for api.RBDVolumeSource -> v1.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(v1.RBDVolumeSource)
- if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for api.FlexVolumeSource -> v1.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(v1.FlexVolumeSource)
- if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for api.CinderVolumeSource -> v1.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(v1.CinderVolumeSource)
- if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for api.CephFSVolumeSource -> v1.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(v1.CephFSVolumeSource)
- if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for api.FlockerVolumeSource -> v1.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(v1.FlockerVolumeSource)
- if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for api.DownwardAPIVolumeSource -> v1.DownwardAPIVolumeSource
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(v1.DownwardAPIVolumeSource)
- if err := Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- // unable to generate simple pointer conversion for api.FCVolumeSource -> v1.FCVolumeSource
- if in.FC != nil {
- out.FC = new(v1.FCVolumeSource)
- if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for api.AzureFileVolumeSource -> v1.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(v1.AzureFileVolumeSource)
- if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- // unable to generate simple pointer conversion for api.ConfigMapVolumeSource -> v1.ConfigMapVolumeSource
- if in.ConfigMap != nil {
- out.ConfigMap = new(v1.ConfigMapVolumeSource)
- if err := Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func Convert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *v1.VolumeSource, s conversion.Scope) error {
- return autoConvert_api_VolumeSource_To_v1_VolumeSource(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*unversioned.LabelSelector))(in)
- }
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(&in.MatchExpressions[i], &out.MatchExpressions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
- return autoConvert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in, out, s)
-}
-
-func autoConvert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*unversioned.LabelSelectorRequirement))(in)
- }
- out.Key = in.Key
- out.Operator = LabelSelectorOperator(in.Operator)
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
- return autoConvert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *v1.AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.AWSElasticBlockStoreVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *v1.AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *v1.AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.AzureFileVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *v1.AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Capabilities_To_api_Capabilities(in *v1.Capabilities, out *api.Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Capabilities))(in)
- }
- if in.Add != nil {
- out.Add = make([]api.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = api.Capability(in.Add[i])
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]api.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = api.Capability(in.Drop[i])
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func Convert_v1_Capabilities_To_api_Capabilities(in *v1.Capabilities, out *api.Capabilities, s conversion.Scope) error {
- return autoConvert_v1_Capabilities_To_api_Capabilities(in, out, s)
-}
-
-func autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *v1.CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *v1.CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *v1.CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.CinderVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *v1.CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *v1.ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ConfigMapKeySelector))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *v1.ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *v1.ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ConfigMapVolumeSource))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_KeyToPath_To_api_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *v1.ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Container_To_api_Container(in *v1.Container, out *api.Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]api.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_v1_ContainerPort_To_api_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]api.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_v1_EnvVar_To_api_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]api.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_v1_VolumeMount_To_api_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Lifecycle -> api.Lifecycle
- if in.Lifecycle != nil {
- out.Lifecycle = new(api.Lifecycle)
- if err := Convert_v1_Lifecycle_To_api_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = api.PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for v1.SecurityContext -> api.SecurityContext
- if in.SecurityContext != nil {
- out.SecurityContext = new(api.SecurityContext)
- if err := Convert_v1_SecurityContext_To_api_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func Convert_v1_Container_To_api_Container(in *v1.Container, out *api.Container, s conversion.Scope) error {
- return autoConvert_v1_Container_To_api_Container(in, out, s)
-}
-
-func autoConvert_v1_ContainerPort_To_api_ContainerPort(in *v1.ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ContainerPort))(in)
- }
- out.Name = in.Name
- out.HostPort = int(in.HostPort)
- out.ContainerPort = int(in.ContainerPort)
- out.Protocol = api.Protocol(in.Protocol)
- out.HostIP = in.HostIP
- return nil
-}
-
-func Convert_v1_ContainerPort_To_api_ContainerPort(in *v1.ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- return autoConvert_v1_ContainerPort_To_api_ContainerPort(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *v1.DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *v1.DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *v1.DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.DownwardAPIVolumeSource))(in)
- }
- if in.Items != nil {
- out.Items = make([]api.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *v1.DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *v1.EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EmptyDirVolumeSource))(in)
- }
- out.Medium = api.StorageMedium(in.Medium)
- return nil
-}
-
-func Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *v1.EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EnvVar_To_api_EnvVar(in *v1.EnvVar, out *api.EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EnvVar))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- // unable to generate simple pointer conversion for v1.EnvVarSource -> api.EnvVarSource
- if in.ValueFrom != nil {
- out.ValueFrom = new(api.EnvVarSource)
- if err := Convert_v1_EnvVarSource_To_api_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVar_To_api_EnvVar(in *v1.EnvVar, out *api.EnvVar, s conversion.Scope) error {
- return autoConvert_v1_EnvVar_To_api_EnvVar(in, out, s)
-}
-
-func autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in *v1.EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.EnvVarSource))(in)
- }
- // unable to generate simple pointer conversion for v1.ObjectFieldSelector -> api.ObjectFieldSelector
- if in.FieldRef != nil {
- out.FieldRef = new(api.ObjectFieldSelector)
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- // unable to generate simple pointer conversion for v1.ConfigMapKeySelector -> api.ConfigMapKeySelector
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(api.ConfigMapKeySelector)
- if err := Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- // unable to generate simple pointer conversion for v1.SecretKeySelector -> api.SecretKeySelector
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(api.SecretKeySelector)
- if err := Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVarSource_To_api_EnvVarSource(in *v1.EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- return autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in, out, s)
-}
-
-func autoConvert_v1_ExecAction_To_api_ExecAction(in *v1.ExecAction, out *api.ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_v1_ExecAction_To_api_ExecAction(in *v1.ExecAction, out *api.ExecAction, s conversion.Scope) error {
- return autoConvert_v1_ExecAction_To_api_ExecAction(in, out, s)
-}
-
-func autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in *v1.FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int)
- *out.Lun = int(*in.Lun)
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in *v1.FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *v1.FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FlexVolumeSource))(in)
- }
- out.Driver = in.Driver
- out.FSType = in.FSType
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *v1.FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *v1.FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.FlockerVolumeSource))(in)
- }
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *v1.FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *v1.GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GCEPersistentDiskVolumeSource))(in)
- }
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *v1.GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *v1.GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GitRepoVolumeSource))(in)
- }
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *v1.GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *v1.GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.GlusterfsVolumeSource))(in)
- }
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *v1.GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in *v1.HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HTTPGetAction))(in)
- }
- out.Path = in.Path
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = api.URIScheme(in.Scheme)
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]api.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_v1_HTTPHeader_To_api_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in *v1.HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- return autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in, out, s)
-}
-
-func autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in *v1.HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HTTPHeader))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func Convert_v1_HTTPHeader_To_api_HTTPHeader(in *v1.HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- return autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in, out, s)
-}
-
-func autoConvert_v1_Handler_To_api_Handler(in *v1.Handler, out *api.Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Handler))(in)
- }
- // unable to generate simple pointer conversion for v1.ExecAction -> api.ExecAction
- if in.Exec != nil {
- out.Exec = new(api.ExecAction)
- if err := Convert_v1_ExecAction_To_api_ExecAction(in.Exec, out.Exec, s); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- // unable to generate simple pointer conversion for v1.HTTPGetAction -> api.HTTPGetAction
- if in.HTTPGet != nil {
- out.HTTPGet = new(api.HTTPGetAction)
- if err := Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- // unable to generate simple pointer conversion for v1.TCPSocketAction -> api.TCPSocketAction
- if in.TCPSocket != nil {
- out.TCPSocket = new(api.TCPSocketAction)
- if err := Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func Convert_v1_Handler_To_api_Handler(in *v1.Handler, out *api.Handler, s conversion.Scope) error {
- return autoConvert_v1_Handler_To_api_Handler(in, out, s)
-}
-
-func autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *v1.HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.HostPathVolumeSource))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *v1.HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *v1.ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ISCSIVolumeSource))(in)
- }
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = int(in.Lun)
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *v1.ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_KeyToPath_To_api_KeyToPath(in *v1.KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.KeyToPath))(in)
- }
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_KeyToPath_To_api_KeyToPath(in *v1.KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- return autoConvert_v1_KeyToPath_To_api_KeyToPath(in, out, s)
-}
-
-func autoConvert_v1_Lifecycle_To_api_Lifecycle(in *v1.Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Lifecycle))(in)
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PostStart != nil {
- out.PostStart = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PostStart, out.PostStart, s); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PreStop != nil {
- out.PreStop = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PreStop, out.PreStop, s); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func Convert_v1_Lifecycle_To_api_Lifecycle(in *v1.Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- return autoConvert_v1_Lifecycle_To_api_Lifecycle(in, out, s)
-}
-
-func autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *v1.LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.LoadBalancerIngress))(in)
- }
- out.IP = in.IP
- out.Hostname = in.Hostname
- return nil
-}
-
-func Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *v1.LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
- return autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in, out, s)
-}
-
-func autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *v1.LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.LoadBalancerStatus))(in)
- }
- if in.Ingress != nil {
- out.Ingress = make([]api.LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ingress = nil
- }
- return nil
-}
-
-func Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *v1.LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
- return autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in, out, s)
-}
-
-func autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in *v1.LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.LocalObjectReference))(in)
- }
- out.Name = in.Name
- return nil
-}
-
-func Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in *v1.LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- return autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in, out, s)
-}
-
-func autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *v1.NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.NFSVolumeSource))(in)
- }
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *v1.NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *v1.ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ObjectFieldSelector))(in)
- }
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *v1.ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- return autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in, out, s)
-}
-
-func autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func Convert_v1_ObjectMeta_To_api_ObjectMeta(in *v1.ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- return autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in, out, s)
-}
-
-func autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *v1.PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PersistentVolumeClaimVolumeSource))(in)
- }
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *v1.PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_PodSpec_To_api_PodSpec(in *v1.PodSpec, out *api.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PodSpec))(in)
- }
- if in.Volumes != nil {
- out.Volumes = make([]api.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_v1_Volume_To_api_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]api.Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_v1_Container_To_api_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = api.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = api.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- // in.DeprecatedServiceAccount has no peer in out
- out.NodeName = in.NodeName
- // in.HostNetwork has no peer in out
- // in.HostPID has no peer in out
- // in.HostIPC has no peer in out
- // unable to generate simple pointer conversion for v1.PodSecurityContext -> api.PodSecurityContext
- if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]api.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *v1.PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.PodTemplateSpec))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *v1.PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in, out, s)
-}
-
-func autoConvert_v1_Probe_To_api_Probe(in *v1.Probe, out *api.Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Probe))(in)
- }
- if err := Convert_v1_Handler_To_api_Handler(&in.Handler, &out.Handler, s); err != nil {
- return err
- }
- out.InitialDelaySeconds = int(in.InitialDelaySeconds)
- out.TimeoutSeconds = int(in.TimeoutSeconds)
- out.PeriodSeconds = int(in.PeriodSeconds)
- out.SuccessThreshold = int(in.SuccessThreshold)
- out.FailureThreshold = int(in.FailureThreshold)
- return nil
-}
-
-func Convert_v1_Probe_To_api_Probe(in *v1.Probe, out *api.Probe, s conversion.Scope) error {
- return autoConvert_v1_Probe_To_api_Probe(in, out, s)
-}
-
-func autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *v1.RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.RBDVolumeSource))(in)
- }
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *v1.RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in *v1.ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.ResourceRequirements))(in)
- }
- if in.Limits != nil {
- out.Limits = make(api.ResourceList)
- for key, val := range in.Limits {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Limits[api.ResourceName(key)] = newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(api.ResourceList)
- for key, val := range in.Requests {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Requests[api.ResourceName(key)] = newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func Convert_v1_ResourceRequirements_To_api_ResourceRequirements(in *v1.ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- return autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in, out, s)
-}
-
-func autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in *v1.SELinuxOptions, out *api.SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SELinuxOptions))(in)
- }
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in *v1.SELinuxOptions, out *api.SELinuxOptions, s conversion.Scope) error {
- return autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in, out, s)
-}
-
-func autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in *v1.SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecretKeySelector))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in *v1.SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
- return autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in, out, s)
-}
-
-func autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *v1.SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecretVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *v1.SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_SecurityContext_To_api_SecurityContext(in *v1.SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.SecurityContext))(in)
- }
- // unable to generate simple pointer conversion for v1.Capabilities -> api.Capabilities
- if in.Capabilities != nil {
- out.Capabilities = new(api.Capabilities)
- if err := Convert_v1_Capabilities_To_api_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for v1.SELinuxOptions -> api.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(api.SELinuxOptions)
- if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func Convert_v1_SecurityContext_To_api_SecurityContext(in *v1.SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- return autoConvert_v1_SecurityContext_To_api_SecurityContext(in, out, s)
-}
-
-func autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in *v1.TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.TCPSocketAction))(in)
- }
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in *v1.TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
- return autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in, out, s)
-}
-
-func autoConvert_v1_Volume_To_api_Volume(in *v1.Volume, out *api.Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.Volume))(in)
- }
- out.Name = in.Name
- if err := Convert_v1_VolumeSource_To_api_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Volume_To_api_Volume(in *v1.Volume, out *api.Volume, s conversion.Scope) error {
- return autoConvert_v1_Volume_To_api_Volume(in, out, s)
-}
-
-func autoConvert_v1_VolumeMount_To_api_VolumeMount(in *v1.VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.VolumeMount))(in)
- }
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func Convert_v1_VolumeMount_To_api_VolumeMount(in *v1.VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
- return autoConvert_v1_VolumeMount_To_api_VolumeMount(in, out, s)
-}
-
-func autoConvert_v1_VolumeSource_To_api_VolumeSource(in *v1.VolumeSource, out *api.VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*v1.VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for v1.HostPathVolumeSource -> api.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(api.HostPathVolumeSource)
- if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for v1.EmptyDirVolumeSource -> api.EmptyDirVolumeSource
- if in.EmptyDir != nil {
- out.EmptyDir = new(api.EmptyDirVolumeSource)
- if err := Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- // unable to generate simple pointer conversion for v1.GCEPersistentDiskVolumeSource -> api.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(api.GCEPersistentDiskVolumeSource)
- if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for v1.AWSElasticBlockStoreVolumeSource -> api.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(api.AWSElasticBlockStoreVolumeSource)
- if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for v1.GitRepoVolumeSource -> api.GitRepoVolumeSource
- if in.GitRepo != nil {
- out.GitRepo = new(api.GitRepoVolumeSource)
- if err := Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- // unable to generate simple pointer conversion for v1.SecretVolumeSource -> api.SecretVolumeSource
- if in.Secret != nil {
- out.Secret = new(api.SecretVolumeSource)
- if err := Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- // unable to generate simple pointer conversion for v1.NFSVolumeSource -> api.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(api.NFSVolumeSource)
- if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for v1.ISCSIVolumeSource -> api.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(api.ISCSIVolumeSource)
- if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for v1.GlusterfsVolumeSource -> api.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(api.GlusterfsVolumeSource)
- if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for v1.PersistentVolumeClaimVolumeSource -> api.PersistentVolumeClaimVolumeSource
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(api.PersistentVolumeClaimVolumeSource)
- if err := Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- // unable to generate simple pointer conversion for v1.RBDVolumeSource -> api.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(api.RBDVolumeSource)
- if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for v1.FlexVolumeSource -> api.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(api.FlexVolumeSource)
- if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for v1.CinderVolumeSource -> api.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(api.CinderVolumeSource)
- if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for v1.CephFSVolumeSource -> api.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(api.CephFSVolumeSource)
- if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for v1.FlockerVolumeSource -> api.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(api.FlockerVolumeSource)
- if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for v1.DownwardAPIVolumeSource -> api.DownwardAPIVolumeSource
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(api.DownwardAPIVolumeSource)
- if err := Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- // unable to generate simple pointer conversion for v1.FCVolumeSource -> api.FCVolumeSource
- if in.FC != nil {
- out.FC = new(api.FCVolumeSource)
- if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for v1.AzureFileVolumeSource -> api.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(api.AzureFileVolumeSource)
- if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- // unable to generate simple pointer conversion for v1.ConfigMapVolumeSource -> api.ConfigMapVolumeSource
- if in.ConfigMap != nil {
- out.ConfigMap = new(api.ConfigMapVolumeSource)
- if err := Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func Convert_v1_VolumeSource_To_api_VolumeSource(in *v1.VolumeSource, out *api.VolumeSource, s conversion.Scope) error {
- return autoConvert_v1_VolumeSource_To_api_VolumeSource(in, out, s)
-}
-
-func autoConvert_extensions_APIVersion_To_v1beta1_APIVersion(in *extensions.APIVersion, out *APIVersion, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.APIVersion))(in)
- }
- out.Name = in.Name
- out.APIGroup = in.APIGroup
- return nil
-}
-
-func Convert_extensions_APIVersion_To_v1beta1_APIVersion(in *extensions.APIVersion, out *APIVersion, s conversion.Scope) error {
- return autoConvert_extensions_APIVersion_To_v1beta1_APIVersion(in, out, s)
-}
-
-func autoConvert_extensions_CPUTargetUtilization_To_v1beta1_CPUTargetUtilization(in *extensions.CPUTargetUtilization, out *CPUTargetUtilization, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.CPUTargetUtilization))(in)
- }
- out.TargetPercentage = int32(in.TargetPercentage)
- return nil
-}
-
-func Convert_extensions_CPUTargetUtilization_To_v1beta1_CPUTargetUtilization(in *extensions.CPUTargetUtilization, out *CPUTargetUtilization, s conversion.Scope) error {
- return autoConvert_extensions_CPUTargetUtilization_To_v1beta1_CPUTargetUtilization(in, out, s)
-}
-
-func autoConvert_extensions_DaemonSet_To_v1beta1_DaemonSet(in *extensions.DaemonSet, out *DaemonSet, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DaemonSet))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_DaemonSet_To_v1beta1_DaemonSet(in *extensions.DaemonSet, out *DaemonSet, s conversion.Scope) error {
- return autoConvert_extensions_DaemonSet_To_v1beta1_DaemonSet(in, out, s)
-}
-
-func autoConvert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in *extensions.DaemonSetList, out *DaemonSetList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DaemonSetList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]DaemonSet, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_DaemonSet_To_v1beta1_DaemonSet(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in *extensions.DaemonSetList, out *DaemonSetList, s conversion.Scope) error {
- return autoConvert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in, out, s)
-}
-
-func autoConvert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *extensions.DaemonSetSpec, out *DaemonSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DaemonSetSpec))(in)
- }
- // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1beta1.LabelSelector
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *extensions.DaemonSetSpec, out *DaemonSetSpec, s conversion.Scope) error {
- return autoConvert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in, out, s)
-}
-
-func autoConvert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *extensions.DaemonSetStatus, out *DaemonSetStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DaemonSetStatus))(in)
- }
- out.CurrentNumberScheduled = int32(in.CurrentNumberScheduled)
- out.NumberMisscheduled = int32(in.NumberMisscheduled)
- out.DesiredNumberScheduled = int32(in.DesiredNumberScheduled)
- return nil
-}
-
-func Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *extensions.DaemonSetStatus, out *DaemonSetStatus, s conversion.Scope) error {
- return autoConvert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in, out, s)
-}
-
-func autoConvert_extensions_Deployment_To_v1beta1_Deployment(in *extensions.Deployment, out *Deployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.Deployment))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_Deployment_To_v1beta1_Deployment(in *extensions.Deployment, out *Deployment, s conversion.Scope) error {
- return autoConvert_extensions_Deployment_To_v1beta1_Deployment(in, out, s)
-}
-
-func autoConvert_extensions_DeploymentList_To_v1beta1_DeploymentList(in *extensions.DeploymentList, out *DeploymentList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Deployment, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_Deployment_To_v1beta1_Deployment(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_DeploymentList_To_v1beta1_DeploymentList(in *extensions.DeploymentList, out *DeploymentList, s conversion.Scope) error {
- return autoConvert_extensions_DeploymentList_To_v1beta1_DeploymentList(in, out, s)
-}
-
-func autoConvert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in *extensions.DeploymentRollback, out *DeploymentRollback, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentRollback))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- out.Name = in.Name
- if in.UpdatedAnnotations != nil {
- out.UpdatedAnnotations = make(map[string]string)
- for key, val := range in.UpdatedAnnotations {
- out.UpdatedAnnotations[key] = val
- }
- } else {
- out.UpdatedAnnotations = nil
- }
- if err := Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in *extensions.DeploymentRollback, out *DeploymentRollback, s conversion.Scope) error {
- return autoConvert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in, out, s)
-}
-
-func autoConvert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec(in *extensions.DeploymentSpec, out *DeploymentSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentSpec))(in)
- }
- if err := s.Convert(&in.Replicas, &out.Replicas, 0); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1beta1.LabelSelector
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- if err := Convert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
- return err
- }
- out.MinReadySeconds = int32(in.MinReadySeconds)
- if in.RevisionHistoryLimit != nil {
- out.RevisionHistoryLimit = new(int32)
- *out.RevisionHistoryLimit = int32(*in.RevisionHistoryLimit)
- } else {
- out.RevisionHistoryLimit = nil
- }
- out.Paused = in.Paused
- // unable to generate simple pointer conversion for extensions.RollbackConfig -> v1beta1.RollbackConfig
- if in.RollbackTo != nil {
- out.RollbackTo = new(RollbackConfig)
- if err := Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in.RollbackTo, out.RollbackTo, s); err != nil {
- return err
- }
- } else {
- out.RollbackTo = nil
- }
- return nil
-}
-
-func autoConvert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in *extensions.DeploymentStatus, out *DeploymentStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentStatus))(in)
- }
- out.ObservedGeneration = in.ObservedGeneration
- out.Replicas = int32(in.Replicas)
- out.UpdatedReplicas = int32(in.UpdatedReplicas)
- out.AvailableReplicas = int32(in.AvailableReplicas)
- out.UnavailableReplicas = int32(in.UnavailableReplicas)
- return nil
-}
-
-func Convert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in *extensions.DeploymentStatus, out *DeploymentStatus, s conversion.Scope) error {
- return autoConvert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in, out, s)
-}
-
-func autoConvert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *extensions.DeploymentStrategy, out *DeploymentStrategy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentStrategy))(in)
- }
- out.Type = DeploymentStrategyType(in.Type)
- // unable to generate simple pointer conversion for extensions.RollingUpdateDeployment -> v1beta1.RollingUpdateDeployment
- if in.RollingUpdate != nil {
- out.RollingUpdate = new(RollingUpdateDeployment)
- if err := Convert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in.RollingUpdate, out.RollingUpdate, s); err != nil {
- return err
- }
- } else {
- out.RollingUpdate = nil
- }
- return nil
-}
-
-func autoConvert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *extensions.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HTTPIngressPath))(in)
- }
- out.Path = in.Path
- if err := Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *extensions.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error {
- return autoConvert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in, out, s)
-}
-
-func autoConvert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *extensions.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HTTPIngressRuleValue))(in)
- }
- if in.Paths != nil {
- out.Paths = make([]HTTPIngressPath, len(in.Paths))
- for i := range in.Paths {
- if err := Convert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(&in.Paths[i], &out.Paths[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Paths = nil
- }
- return nil
-}
-
-func Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *extensions.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error {
- return autoConvert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in *extensions.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscaler))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in *extensions.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in *extensions.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in *extensions.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(in *extensions.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerSpec))(in)
- }
- if err := Convert_extensions_SubresourceReference_To_v1beta1_SubresourceReference(&in.ScaleRef, &out.ScaleRef, s); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int32)
- *out.MinReplicas = int32(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int32(in.MaxReplicas)
- // unable to generate simple pointer conversion for extensions.CPUTargetUtilization -> v1beta1.CPUTargetUtilization
- if in.CPUUtilization != nil {
- out.CPUUtilization = new(CPUTargetUtilization)
- if err := Convert_extensions_CPUTargetUtilization_To_v1beta1_CPUTargetUtilization(in.CPUUtilization, out.CPUUtilization, s); err != nil {
- return err
- }
- } else {
- out.CPUUtilization = nil
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(in *extensions.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(in, out, s)
-}
-
-func autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in *extensions.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HorizontalPodAutoscalerStatus))(in)
- }
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastScaleTime, out.LastScaleTime, s); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = int32(in.CurrentReplicas)
- out.DesiredReplicas = int32(in.DesiredReplicas)
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int32)
- *out.CurrentCPUUtilizationPercentage = int32(*in.CurrentCPUUtilizationPercentage)
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func Convert_extensions_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in *extensions.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- return autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in, out, s)
-}
-
-func autoConvert_extensions_HostPortRange_To_v1beta1_HostPortRange(in *extensions.HostPortRange, out *HostPortRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.HostPortRange))(in)
- }
- out.Min = int32(in.Min)
- out.Max = int32(in.Max)
- return nil
-}
-
-func Convert_extensions_HostPortRange_To_v1beta1_HostPortRange(in *extensions.HostPortRange, out *HostPortRange, s conversion.Scope) error {
- return autoConvert_extensions_HostPortRange_To_v1beta1_HostPortRange(in, out, s)
-}
-
-func autoConvert_extensions_IDRange_To_v1beta1_IDRange(in *extensions.IDRange, out *IDRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IDRange))(in)
- }
- out.Min = in.Min
- out.Max = in.Max
- return nil
-}
-
-func Convert_extensions_IDRange_To_v1beta1_IDRange(in *extensions.IDRange, out *IDRange, s conversion.Scope) error {
- return autoConvert_extensions_IDRange_To_v1beta1_IDRange(in, out, s)
-}
-
-func autoConvert_extensions_Ingress_To_v1beta1_Ingress(in *extensions.Ingress, out *Ingress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.Ingress))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_IngressSpec_To_v1beta1_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_IngressStatus_To_v1beta1_IngressStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_Ingress_To_v1beta1_Ingress(in *extensions.Ingress, out *Ingress, s conversion.Scope) error {
- return autoConvert_extensions_Ingress_To_v1beta1_Ingress(in, out, s)
-}
-
-func autoConvert_extensions_IngressBackend_To_v1beta1_IngressBackend(in *extensions.IngressBackend, out *IngressBackend, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressBackend))(in)
- }
- out.ServiceName = in.ServiceName
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.ServicePort, &out.ServicePort, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(in *extensions.IngressBackend, out *IngressBackend, s conversion.Scope) error {
- return autoConvert_extensions_IngressBackend_To_v1beta1_IngressBackend(in, out, s)
-}
-
-func autoConvert_extensions_IngressList_To_v1beta1_IngressList(in *extensions.IngressList, out *IngressList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Ingress, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_Ingress_To_v1beta1_Ingress(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_IngressList_To_v1beta1_IngressList(in *extensions.IngressList, out *IngressList, s conversion.Scope) error {
- return autoConvert_extensions_IngressList_To_v1beta1_IngressList(in, out, s)
-}
-
-func autoConvert_extensions_IngressRule_To_v1beta1_IngressRule(in *extensions.IngressRule, out *IngressRule, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressRule))(in)
- }
- out.Host = in.Host
- if err := Convert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_IngressRule_To_v1beta1_IngressRule(in *extensions.IngressRule, out *IngressRule, s conversion.Scope) error {
- return autoConvert_extensions_IngressRule_To_v1beta1_IngressRule(in, out, s)
-}
-
-func autoConvert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in *extensions.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressRuleValue))(in)
- }
- // unable to generate simple pointer conversion for extensions.HTTPIngressRuleValue -> v1beta1.HTTPIngressRuleValue
- if in.HTTP != nil {
- out.HTTP = new(HTTPIngressRuleValue)
- if err := Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in.HTTP, out.HTTP, s); err != nil {
- return err
- }
- } else {
- out.HTTP = nil
- }
- return nil
-}
-
-func Convert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in *extensions.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error {
- return autoConvert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in, out, s)
-}
-
-func autoConvert_extensions_IngressSpec_To_v1beta1_IngressSpec(in *extensions.IngressSpec, out *IngressSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressSpec))(in)
- }
- // unable to generate simple pointer conversion for extensions.IngressBackend -> v1beta1.IngressBackend
- if in.Backend != nil {
- out.Backend = new(IngressBackend)
- if err := Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(in.Backend, out.Backend, s); err != nil {
- return err
- }
- } else {
- out.Backend = nil
- }
- if in.TLS != nil {
- out.TLS = make([]IngressTLS, len(in.TLS))
- for i := range in.TLS {
- if err := Convert_extensions_IngressTLS_To_v1beta1_IngressTLS(&in.TLS[i], &out.TLS[i], s); err != nil {
- return err
- }
- }
- } else {
- out.TLS = nil
- }
- if in.Rules != nil {
- out.Rules = make([]IngressRule, len(in.Rules))
- for i := range in.Rules {
- if err := Convert_extensions_IngressRule_To_v1beta1_IngressRule(&in.Rules[i], &out.Rules[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Rules = nil
- }
- return nil
-}
-
-func Convert_extensions_IngressSpec_To_v1beta1_IngressSpec(in *extensions.IngressSpec, out *IngressSpec, s conversion.Scope) error {
- return autoConvert_extensions_IngressSpec_To_v1beta1_IngressSpec(in, out, s)
-}
-
-func autoConvert_extensions_IngressStatus_To_v1beta1_IngressStatus(in *extensions.IngressStatus, out *IngressStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressStatus))(in)
- }
- if err := Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_IngressStatus_To_v1beta1_IngressStatus(in *extensions.IngressStatus, out *IngressStatus, s conversion.Scope) error {
- return autoConvert_extensions_IngressStatus_To_v1beta1_IngressStatus(in, out, s)
-}
-
-func autoConvert_extensions_IngressTLS_To_v1beta1_IngressTLS(in *extensions.IngressTLS, out *IngressTLS, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.IngressTLS))(in)
- }
- if in.Hosts != nil {
- out.Hosts = make([]string, len(in.Hosts))
- for i := range in.Hosts {
- out.Hosts[i] = in.Hosts[i]
- }
- } else {
- out.Hosts = nil
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_extensions_IngressTLS_To_v1beta1_IngressTLS(in *extensions.IngressTLS, out *IngressTLS, s conversion.Scope) error {
- return autoConvert_extensions_IngressTLS_To_v1beta1_IngressTLS(in, out, s)
-}
-
-func autoConvert_extensions_Job_To_v1beta1_Job(in *extensions.Job, out *Job, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.Job))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_JobSpec_To_v1beta1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_JobStatus_To_v1beta1_JobStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_Job_To_v1beta1_Job(in *extensions.Job, out *Job, s conversion.Scope) error {
- return autoConvert_extensions_Job_To_v1beta1_Job(in, out, s)
-}
-
-func autoConvert_extensions_JobCondition_To_v1beta1_JobCondition(in *extensions.JobCondition, out *JobCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobCondition))(in)
- }
- out.Type = JobConditionType(in.Type)
- out.Status = v1.ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_extensions_JobCondition_To_v1beta1_JobCondition(in *extensions.JobCondition, out *JobCondition, s conversion.Scope) error {
- return autoConvert_extensions_JobCondition_To_v1beta1_JobCondition(in, out, s)
-}
-
-func autoConvert_extensions_JobList_To_v1beta1_JobList(in *extensions.JobList, out *JobList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Job, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_Job_To_v1beta1_Job(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_JobList_To_v1beta1_JobList(in *extensions.JobList, out *JobList, s conversion.Scope) error {
- return autoConvert_extensions_JobList_To_v1beta1_JobList(in, out, s)
-}
-
-func autoConvert_extensions_JobSpec_To_v1beta1_JobSpec(in *extensions.JobSpec, out *JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int32)
- *out.Parallelism = int32(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int32)
- *out.Completions = int32(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1beta1.LabelSelector
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- // in.ManualSelector has no peer in out
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_extensions_JobStatus_To_v1beta1_JobStatus(in *extensions.JobStatus, out *JobStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobStatus))(in)
- }
- if in.Conditions != nil {
- out.Conditions = make([]JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_extensions_JobCondition_To_v1beta1_JobCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.CompletionTime, out.CompletionTime, s); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = int32(in.Active)
- out.Succeeded = int32(in.Succeeded)
- out.Failed = int32(in.Failed)
- return nil
-}
-
-func Convert_extensions_JobStatus_To_v1beta1_JobStatus(in *extensions.JobStatus, out *JobStatus, s conversion.Scope) error {
- return autoConvert_extensions_JobStatus_To_v1beta1_JobStatus(in, out, s)
-}
-
-func autoConvert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in *extensions.PodSecurityPolicy, out *PodSecurityPolicy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.PodSecurityPolicy))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in *extensions.PodSecurityPolicy, out *PodSecurityPolicy, s conversion.Scope) error {
- return autoConvert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in, out, s)
-}
-
-func autoConvert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in *extensions.PodSecurityPolicyList, out *PodSecurityPolicyList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.PodSecurityPolicyList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]PodSecurityPolicy, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in *extensions.PodSecurityPolicyList, out *PodSecurityPolicyList, s conversion.Scope) error {
- return autoConvert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in, out, s)
-}
-
-func autoConvert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in *extensions.PodSecurityPolicySpec, out *PodSecurityPolicySpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.PodSecurityPolicySpec))(in)
- }
- out.Privileged = in.Privileged
- if in.Capabilities != nil {
- out.Capabilities = make([]v1.Capability, len(in.Capabilities))
- for i := range in.Capabilities {
- out.Capabilities[i] = v1.Capability(in.Capabilities[i])
- }
- } else {
- out.Capabilities = nil
- }
- if in.Volumes != nil {
- out.Volumes = make([]FSType, len(in.Volumes))
- for i := range in.Volumes {
- out.Volumes[i] = FSType(in.Volumes[i])
- }
- } else {
- out.Volumes = nil
- }
- out.HostNetwork = in.HostNetwork
- if in.HostPorts != nil {
- out.HostPorts = make([]HostPortRange, len(in.HostPorts))
- for i := range in.HostPorts {
- if err := Convert_extensions_HostPortRange_To_v1beta1_HostPortRange(&in.HostPorts[i], &out.HostPorts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HostPorts = nil
- }
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if err := Convert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(&in.SELinux, &out.SELinux, s); err != nil {
- return err
- }
- if err := Convert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(&in.RunAsUser, &out.RunAsUser, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in *extensions.PodSecurityPolicySpec, out *PodSecurityPolicySpec, s conversion.Scope) error {
- return autoConvert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in, out, s)
-}
-
-func autoConvert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in *extensions.ReplicaSet, out *ReplicaSet, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicaSet))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in *extensions.ReplicaSet, out *ReplicaSet, s conversion.Scope) error {
- return autoConvert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in, out, s)
-}
-
-func autoConvert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in *extensions.ReplicaSetList, out *ReplicaSetList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicaSetList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ReplicaSet, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in *extensions.ReplicaSetList, out *ReplicaSetList, s conversion.Scope) error {
- return autoConvert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in, out, s)
-}
-
-func autoConvert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in *extensions.ReplicaSetSpec, out *ReplicaSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicaSetSpec))(in)
- }
- if err := s.Convert(&in.Replicas, &out.Replicas, 0); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1beta1.LabelSelector
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *extensions.ReplicaSetStatus, out *ReplicaSetStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicaSetStatus))(in)
- }
- out.Replicas = int32(in.Replicas)
- out.FullyLabeledReplicas = int32(in.FullyLabeledReplicas)
- out.ObservedGeneration = in.ObservedGeneration
- return nil
-}
-
-func Convert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *extensions.ReplicaSetStatus, out *ReplicaSetStatus, s conversion.Scope) error {
- return autoConvert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in, out, s)
-}
-
-func autoConvert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in *extensions.ReplicationControllerDummy, out *ReplicationControllerDummy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicationControllerDummy))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in *extensions.ReplicationControllerDummy, out *ReplicationControllerDummy, s conversion.Scope) error {
- return autoConvert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in, out, s)
-}
-
-func autoConvert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in *extensions.RollbackConfig, out *RollbackConfig, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.RollbackConfig))(in)
- }
- out.Revision = in.Revision
- return nil
-}
-
-func Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in *extensions.RollbackConfig, out *RollbackConfig, s conversion.Scope) error {
- return autoConvert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in, out, s)
-}
-
-func autoConvert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *extensions.RollingUpdateDeployment, out *RollingUpdateDeployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.RollingUpdateDeployment))(in)
- }
- if err := s.Convert(&in.MaxUnavailable, &out.MaxUnavailable, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.MaxSurge, &out.MaxSurge, 0); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in *extensions.RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.RunAsUserStrategyOptions))(in)
- }
- out.Rule = RunAsUserStrategy(in.Rule)
- if in.Ranges != nil {
- out.Ranges = make([]IDRange, len(in.Ranges))
- for i := range in.Ranges {
- if err := Convert_extensions_IDRange_To_v1beta1_IDRange(&in.Ranges[i], &out.Ranges[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ranges = nil
- }
- return nil
-}
-
-func Convert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in *extensions.RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, s conversion.Scope) error {
- return autoConvert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in, out, s)
-}
-
-func autoConvert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in *extensions.SELinuxStrategyOptions, out *SELinuxStrategyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.SELinuxStrategyOptions))(in)
- }
- out.Rule = SELinuxStrategy(in.Rule)
- // unable to generate simple pointer conversion for api.SELinuxOptions -> v1.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- return nil
-}
-
-func Convert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in *extensions.SELinuxStrategyOptions, out *SELinuxStrategyOptions, s conversion.Scope) error {
- return autoConvert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in, out, s)
-}
-
-func autoConvert_extensions_Scale_To_v1beta1_Scale(in *extensions.Scale, out *Scale, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.Scale))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_Scale_To_v1beta1_Scale(in *extensions.Scale, out *Scale, s conversion.Scope) error {
- return autoConvert_extensions_Scale_To_v1beta1_Scale(in, out, s)
-}
-
-func autoConvert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in *extensions.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ScaleSpec))(in)
- }
- out.Replicas = int32(in.Replicas)
- return nil
-}
-
-func Convert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in *extensions.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
- return autoConvert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in, out, s)
-}
-
-func autoConvert_extensions_ScaleStatus_To_v1beta1_ScaleStatus(in *extensions.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ScaleStatus))(in)
- }
- out.Replicas = int32(in.Replicas)
- // in.Selector has no peer in out
- return nil
-}
-
-func autoConvert_extensions_SubresourceReference_To_v1beta1_SubresourceReference(in *extensions.SubresourceReference, out *SubresourceReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.SubresourceReference))(in)
- }
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- out.Subresource = in.Subresource
- return nil
-}
-
-func Convert_extensions_SubresourceReference_To_v1beta1_SubresourceReference(in *extensions.SubresourceReference, out *SubresourceReference, s conversion.Scope) error {
- return autoConvert_extensions_SubresourceReference_To_v1beta1_SubresourceReference(in, out, s)
-}
-
-func autoConvert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in *extensions.ThirdPartyResource, out *ThirdPartyResource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ThirdPartyResource))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- out.Description = in.Description
- if in.Versions != nil {
- out.Versions = make([]APIVersion, len(in.Versions))
- for i := range in.Versions {
- if err := Convert_extensions_APIVersion_To_v1beta1_APIVersion(&in.Versions[i], &out.Versions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Versions = nil
- }
- return nil
-}
-
-func Convert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in *extensions.ThirdPartyResource, out *ThirdPartyResource, s conversion.Scope) error {
- return autoConvert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in, out, s)
-}
-
-func autoConvert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in *extensions.ThirdPartyResourceData, out *ThirdPartyResourceData, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ThirdPartyResourceData))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := conversion.ByteSliceCopy(&in.Data, &out.Data, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in *extensions.ThirdPartyResourceData, out *ThirdPartyResourceData, s conversion.Scope) error {
- return autoConvert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in, out, s)
-}
-
-func autoConvert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in *extensions.ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ThirdPartyResourceDataList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ThirdPartyResourceData, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in *extensions.ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, s conversion.Scope) error {
- return autoConvert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in, out, s)
-}
-
-func autoConvert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in *extensions.ThirdPartyResourceList, out *ThirdPartyResourceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ThirdPartyResourceList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ThirdPartyResource, len(in.Items))
- for i := range in.Items {
- if err := Convert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in *extensions.ThirdPartyResourceList, out *ThirdPartyResourceList, s conversion.Scope) error {
- return autoConvert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in, out, s)
-}
-
-func autoConvert_v1beta1_APIVersion_To_extensions_APIVersion(in *APIVersion, out *extensions.APIVersion, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*APIVersion))(in)
- }
- out.Name = in.Name
- out.APIGroup = in.APIGroup
- return nil
-}
-
-func Convert_v1beta1_APIVersion_To_extensions_APIVersion(in *APIVersion, out *extensions.APIVersion, s conversion.Scope) error {
- return autoConvert_v1beta1_APIVersion_To_extensions_APIVersion(in, out, s)
-}
-
-func autoConvert_v1beta1_CPUTargetUtilization_To_extensions_CPUTargetUtilization(in *CPUTargetUtilization, out *extensions.CPUTargetUtilization, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*CPUTargetUtilization))(in)
- }
- out.TargetPercentage = int(in.TargetPercentage)
- return nil
-}
-
-func Convert_v1beta1_CPUTargetUtilization_To_extensions_CPUTargetUtilization(in *CPUTargetUtilization, out *extensions.CPUTargetUtilization, s conversion.Scope) error {
- return autoConvert_v1beta1_CPUTargetUtilization_To_extensions_CPUTargetUtilization(in, out, s)
-}
-
-func autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet(in *DaemonSet, out *extensions.DaemonSet, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DaemonSet))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_DaemonSet_To_extensions_DaemonSet(in *DaemonSet, out *extensions.DaemonSet, s conversion.Scope) error {
- return autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet(in, out, s)
-}
-
-func autoConvert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in *DaemonSetList, out *extensions.DaemonSetList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DaemonSetList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.DaemonSet, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_DaemonSet_To_extensions_DaemonSet(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in *DaemonSetList, out *extensions.DaemonSetList, s conversion.Scope) error {
- return autoConvert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in, out, s)
-}
-
-func autoConvert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in *DaemonSetSpec, out *extensions.DaemonSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DaemonSetSpec))(in)
- }
- // unable to generate simple pointer conversion for v1beta1.LabelSelector -> unversioned.LabelSelector
- if in.Selector != nil {
- out.Selector = new(unversioned.LabelSelector)
- if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in *DaemonSetSpec, out *extensions.DaemonSetSpec, s conversion.Scope) error {
- return autoConvert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in, out, s)
-}
-
-func autoConvert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in *DaemonSetStatus, out *extensions.DaemonSetStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DaemonSetStatus))(in)
- }
- out.CurrentNumberScheduled = int(in.CurrentNumberScheduled)
- out.NumberMisscheduled = int(in.NumberMisscheduled)
- out.DesiredNumberScheduled = int(in.DesiredNumberScheduled)
- return nil
-}
-
-func Convert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in *DaemonSetStatus, out *extensions.DaemonSetStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_Deployment_To_extensions_Deployment(in *Deployment, out *extensions.Deployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Deployment))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_Deployment_To_extensions_Deployment(in *Deployment, out *extensions.Deployment, s conversion.Scope) error {
- return autoConvert_v1beta1_Deployment_To_extensions_Deployment(in, out, s)
-}
-
-func autoConvert_v1beta1_DeploymentList_To_extensions_DeploymentList(in *DeploymentList, out *extensions.DeploymentList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.Deployment, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_Deployment_To_extensions_Deployment(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_DeploymentList_To_extensions_DeploymentList(in *DeploymentList, out *extensions.DeploymentList, s conversion.Scope) error {
- return autoConvert_v1beta1_DeploymentList_To_extensions_DeploymentList(in, out, s)
-}
-
-func autoConvert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in *DeploymentRollback, out *extensions.DeploymentRollback, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentRollback))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- out.Name = in.Name
- if in.UpdatedAnnotations != nil {
- out.UpdatedAnnotations = make(map[string]string)
- for key, val := range in.UpdatedAnnotations {
- out.UpdatedAnnotations[key] = val
- }
- } else {
- out.UpdatedAnnotations = nil
- }
- if err := Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in *DeploymentRollback, out *extensions.DeploymentRollback, s conversion.Scope) error {
- return autoConvert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in, out, s)
-}
-
-func autoConvert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(in *DeploymentSpec, out *extensions.DeploymentSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentSpec))(in)
- }
- // in.Replicas has no peer in out
- // unable to generate simple pointer conversion for v1beta1.LabelSelector -> unversioned.LabelSelector
- if in.Selector != nil {
- out.Selector = new(unversioned.LabelSelector)
- if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- if err := s.Convert(&in.Strategy, &out.Strategy, 0); err != nil {
- return err
- }
- out.MinReadySeconds = int(in.MinReadySeconds)
- if in.RevisionHistoryLimit != nil {
- out.RevisionHistoryLimit = new(int)
- *out.RevisionHistoryLimit = int(*in.RevisionHistoryLimit)
- } else {
- out.RevisionHistoryLimit = nil
- }
- out.Paused = in.Paused
- // unable to generate simple pointer conversion for v1beta1.RollbackConfig -> extensions.RollbackConfig
- if in.RollbackTo != nil {
- out.RollbackTo = new(extensions.RollbackConfig)
- if err := Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in.RollbackTo, out.RollbackTo, s); err != nil {
- return err
- }
- } else {
- out.RollbackTo = nil
- }
- return nil
-}
-
-func autoConvert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in *DeploymentStatus, out *extensions.DeploymentStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentStatus))(in)
- }
- out.ObservedGeneration = in.ObservedGeneration
- out.Replicas = int(in.Replicas)
- out.UpdatedReplicas = int(in.UpdatedReplicas)
- out.AvailableReplicas = int(in.AvailableReplicas)
- out.UnavailableReplicas = int(in.UnavailableReplicas)
- return nil
-}
-
-func Convert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in *DeploymentStatus, out *extensions.DeploymentStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in *HTTPIngressPath, out *extensions.HTTPIngressPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HTTPIngressPath))(in)
- }
- out.Path = in.Path
- if err := Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in *HTTPIngressPath, out *extensions.HTTPIngressPath, s conversion.Scope) error {
- return autoConvert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in, out, s)
-}
-
-func autoConvert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *extensions.HTTPIngressRuleValue, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HTTPIngressRuleValue))(in)
- }
- if in.Paths != nil {
- out.Paths = make([]extensions.HTTPIngressPath, len(in.Paths))
- for i := range in.Paths {
- if err := Convert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(&in.Paths[i], &out.Paths[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Paths = nil
- }
- return nil
-}
-
-func Convert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *extensions.HTTPIngressRuleValue, s conversion.Scope) error {
- return autoConvert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in, out, s)
-}
-
-func autoConvert_v1beta1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *extensions.HorizontalPodAutoscaler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscaler))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *extensions.HorizontalPodAutoscaler, s conversion.Scope) error {
- return autoConvert_v1beta1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(in, out, s)
-}
-
-func autoConvert_v1beta1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *extensions.HorizontalPodAutoscalerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *extensions.HorizontalPodAutoscalerList, s conversion.Scope) error {
- return autoConvert_v1beta1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList(in, out, s)
-}
-
-func autoConvert_v1beta1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *extensions.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerSpec))(in)
- }
- if err := Convert_v1beta1_SubresourceReference_To_extensions_SubresourceReference(&in.ScaleRef, &out.ScaleRef, s); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int)
- *out.MinReplicas = int(*in.MinReplicas)
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = int(in.MaxReplicas)
- // unable to generate simple pointer conversion for v1beta1.CPUTargetUtilization -> extensions.CPUTargetUtilization
- if in.CPUUtilization != nil {
- out.CPUUtilization = new(extensions.CPUTargetUtilization)
- if err := Convert_v1beta1_CPUTargetUtilization_To_extensions_CPUTargetUtilization(in.CPUUtilization, out.CPUUtilization, s); err != nil {
- return err
- }
- } else {
- out.CPUUtilization = nil
- }
- return nil
-}
-
-func Convert_v1beta1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *extensions.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
- return autoConvert_v1beta1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec(in, out, s)
-}
-
-func autoConvert_v1beta1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *extensions.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HorizontalPodAutoscalerStatus))(in)
- }
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastScaleTime, out.LastScaleTime, s); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = int(in.CurrentReplicas)
- out.DesiredReplicas = int(in.DesiredReplicas)
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int)
- *out.CurrentCPUUtilizationPercentage = int(*in.CurrentCPUUtilizationPercentage)
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func Convert_v1beta1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *extensions.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_HostPortRange_To_extensions_HostPortRange(in *HostPortRange, out *extensions.HostPortRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HostPortRange))(in)
- }
- out.Min = int(in.Min)
- out.Max = int(in.Max)
- return nil
-}
-
-func Convert_v1beta1_HostPortRange_To_extensions_HostPortRange(in *HostPortRange, out *extensions.HostPortRange, s conversion.Scope) error {
- return autoConvert_v1beta1_HostPortRange_To_extensions_HostPortRange(in, out, s)
-}
-
-func autoConvert_v1beta1_IDRange_To_extensions_IDRange(in *IDRange, out *extensions.IDRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IDRange))(in)
- }
- out.Min = in.Min
- out.Max = in.Max
- return nil
-}
-
-func Convert_v1beta1_IDRange_To_extensions_IDRange(in *IDRange, out *extensions.IDRange, s conversion.Scope) error {
- return autoConvert_v1beta1_IDRange_To_extensions_IDRange(in, out, s)
-}
-
-func autoConvert_v1beta1_Ingress_To_extensions_Ingress(in *Ingress, out *extensions.Ingress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Ingress))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_IngressSpec_To_extensions_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_IngressStatus_To_extensions_IngressStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_Ingress_To_extensions_Ingress(in *Ingress, out *extensions.Ingress, s conversion.Scope) error {
- return autoConvert_v1beta1_Ingress_To_extensions_Ingress(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressBackend_To_extensions_IngressBackend(in *IngressBackend, out *extensions.IngressBackend, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressBackend))(in)
- }
- out.ServiceName = in.ServiceName
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.ServicePort, &out.ServicePort, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(in *IngressBackend, out *extensions.IngressBackend, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressBackend_To_extensions_IngressBackend(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressList_To_extensions_IngressList(in *IngressList, out *extensions.IngressList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.Ingress, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_Ingress_To_extensions_Ingress(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_IngressList_To_extensions_IngressList(in *IngressList, out *extensions.IngressList, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressList_To_extensions_IngressList(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressRule_To_extensions_IngressRule(in *IngressRule, out *extensions.IngressRule, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressRule))(in)
- }
- out.Host = in.Host
- if err := Convert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_IngressRule_To_extensions_IngressRule(in *IngressRule, out *extensions.IngressRule, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressRule_To_extensions_IngressRule(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in *IngressRuleValue, out *extensions.IngressRuleValue, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressRuleValue))(in)
- }
- // unable to generate simple pointer conversion for v1beta1.HTTPIngressRuleValue -> extensions.HTTPIngressRuleValue
- if in.HTTP != nil {
- out.HTTP = new(extensions.HTTPIngressRuleValue)
- if err := Convert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in.HTTP, out.HTTP, s); err != nil {
- return err
- }
- } else {
- out.HTTP = nil
- }
- return nil
-}
-
-func Convert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in *IngressRuleValue, out *extensions.IngressRuleValue, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressSpec_To_extensions_IngressSpec(in *IngressSpec, out *extensions.IngressSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressSpec))(in)
- }
- // unable to generate simple pointer conversion for v1beta1.IngressBackend -> extensions.IngressBackend
- if in.Backend != nil {
- out.Backend = new(extensions.IngressBackend)
- if err := Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(in.Backend, out.Backend, s); err != nil {
- return err
- }
- } else {
- out.Backend = nil
- }
- if in.TLS != nil {
- out.TLS = make([]extensions.IngressTLS, len(in.TLS))
- for i := range in.TLS {
- if err := Convert_v1beta1_IngressTLS_To_extensions_IngressTLS(&in.TLS[i], &out.TLS[i], s); err != nil {
- return err
- }
- }
- } else {
- out.TLS = nil
- }
- if in.Rules != nil {
- out.Rules = make([]extensions.IngressRule, len(in.Rules))
- for i := range in.Rules {
- if err := Convert_v1beta1_IngressRule_To_extensions_IngressRule(&in.Rules[i], &out.Rules[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Rules = nil
- }
- return nil
-}
-
-func Convert_v1beta1_IngressSpec_To_extensions_IngressSpec(in *IngressSpec, out *extensions.IngressSpec, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressSpec_To_extensions_IngressSpec(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressStatus_To_extensions_IngressStatus(in *IngressStatus, out *extensions.IngressStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressStatus))(in)
- }
- if err := Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_IngressStatus_To_extensions_IngressStatus(in *IngressStatus, out *extensions.IngressStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressStatus_To_extensions_IngressStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_IngressTLS_To_extensions_IngressTLS(in *IngressTLS, out *extensions.IngressTLS, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*IngressTLS))(in)
- }
- if in.Hosts != nil {
- out.Hosts = make([]string, len(in.Hosts))
- for i := range in.Hosts {
- out.Hosts[i] = in.Hosts[i]
- }
- } else {
- out.Hosts = nil
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_v1beta1_IngressTLS_To_extensions_IngressTLS(in *IngressTLS, out *extensions.IngressTLS, s conversion.Scope) error {
- return autoConvert_v1beta1_IngressTLS_To_extensions_IngressTLS(in, out, s)
-}
-
-func autoConvert_v1beta1_Job_To_extensions_Job(in *Job, out *extensions.Job, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Job))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_JobSpec_To_extensions_JobSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_JobStatus_To_extensions_JobStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_Job_To_extensions_Job(in *Job, out *extensions.Job, s conversion.Scope) error {
- return autoConvert_v1beta1_Job_To_extensions_Job(in, out, s)
-}
-
-func autoConvert_v1beta1_JobCondition_To_extensions_JobCondition(in *JobCondition, out *extensions.JobCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobCondition))(in)
- }
- out.Type = extensions.JobConditionType(in.Type)
- out.Status = api.ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_v1beta1_JobCondition_To_extensions_JobCondition(in *JobCondition, out *extensions.JobCondition, s conversion.Scope) error {
- return autoConvert_v1beta1_JobCondition_To_extensions_JobCondition(in, out, s)
-}
-
-func autoConvert_v1beta1_JobList_To_extensions_JobList(in *JobList, out *extensions.JobList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.Job, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_Job_To_extensions_Job(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_JobList_To_extensions_JobList(in *JobList, out *extensions.JobList, s conversion.Scope) error {
- return autoConvert_v1beta1_JobList_To_extensions_JobList(in, out, s)
-}
-
-func autoConvert_v1beta1_JobSpec_To_extensions_JobSpec(in *JobSpec, out *extensions.JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int)
- *out.Parallelism = int(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int)
- *out.Completions = int(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- // unable to generate simple pointer conversion for v1beta1.LabelSelector -> unversioned.LabelSelector
- if in.Selector != nil {
- out.Selector = new(unversioned.LabelSelector)
- if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- // in.AutoSelector has no peer in out
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_v1beta1_JobStatus_To_extensions_JobStatus(in *JobStatus, out *extensions.JobStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobStatus))(in)
- }
- if in.Conditions != nil {
- out.Conditions = make([]extensions.JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_v1beta1_JobCondition_To_extensions_JobCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.CompletionTime, out.CompletionTime, s); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = int(in.Active)
- out.Succeeded = int(in.Succeeded)
- out.Failed = int(in.Failed)
- return nil
-}
-
-func Convert_v1beta1_JobStatus_To_extensions_JobStatus(in *JobStatus, out *extensions.JobStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_JobStatus_To_extensions_JobStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LabelSelector))(in)
- }
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]unversioned.LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := Convert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&in.MatchExpressions[i], &out.MatchExpressions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
- return autoConvert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
-}
-
-func autoConvert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LabelSelectorRequirement))(in)
- }
- out.Key = in.Key
- out.Operator = unversioned.LabelSelectorOperator(in.Operator)
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func Convert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
- return autoConvert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
-}
-
-func autoConvert_v1beta1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ListOptions))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_string_To_labels_Selector(&in.LabelSelector, &out.LabelSelector, s); err != nil {
- return err
- }
- if err := api.Convert_string_To_fields_Selector(&in.FieldSelector, &out.FieldSelector, s); err != nil {
- return err
- }
- out.Watch = in.Watch
- out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
- return nil
-}
-
-func Convert_v1beta1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
- return autoConvert_v1beta1_ListOptions_To_api_ListOptions(in, out, s)
-}
-
-func autoConvert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in *PodSecurityPolicy, out *extensions.PodSecurityPolicy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSecurityPolicy))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in *PodSecurityPolicy, out *extensions.PodSecurityPolicy, s conversion.Scope) error {
- return autoConvert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in, out, s)
-}
-
-func autoConvert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in *PodSecurityPolicyList, out *extensions.PodSecurityPolicyList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSecurityPolicyList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.PodSecurityPolicy, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in *PodSecurityPolicyList, out *extensions.PodSecurityPolicyList, s conversion.Scope) error {
- return autoConvert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in, out, s)
-}
-
-func autoConvert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in *PodSecurityPolicySpec, out *extensions.PodSecurityPolicySpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSecurityPolicySpec))(in)
- }
- out.Privileged = in.Privileged
- if in.Capabilities != nil {
- out.Capabilities = make([]api.Capability, len(in.Capabilities))
- for i := range in.Capabilities {
- out.Capabilities[i] = api.Capability(in.Capabilities[i])
- }
- } else {
- out.Capabilities = nil
- }
- if in.Volumes != nil {
- out.Volumes = make([]extensions.FSType, len(in.Volumes))
- for i := range in.Volumes {
- out.Volumes[i] = extensions.FSType(in.Volumes[i])
- }
- } else {
- out.Volumes = nil
- }
- out.HostNetwork = in.HostNetwork
- if in.HostPorts != nil {
- out.HostPorts = make([]extensions.HostPortRange, len(in.HostPorts))
- for i := range in.HostPorts {
- if err := Convert_v1beta1_HostPortRange_To_extensions_HostPortRange(&in.HostPorts[i], &out.HostPorts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HostPorts = nil
- }
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if err := Convert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(&in.SELinux, &out.SELinux, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(&in.RunAsUser, &out.RunAsUser, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in *PodSecurityPolicySpec, out *extensions.PodSecurityPolicySpec, s conversion.Scope) error {
- return autoConvert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in, out, s)
-}
-
-func autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in *ReplicaSet, out *extensions.ReplicaSet, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicaSet))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in *ReplicaSet, out *extensions.ReplicaSet, s conversion.Scope) error {
- return autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in, out, s)
-}
-
-func autoConvert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in *ReplicaSetList, out *extensions.ReplicaSetList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicaSetList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.ReplicaSet, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in *ReplicaSetList, out *extensions.ReplicaSetList, s conversion.Scope) error {
- return autoConvert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in, out, s)
-}
-
-func autoConvert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec(in *ReplicaSetSpec, out *extensions.ReplicaSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicaSetSpec))(in)
- }
- // in.Replicas has no peer in out
- // unable to generate simple pointer conversion for v1beta1.LabelSelector -> unversioned.LabelSelector
- if in.Selector != nil {
- out.Selector = new(unversioned.LabelSelector)
- if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in *ReplicaSetStatus, out *extensions.ReplicaSetStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicaSetStatus))(in)
- }
- out.Replicas = int(in.Replicas)
- out.FullyLabeledReplicas = int(in.FullyLabeledReplicas)
- out.ObservedGeneration = in.ObservedGeneration
- return nil
-}
-
-func Convert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in *ReplicaSetStatus, out *extensions.ReplicaSetStatus, s conversion.Scope) error {
- return autoConvert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in, out, s)
-}
-
-func autoConvert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in *ReplicationControllerDummy, out *extensions.ReplicationControllerDummy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationControllerDummy))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in *ReplicationControllerDummy, out *extensions.ReplicationControllerDummy, s conversion.Scope) error {
- return autoConvert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in, out, s)
-}
-
-func autoConvert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in *RollbackConfig, out *extensions.RollbackConfig, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RollbackConfig))(in)
- }
- out.Revision = in.Revision
- return nil
-}
-
-func Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in *RollbackConfig, out *extensions.RollbackConfig, s conversion.Scope) error {
- return autoConvert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in, out, s)
-}
-
-func autoConvert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment(in *RollingUpdateDeployment, out *extensions.RollingUpdateDeployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RollingUpdateDeployment))(in)
- }
- // in.MaxUnavailable has no peer in out
- // in.MaxSurge has no peer in out
- return nil
-}
-
-func autoConvert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in *RunAsUserStrategyOptions, out *extensions.RunAsUserStrategyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RunAsUserStrategyOptions))(in)
- }
- out.Rule = extensions.RunAsUserStrategy(in.Rule)
- if in.Ranges != nil {
- out.Ranges = make([]extensions.IDRange, len(in.Ranges))
- for i := range in.Ranges {
- if err := Convert_v1beta1_IDRange_To_extensions_IDRange(&in.Ranges[i], &out.Ranges[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ranges = nil
- }
- return nil
-}
-
-func Convert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in *RunAsUserStrategyOptions, out *extensions.RunAsUserStrategyOptions, s conversion.Scope) error {
- return autoConvert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in, out, s)
-}
-
-func autoConvert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in *SELinuxStrategyOptions, out *extensions.SELinuxStrategyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SELinuxStrategyOptions))(in)
- }
- out.Rule = extensions.SELinuxStrategy(in.Rule)
- // unable to generate simple pointer conversion for v1.SELinuxOptions -> api.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(api.SELinuxOptions)
- if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- return nil
-}
-
-func Convert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in *SELinuxStrategyOptions, out *extensions.SELinuxStrategyOptions, s conversion.Scope) error {
- return autoConvert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in, out, s)
-}
-
-func autoConvert_v1beta1_Scale_To_extensions_Scale(in *Scale, out *extensions.Scale, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Scale))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_Scale_To_extensions_Scale(in *Scale, out *extensions.Scale, s conversion.Scope) error {
- return autoConvert_v1beta1_Scale_To_extensions_Scale(in, out, s)
-}
-
-func autoConvert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in *ScaleSpec, out *extensions.ScaleSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ScaleSpec))(in)
- }
- out.Replicas = int(in.Replicas)
- return nil
-}
-
-func Convert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in *ScaleSpec, out *extensions.ScaleSpec, s conversion.Scope) error {
- return autoConvert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in, out, s)
-}
-
-func autoConvert_v1beta1_ScaleStatus_To_extensions_ScaleStatus(in *ScaleStatus, out *extensions.ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ScaleStatus))(in)
- }
- out.Replicas = int(in.Replicas)
- // in.Selector has no peer in out
- // in.TargetSelector has no peer in out
- return nil
-}
-
-func autoConvert_v1beta1_SubresourceReference_To_extensions_SubresourceReference(in *SubresourceReference, out *extensions.SubresourceReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SubresourceReference))(in)
- }
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- out.Subresource = in.Subresource
- return nil
-}
-
-func Convert_v1beta1_SubresourceReference_To_extensions_SubresourceReference(in *SubresourceReference, out *extensions.SubresourceReference, s conversion.Scope) error {
- return autoConvert_v1beta1_SubresourceReference_To_extensions_SubresourceReference(in, out, s)
-}
-
-func autoConvert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in *ThirdPartyResource, out *extensions.ThirdPartyResource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ThirdPartyResource))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- out.Description = in.Description
- if in.Versions != nil {
- out.Versions = make([]extensions.APIVersion, len(in.Versions))
- for i := range in.Versions {
- if err := Convert_v1beta1_APIVersion_To_extensions_APIVersion(&in.Versions[i], &out.Versions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Versions = nil
- }
- return nil
-}
-
-func Convert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in *ThirdPartyResource, out *extensions.ThirdPartyResource, s conversion.Scope) error {
- return autoConvert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in, out, s)
-}
-
-func autoConvert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in *ThirdPartyResourceData, out *extensions.ThirdPartyResourceData, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ThirdPartyResourceData))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := conversion.ByteSliceCopy(&in.Data, &out.Data, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in *ThirdPartyResourceData, out *extensions.ThirdPartyResourceData, s conversion.Scope) error {
- return autoConvert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in, out, s)
-}
-
-func autoConvert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in *ThirdPartyResourceDataList, out *extensions.ThirdPartyResourceDataList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ThirdPartyResourceDataList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.ThirdPartyResourceData, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in *ThirdPartyResourceDataList, out *extensions.ThirdPartyResourceDataList, s conversion.Scope) error {
- return autoConvert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in, out, s)
-}
-
-func autoConvert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in *ThirdPartyResourceList, out *extensions.ThirdPartyResourceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ThirdPartyResourceList))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]extensions.ThirdPartyResource, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in *ThirdPartyResourceList, out *extensions.ThirdPartyResourceList, s conversion.Scope) error {
- return autoConvert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in, out, s)
-}
-
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource,
- autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource,
- autoConvert_api_Capabilities_To_v1_Capabilities,
- autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource,
- autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource,
- autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector,
- autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource,
- autoConvert_api_ContainerPort_To_v1_ContainerPort,
- autoConvert_api_Container_To_v1_Container,
- autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile,
- autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource,
- autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource,
- autoConvert_api_EnvVarSource_To_v1_EnvVarSource,
- autoConvert_api_EnvVar_To_v1_EnvVar,
- autoConvert_api_ExecAction_To_v1_ExecAction,
- autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource,
- autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource,
- autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource,
- autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource,
- autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource,
- autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource,
- autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction,
- autoConvert_api_HTTPHeader_To_v1_HTTPHeader,
- autoConvert_api_Handler_To_v1_Handler,
- autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource,
- autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource,
- autoConvert_api_KeyToPath_To_v1_KeyToPath,
- autoConvert_api_Lifecycle_To_v1_Lifecycle,
- autoConvert_api_ListOptions_To_v1beta1_ListOptions,
- autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress,
- autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus,
- autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference,
- autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource,
- autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector,
- autoConvert_api_ObjectMeta_To_v1_ObjectMeta,
- autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource,
- autoConvert_api_PodSpec_To_v1_PodSpec,
- autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec,
- autoConvert_api_Probe_To_v1_Probe,
- autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource,
- autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements,
- autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions,
- autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector,
- autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource,
- autoConvert_api_SecurityContext_To_v1_SecurityContext,
- autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction,
- autoConvert_api_VolumeMount_To_v1_VolumeMount,
- autoConvert_api_VolumeSource_To_v1_VolumeSource,
- autoConvert_api_Volume_To_v1_Volume,
- autoConvert_extensions_APIVersion_To_v1beta1_APIVersion,
- autoConvert_extensions_CPUTargetUtilization_To_v1beta1_CPUTargetUtilization,
- autoConvert_extensions_DaemonSetList_To_v1beta1_DaemonSetList,
- autoConvert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec,
- autoConvert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus,
- autoConvert_extensions_DaemonSet_To_v1beta1_DaemonSet,
- autoConvert_extensions_DeploymentList_To_v1beta1_DeploymentList,
- autoConvert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback,
- autoConvert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec,
- autoConvert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus,
- autoConvert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy,
- autoConvert_extensions_Deployment_To_v1beta1_Deployment,
- autoConvert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath,
- autoConvert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue,
- autoConvert_extensions_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList,
- autoConvert_extensions_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec,
- autoConvert_extensions_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus,
- autoConvert_extensions_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler,
- autoConvert_extensions_HostPortRange_To_v1beta1_HostPortRange,
- autoConvert_extensions_IDRange_To_v1beta1_IDRange,
- autoConvert_extensions_IngressBackend_To_v1beta1_IngressBackend,
- autoConvert_extensions_IngressList_To_v1beta1_IngressList,
- autoConvert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue,
- autoConvert_extensions_IngressRule_To_v1beta1_IngressRule,
- autoConvert_extensions_IngressSpec_To_v1beta1_IngressSpec,
- autoConvert_extensions_IngressStatus_To_v1beta1_IngressStatus,
- autoConvert_extensions_IngressTLS_To_v1beta1_IngressTLS,
- autoConvert_extensions_Ingress_To_v1beta1_Ingress,
- autoConvert_extensions_JobCondition_To_v1beta1_JobCondition,
- autoConvert_extensions_JobList_To_v1beta1_JobList,
- autoConvert_extensions_JobSpec_To_v1beta1_JobSpec,
- autoConvert_extensions_JobStatus_To_v1beta1_JobStatus,
- autoConvert_extensions_Job_To_v1beta1_Job,
- autoConvert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList,
- autoConvert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec,
- autoConvert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy,
- autoConvert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList,
- autoConvert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec,
- autoConvert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus,
- autoConvert_extensions_ReplicaSet_To_v1beta1_ReplicaSet,
- autoConvert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy,
- autoConvert_extensions_RollbackConfig_To_v1beta1_RollbackConfig,
- autoConvert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment,
- autoConvert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions,
- autoConvert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions,
- autoConvert_extensions_ScaleSpec_To_v1beta1_ScaleSpec,
- autoConvert_extensions_ScaleStatus_To_v1beta1_ScaleStatus,
- autoConvert_extensions_Scale_To_v1beta1_Scale,
- autoConvert_extensions_SubresourceReference_To_v1beta1_SubresourceReference,
- autoConvert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList,
- autoConvert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData,
- autoConvert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList,
- autoConvert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource,
- autoConvert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement,
- autoConvert_unversioned_LabelSelector_To_v1beta1_LabelSelector,
- autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource,
- autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource,
- autoConvert_v1_Capabilities_To_api_Capabilities,
- autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource,
- autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource,
- autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector,
- autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource,
- autoConvert_v1_ContainerPort_To_api_ContainerPort,
- autoConvert_v1_Container_To_api_Container,
- autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile,
- autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource,
- autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource,
- autoConvert_v1_EnvVarSource_To_api_EnvVarSource,
- autoConvert_v1_EnvVar_To_api_EnvVar,
- autoConvert_v1_ExecAction_To_api_ExecAction,
- autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource,
- autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource,
- autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource,
- autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource,
- autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource,
- autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource,
- autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction,
- autoConvert_v1_HTTPHeader_To_api_HTTPHeader,
- autoConvert_v1_Handler_To_api_Handler,
- autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource,
- autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource,
- autoConvert_v1_KeyToPath_To_api_KeyToPath,
- autoConvert_v1_Lifecycle_To_api_Lifecycle,
- autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress,
- autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus,
- autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference,
- autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource,
- autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector,
- autoConvert_v1_ObjectMeta_To_api_ObjectMeta,
- autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource,
- autoConvert_v1_PodSpec_To_api_PodSpec,
- autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec,
- autoConvert_v1_Probe_To_api_Probe,
- autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource,
- autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements,
- autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions,
- autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector,
- autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource,
- autoConvert_v1_SecurityContext_To_api_SecurityContext,
- autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction,
- autoConvert_v1_VolumeMount_To_api_VolumeMount,
- autoConvert_v1_VolumeSource_To_api_VolumeSource,
- autoConvert_v1_Volume_To_api_Volume,
- autoConvert_v1beta1_APIVersion_To_extensions_APIVersion,
- autoConvert_v1beta1_CPUTargetUtilization_To_extensions_CPUTargetUtilization,
- autoConvert_v1beta1_DaemonSetList_To_extensions_DaemonSetList,
- autoConvert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec,
- autoConvert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus,
- autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet,
- autoConvert_v1beta1_DeploymentList_To_extensions_DeploymentList,
- autoConvert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback,
- autoConvert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec,
- autoConvert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus,
- autoConvert_v1beta1_Deployment_To_extensions_Deployment,
- autoConvert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath,
- autoConvert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue,
- autoConvert_v1beta1_HorizontalPodAutoscalerList_To_extensions_HorizontalPodAutoscalerList,
- autoConvert_v1beta1_HorizontalPodAutoscalerSpec_To_extensions_HorizontalPodAutoscalerSpec,
- autoConvert_v1beta1_HorizontalPodAutoscalerStatus_To_extensions_HorizontalPodAutoscalerStatus,
- autoConvert_v1beta1_HorizontalPodAutoscaler_To_extensions_HorizontalPodAutoscaler,
- autoConvert_v1beta1_HostPortRange_To_extensions_HostPortRange,
- autoConvert_v1beta1_IDRange_To_extensions_IDRange,
- autoConvert_v1beta1_IngressBackend_To_extensions_IngressBackend,
- autoConvert_v1beta1_IngressList_To_extensions_IngressList,
- autoConvert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue,
- autoConvert_v1beta1_IngressRule_To_extensions_IngressRule,
- autoConvert_v1beta1_IngressSpec_To_extensions_IngressSpec,
- autoConvert_v1beta1_IngressStatus_To_extensions_IngressStatus,
- autoConvert_v1beta1_IngressTLS_To_extensions_IngressTLS,
- autoConvert_v1beta1_Ingress_To_extensions_Ingress,
- autoConvert_v1beta1_JobCondition_To_extensions_JobCondition,
- autoConvert_v1beta1_JobList_To_extensions_JobList,
- autoConvert_v1beta1_JobSpec_To_extensions_JobSpec,
- autoConvert_v1beta1_JobStatus_To_extensions_JobStatus,
- autoConvert_v1beta1_Job_To_extensions_Job,
- autoConvert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
- autoConvert_v1beta1_LabelSelector_To_unversioned_LabelSelector,
- autoConvert_v1beta1_ListOptions_To_api_ListOptions,
- autoConvert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList,
- autoConvert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec,
- autoConvert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy,
- autoConvert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList,
- autoConvert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec,
- autoConvert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus,
- autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet,
- autoConvert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy,
- autoConvert_v1beta1_RollbackConfig_To_extensions_RollbackConfig,
- autoConvert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment,
- autoConvert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions,
- autoConvert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions,
- autoConvert_v1beta1_ScaleSpec_To_extensions_ScaleSpec,
- autoConvert_v1beta1_ScaleStatus_To_extensions_ScaleStatus,
- autoConvert_v1beta1_Scale_To_extensions_Scale,
- autoConvert_v1beta1_SubresourceReference_To_extensions_SubresourceReference,
- autoConvert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList,
- autoConvert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData,
- autoConvert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList,
- autoConvert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go
deleted file mode 100644
index 845e4dd7f5e3f32d884fd88825ec945dd5fcfef6..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go
+++ /dev/null
@@ -1,2060 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1beta1
-
-import (
- time "time"
-
- api "k8s.io/kubernetes/pkg/api"
- resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- v1 "k8s.io/kubernetes/pkg/api/v1"
- conversion "k8s.io/kubernetes/pkg/conversion"
- intstr "k8s.io/kubernetes/pkg/util/intstr"
- inf "speter.net/go/exp/math/dec/inf"
-)
-
-func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error {
- if in.Amount != nil {
- if newVal, err := c.DeepCopy(in.Amount); err != nil {
- return err
- } else {
- out.Amount = newVal.(*inf.Dec)
- }
- } else {
- out.Amount = nil
- }
- out.Format = in.Format
- return nil
-}
-
-func deepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
- out.SelfLink = in.SelfLink
- out.ResourceVersion = in.ResourceVersion
- return nil
-}
-
-func deepCopy_unversioned_Time(in unversioned.Time, out *unversioned.Time, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.Time); err != nil {
- return err
- } else {
- out.Time = newVal.(time.Time)
- }
- return nil
-}
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1_AWSElasticBlockStoreVolumeSource(in v1.AWSElasticBlockStoreVolumeSource, out *v1.AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_AzureFileVolumeSource(in v1.AzureFileVolumeSource, out *v1.AzureFileVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_Capabilities(in v1.Capabilities, out *v1.Capabilities, c *conversion.Cloner) error {
- if in.Add != nil {
- out.Add = make([]v1.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = in.Add[i]
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]v1.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = in.Drop[i]
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func deepCopy_v1_CephFSVolumeSource(in v1.CephFSVolumeSource, out *v1.CephFSVolumeSource, c *conversion.Cloner) error {
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_CinderVolumeSource(in v1.CinderVolumeSource, out *v1.CinderVolumeSource, c *conversion.Cloner) error {
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ConfigMapKeySelector(in v1.ConfigMapKeySelector, out *v1.ConfigMapKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_ConfigMapVolumeSource(in v1.ConfigMapVolumeSource, out *v1.ConfigMapVolumeSource, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]v1.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_KeyToPath(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_Container(in v1.Container, out *v1.Container, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]v1.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := deepCopy_v1_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]v1.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := deepCopy_v1_EnvVar(in.Env[i], &out.Env[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]v1.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := deepCopy_v1_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(v1.Probe)
- if err := deepCopy_v1_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(v1.Probe)
- if err := deepCopy_v1_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- if in.Lifecycle != nil {
- out.Lifecycle = new(v1.Lifecycle)
- if err := deepCopy_v1_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = in.ImagePullPolicy
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.SecurityContext)
- if err := deepCopy_v1_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func deepCopy_v1_ContainerPort(in v1.ContainerPort, out *v1.ContainerPort, c *conversion.Cloner) error {
- out.Name = in.Name
- out.HostPort = in.HostPort
- out.ContainerPort = in.ContainerPort
- out.Protocol = in.Protocol
- out.HostIP = in.HostIP
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeFile(in v1.DownwardAPIVolumeFile, out *v1.DownwardAPIVolumeFile, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_v1_ObjectFieldSelector(in.FieldRef, &out.FieldRef, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_DownwardAPIVolumeSource(in v1.DownwardAPIVolumeSource, out *v1.DownwardAPIVolumeSource, c *conversion.Cloner) error {
- if in.Items != nil {
- out.Items = make([]v1.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1_DownwardAPIVolumeFile(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1_EmptyDirVolumeSource(in v1.EmptyDirVolumeSource, out *v1.EmptyDirVolumeSource, c *conversion.Cloner) error {
- out.Medium = in.Medium
- return nil
-}
-
-func deepCopy_v1_EnvVar(in v1.EnvVar, out *v1.EnvVar, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- if in.ValueFrom != nil {
- out.ValueFrom = new(v1.EnvVarSource)
- if err := deepCopy_v1_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func deepCopy_v1_EnvVarSource(in v1.EnvVarSource, out *v1.EnvVarSource, c *conversion.Cloner) error {
- if in.FieldRef != nil {
- out.FieldRef = new(v1.ObjectFieldSelector)
- if err := deepCopy_v1_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(v1.ConfigMapKeySelector)
- if err := deepCopy_v1_ConfigMapKeySelector(*in.ConfigMapKeyRef, out.ConfigMapKeyRef, c); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(v1.SecretKeySelector)
- if err := deepCopy_v1_SecretKeySelector(*in.SecretKeyRef, out.SecretKeyRef, c); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func deepCopy_v1_ExecAction(in v1.ExecAction, out *v1.ExecAction, c *conversion.Cloner) error {
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func deepCopy_v1_FCVolumeSource(in v1.FCVolumeSource, out *v1.FCVolumeSource, c *conversion.Cloner) error {
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = *in.Lun
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_FlexVolumeSource(in v1.FlexVolumeSource, out *v1.FlexVolumeSource, c *conversion.Cloner) error {
- out.Driver = in.Driver
- out.FSType = in.FSType
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func deepCopy_v1_FlockerVolumeSource(in v1.FlockerVolumeSource, out *v1.FlockerVolumeSource, c *conversion.Cloner) error {
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func deepCopy_v1_GCEPersistentDiskVolumeSource(in v1.GCEPersistentDiskVolumeSource, out *v1.GCEPersistentDiskVolumeSource, c *conversion.Cloner) error {
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = in.Partition
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_GitRepoVolumeSource(in v1.GitRepoVolumeSource, out *v1.GitRepoVolumeSource, c *conversion.Cloner) error {
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func deepCopy_v1_GlusterfsVolumeSource(in v1.GlusterfsVolumeSource, out *v1.GlusterfsVolumeSource, c *conversion.Cloner) error {
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_HTTPGetAction(in v1.HTTPGetAction, out *v1.HTTPGetAction, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = in.Scheme
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]v1.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := deepCopy_v1_HTTPHeader(in.HTTPHeaders[i], &out.HTTPHeaders[i], c); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func deepCopy_v1_HTTPHeader(in v1.HTTPHeader, out *v1.HTTPHeader, c *conversion.Cloner) error {
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func deepCopy_v1_Handler(in v1.Handler, out *v1.Handler, c *conversion.Cloner) error {
- if in.Exec != nil {
- out.Exec = new(v1.ExecAction)
- if err := deepCopy_v1_ExecAction(*in.Exec, out.Exec, c); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- if in.HTTPGet != nil {
- out.HTTPGet = new(v1.HTTPGetAction)
- if err := deepCopy_v1_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- if in.TCPSocket != nil {
- out.TCPSocket = new(v1.TCPSocketAction)
- if err := deepCopy_v1_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func deepCopy_v1_HostPathVolumeSource(in v1.HostPathVolumeSource, out *v1.HostPathVolumeSource, c *conversion.Cloner) error {
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_ISCSIVolumeSource(in v1.ISCSIVolumeSource, out *v1.ISCSIVolumeSource, c *conversion.Cloner) error {
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = in.Lun
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_KeyToPath(in v1.KeyToPath, out *v1.KeyToPath, c *conversion.Cloner) error {
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func deepCopy_v1_Lifecycle(in v1.Lifecycle, out *v1.Lifecycle, c *conversion.Cloner) error {
- if in.PostStart != nil {
- out.PostStart = new(v1.Handler)
- if err := deepCopy_v1_Handler(*in.PostStart, out.PostStart, c); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- if in.PreStop != nil {
- out.PreStop = new(v1.Handler)
- if err := deepCopy_v1_Handler(*in.PreStop, out.PreStop, c); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func deepCopy_v1_LoadBalancerIngress(in v1.LoadBalancerIngress, out *v1.LoadBalancerIngress, c *conversion.Cloner) error {
- out.IP = in.IP
- out.Hostname = in.Hostname
- return nil
-}
-
-func deepCopy_v1_LoadBalancerStatus(in v1.LoadBalancerStatus, out *v1.LoadBalancerStatus, c *conversion.Cloner) error {
- if in.Ingress != nil {
- out.Ingress = make([]v1.LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := deepCopy_v1_LoadBalancerIngress(in.Ingress[i], &out.Ingress[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ingress = nil
- }
- return nil
-}
-
-func deepCopy_v1_LocalObjectReference(in v1.LocalObjectReference, out *v1.LocalObjectReference, c *conversion.Cloner) error {
- out.Name = in.Name
- return nil
-}
-
-func deepCopy_v1_NFSVolumeSource(in v1.NFSVolumeSource, out *v1.NFSVolumeSource, c *conversion.Cloner) error {
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ObjectFieldSelector(in v1.ObjectFieldSelector, out *v1.ObjectFieldSelector, c *conversion.Cloner) error {
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func deepCopy_v1_ObjectMeta(in v1.ObjectMeta, out *v1.ObjectMeta, c *conversion.Cloner) error {
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := deepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
- return err
- }
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil {
- return err
- }
- } else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
- }
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
- }
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
- }
- } else {
- out.Annotations = nil
- }
- return nil
-}
-
-func deepCopy_v1_PersistentVolumeClaimVolumeSource(in v1.PersistentVolumeClaimVolumeSource, out *v1.PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error {
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_PodSecurityContext(in v1.PodSecurityContext, out *v1.PodSecurityContext, c *conversion.Cloner) error {
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.SupplementalGroups != nil {
- out.SupplementalGroups = make([]int64, len(in.SupplementalGroups))
- for i := range in.SupplementalGroups {
- out.SupplementalGroups[i] = in.SupplementalGroups[i]
- }
- } else {
- out.SupplementalGroups = nil
- }
- if in.FSGroup != nil {
- out.FSGroup = new(int64)
- *out.FSGroup = *in.FSGroup
- } else {
- out.FSGroup = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodSpec(in v1.PodSpec, out *v1.PodSpec, c *conversion.Cloner) error {
- if in.Volumes != nil {
- out.Volumes = make([]v1.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := deepCopy_v1_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
- }
- if in.Containers != nil {
- out.Containers = make([]v1.Container, len(in.Containers))
- for i := range in.Containers {
- if err := deepCopy_v1_Container(in.Containers[i], &out.Containers[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Containers = nil
- }
- out.RestartPolicy = in.RestartPolicy
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- out.DNSPolicy = in.DNSPolicy
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
- out.ServiceAccountName = in.ServiceAccountName
- out.DeprecatedServiceAccount = in.DeprecatedServiceAccount
- out.NodeName = in.NodeName
- out.HostNetwork = in.HostNetwork
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if in.SecurityContext != nil {
- out.SecurityContext = new(v1.PodSecurityContext)
- if err := deepCopy_v1_PodSecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]v1.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := deepCopy_v1_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func deepCopy_v1_PodTemplateSpec(in v1.PodTemplateSpec, out *v1.PodTemplateSpec, c *conversion.Cloner) error {
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Probe(in v1.Probe, out *v1.Probe, c *conversion.Cloner) error {
- if err := deepCopy_v1_Handler(in.Handler, &out.Handler, c); err != nil {
- return err
- }
- out.InitialDelaySeconds = in.InitialDelaySeconds
- out.TimeoutSeconds = in.TimeoutSeconds
- out.PeriodSeconds = in.PeriodSeconds
- out.SuccessThreshold = in.SuccessThreshold
- out.FailureThreshold = in.FailureThreshold
- return nil
-}
-
-func deepCopy_v1_RBDVolumeSource(in v1.RBDVolumeSource, out *v1.RBDVolumeSource, c *conversion.Cloner) error {
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- if in.SecretRef != nil {
- out.SecretRef = new(v1.LocalObjectReference)
- if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func deepCopy_v1_ResourceRequirements(in v1.ResourceRequirements, out *v1.ResourceRequirements, c *conversion.Cloner) error {
- if in.Limits != nil {
- out.Limits = make(v1.ResourceList)
- for key, val := range in.Limits {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Limits[key] = *newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(v1.ResourceList)
- for key, val := range in.Requests {
- newVal := new(resource.Quantity)
- if err := deepCopy_resource_Quantity(val, newVal, c); err != nil {
- return err
- }
- out.Requests[key] = *newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func deepCopy_v1_SELinuxOptions(in v1.SELinuxOptions, out *v1.SELinuxOptions, c *conversion.Cloner) error {
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func deepCopy_v1_SecretKeySelector(in v1.SecretKeySelector, out *v1.SecretKeySelector, c *conversion.Cloner) error {
- if err := deepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func deepCopy_v1_SecretVolumeSource(in v1.SecretVolumeSource, out *v1.SecretVolumeSource, c *conversion.Cloner) error {
- out.SecretName = in.SecretName
- return nil
-}
-
-func deepCopy_v1_SecurityContext(in v1.SecurityContext, out *v1.SecurityContext, c *conversion.Cloner) error {
- if in.Capabilities != nil {
- out.Capabilities = new(v1.Capabilities)
- if err := deepCopy_v1_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func deepCopy_v1_TCPSocketAction(in v1.TCPSocketAction, out *v1.TCPSocketAction, c *conversion.Cloner) error {
- if err := deepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_Volume(in v1.Volume, out *v1.Volume, c *conversion.Cloner) error {
- out.Name = in.Name
- if err := deepCopy_v1_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1_VolumeMount(in v1.VolumeMount, out *v1.VolumeMount, c *conversion.Cloner) error {
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func deepCopy_v1_VolumeSource(in v1.VolumeSource, out *v1.VolumeSource, c *conversion.Cloner) error {
- if in.HostPath != nil {
- out.HostPath = new(v1.HostPathVolumeSource)
- if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- if in.EmptyDir != nil {
- out.EmptyDir = new(v1.EmptyDirVolumeSource)
- if err := deepCopy_v1_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(v1.GCEPersistentDiskVolumeSource)
- if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(v1.AWSElasticBlockStoreVolumeSource)
- if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- if in.GitRepo != nil {
- out.GitRepo = new(v1.GitRepoVolumeSource)
- if err := deepCopy_v1_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- if in.Secret != nil {
- out.Secret = new(v1.SecretVolumeSource)
- if err := deepCopy_v1_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- if in.NFS != nil {
- out.NFS = new(v1.NFSVolumeSource)
- if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- if in.ISCSI != nil {
- out.ISCSI = new(v1.ISCSIVolumeSource)
- if err := deepCopy_v1_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- if in.Glusterfs != nil {
- out.Glusterfs = new(v1.GlusterfsVolumeSource)
- if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(v1.PersistentVolumeClaimVolumeSource)
- if err := deepCopy_v1_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaim, out.PersistentVolumeClaim, c); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- if in.RBD != nil {
- out.RBD = new(v1.RBDVolumeSource)
- if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- if in.FlexVolume != nil {
- out.FlexVolume = new(v1.FlexVolumeSource)
- if err := deepCopy_v1_FlexVolumeSource(*in.FlexVolume, out.FlexVolume, c); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- if in.Cinder != nil {
- out.Cinder = new(v1.CinderVolumeSource)
- if err := deepCopy_v1_CinderVolumeSource(*in.Cinder, out.Cinder, c); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- if in.CephFS != nil {
- out.CephFS = new(v1.CephFSVolumeSource)
- if err := deepCopy_v1_CephFSVolumeSource(*in.CephFS, out.CephFS, c); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- if in.Flocker != nil {
- out.Flocker = new(v1.FlockerVolumeSource)
- if err := deepCopy_v1_FlockerVolumeSource(*in.Flocker, out.Flocker, c); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(v1.DownwardAPIVolumeSource)
- if err := deepCopy_v1_DownwardAPIVolumeSource(*in.DownwardAPI, out.DownwardAPI, c); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- if in.FC != nil {
- out.FC = new(v1.FCVolumeSource)
- if err := deepCopy_v1_FCVolumeSource(*in.FC, out.FC, c); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- if in.AzureFile != nil {
- out.AzureFile = new(v1.AzureFileVolumeSource)
- if err := deepCopy_v1_AzureFileVolumeSource(*in.AzureFile, out.AzureFile, c); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- if in.ConfigMap != nil {
- out.ConfigMap = new(v1.ConfigMapVolumeSource)
- if err := deepCopy_v1_ConfigMapVolumeSource(*in.ConfigMap, out.ConfigMap, c); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_APIVersion(in APIVersion, out *APIVersion, c *conversion.Cloner) error {
- out.Name = in.Name
- out.APIGroup = in.APIGroup
- return nil
-}
-
-func deepCopy_v1beta1_CPUTargetUtilization(in CPUTargetUtilization, out *CPUTargetUtilization, c *conversion.Cloner) error {
- out.TargetPercentage = in.TargetPercentage
- return nil
-}
-
-func deepCopy_v1beta1_DaemonSet(in DaemonSet, out *DaemonSet, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_DaemonSetSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_DaemonSetStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_DaemonSetList(in DaemonSetList, out *DaemonSetList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]DaemonSet, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_DaemonSet(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_DaemonSetSpec(in DaemonSetSpec, out *DaemonSetSpec, c *conversion.Cloner) error {
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := deepCopy_v1beta1_LabelSelector(*in.Selector, out.Selector, c); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_DaemonSetStatus(in DaemonSetStatus, out *DaemonSetStatus, c *conversion.Cloner) error {
- out.CurrentNumberScheduled = in.CurrentNumberScheduled
- out.NumberMisscheduled = in.NumberMisscheduled
- out.DesiredNumberScheduled = in.DesiredNumberScheduled
- return nil
-}
-
-func deepCopy_v1beta1_Deployment(in Deployment, out *Deployment, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_DeploymentSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_DeploymentStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_DeploymentList(in DeploymentList, out *DeploymentList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Deployment, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_Deployment(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_DeploymentRollback(in DeploymentRollback, out *DeploymentRollback, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.Name = in.Name
- if in.UpdatedAnnotations != nil {
- out.UpdatedAnnotations = make(map[string]string)
- for key, val := range in.UpdatedAnnotations {
- out.UpdatedAnnotations[key] = val
- }
- } else {
- out.UpdatedAnnotations = nil
- }
- if err := deepCopy_v1beta1_RollbackConfig(in.RollbackTo, &out.RollbackTo, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_DeploymentSpec(in DeploymentSpec, out *DeploymentSpec, c *conversion.Cloner) error {
- if in.Replicas != nil {
- out.Replicas = new(int32)
- *out.Replicas = *in.Replicas
- } else {
- out.Replicas = nil
- }
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := deepCopy_v1beta1_LabelSelector(*in.Selector, out.Selector, c); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_DeploymentStrategy(in.Strategy, &out.Strategy, c); err != nil {
- return err
- }
- out.MinReadySeconds = in.MinReadySeconds
- if in.RevisionHistoryLimit != nil {
- out.RevisionHistoryLimit = new(int32)
- *out.RevisionHistoryLimit = *in.RevisionHistoryLimit
- } else {
- out.RevisionHistoryLimit = nil
- }
- out.Paused = in.Paused
- if in.RollbackTo != nil {
- out.RollbackTo = new(RollbackConfig)
- if err := deepCopy_v1beta1_RollbackConfig(*in.RollbackTo, out.RollbackTo, c); err != nil {
- return err
- }
- } else {
- out.RollbackTo = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_DeploymentStatus(in DeploymentStatus, out *DeploymentStatus, c *conversion.Cloner) error {
- out.ObservedGeneration = in.ObservedGeneration
- out.Replicas = in.Replicas
- out.UpdatedReplicas = in.UpdatedReplicas
- out.AvailableReplicas = in.AvailableReplicas
- out.UnavailableReplicas = in.UnavailableReplicas
- return nil
-}
-
-func deepCopy_v1beta1_DeploymentStrategy(in DeploymentStrategy, out *DeploymentStrategy, c *conversion.Cloner) error {
- out.Type = in.Type
- if in.RollingUpdate != nil {
- out.RollingUpdate = new(RollingUpdateDeployment)
- if err := deepCopy_v1beta1_RollingUpdateDeployment(*in.RollingUpdate, out.RollingUpdate, c); err != nil {
- return err
- }
- } else {
- out.RollingUpdate = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_HTTPIngressPath(in HTTPIngressPath, out *HTTPIngressPath, c *conversion.Cloner) error {
- out.Path = in.Path
- if err := deepCopy_v1beta1_IngressBackend(in.Backend, &out.Backend, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_HTTPIngressRuleValue(in HTTPIngressRuleValue, out *HTTPIngressRuleValue, c *conversion.Cloner) error {
- if in.Paths != nil {
- out.Paths = make([]HTTPIngressPath, len(in.Paths))
- for i := range in.Paths {
- if err := deepCopy_v1beta1_HTTPIngressPath(in.Paths[i], &out.Paths[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Paths = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_HorizontalPodAutoscalerStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]HorizontalPodAutoscaler, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_HorizontalPodAutoscaler(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
- if err := deepCopy_v1beta1_SubresourceReference(in.ScaleRef, &out.ScaleRef, c); err != nil {
- return err
- }
- if in.MinReplicas != nil {
- out.MinReplicas = new(int32)
- *out.MinReplicas = *in.MinReplicas
- } else {
- out.MinReplicas = nil
- }
- out.MaxReplicas = in.MaxReplicas
- if in.CPUUtilization != nil {
- out.CPUUtilization = new(CPUTargetUtilization)
- if err := deepCopy_v1beta1_CPUTargetUtilization(*in.CPUUtilization, out.CPUUtilization, c); err != nil {
- return err
- }
- } else {
- out.CPUUtilization = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
- if in.ObservedGeneration != nil {
- out.ObservedGeneration = new(int64)
- *out.ObservedGeneration = *in.ObservedGeneration
- } else {
- out.ObservedGeneration = nil
- }
- if in.LastScaleTime != nil {
- out.LastScaleTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.LastScaleTime, out.LastScaleTime, c); err != nil {
- return err
- }
- } else {
- out.LastScaleTime = nil
- }
- out.CurrentReplicas = in.CurrentReplicas
- out.DesiredReplicas = in.DesiredReplicas
- if in.CurrentCPUUtilizationPercentage != nil {
- out.CurrentCPUUtilizationPercentage = new(int32)
- *out.CurrentCPUUtilizationPercentage = *in.CurrentCPUUtilizationPercentage
- } else {
- out.CurrentCPUUtilizationPercentage = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_HostPortRange(in HostPortRange, out *HostPortRange, c *conversion.Cloner) error {
- out.Min = in.Min
- out.Max = in.Max
- return nil
-}
-
-func deepCopy_v1beta1_IDRange(in IDRange, out *IDRange, c *conversion.Cloner) error {
- out.Min = in.Min
- out.Max = in.Max
- return nil
-}
-
-func deepCopy_v1beta1_Ingress(in Ingress, out *Ingress, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_IngressSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_IngressStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressBackend(in IngressBackend, out *IngressBackend, c *conversion.Cloner) error {
- out.ServiceName = in.ServiceName
- if err := deepCopy_intstr_IntOrString(in.ServicePort, &out.ServicePort, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressList(in IngressList, out *IngressList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Ingress, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_Ingress(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error {
- out.Host = in.Host
- if err := deepCopy_v1beta1_IngressRuleValue(in.IngressRuleValue, &out.IngressRuleValue, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressRuleValue(in IngressRuleValue, out *IngressRuleValue, c *conversion.Cloner) error {
- if in.HTTP != nil {
- out.HTTP = new(HTTPIngressRuleValue)
- if err := deepCopy_v1beta1_HTTPIngressRuleValue(*in.HTTP, out.HTTP, c); err != nil {
- return err
- }
- } else {
- out.HTTP = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressSpec(in IngressSpec, out *IngressSpec, c *conversion.Cloner) error {
- if in.Backend != nil {
- out.Backend = new(IngressBackend)
- if err := deepCopy_v1beta1_IngressBackend(*in.Backend, out.Backend, c); err != nil {
- return err
- }
- } else {
- out.Backend = nil
- }
- if in.TLS != nil {
- out.TLS = make([]IngressTLS, len(in.TLS))
- for i := range in.TLS {
- if err := deepCopy_v1beta1_IngressTLS(in.TLS[i], &out.TLS[i], c); err != nil {
- return err
- }
- }
- } else {
- out.TLS = nil
- }
- if in.Rules != nil {
- out.Rules = make([]IngressRule, len(in.Rules))
- for i := range in.Rules {
- if err := deepCopy_v1beta1_IngressRule(in.Rules[i], &out.Rules[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Rules = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressStatus(in IngressStatus, out *IngressStatus, c *conversion.Cloner) error {
- if err := deepCopy_v1_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_IngressTLS(in IngressTLS, out *IngressTLS, c *conversion.Cloner) error {
- if in.Hosts != nil {
- out.Hosts = make([]string, len(in.Hosts))
- for i := range in.Hosts {
- out.Hosts[i] = in.Hosts[i]
- }
- } else {
- out.Hosts = nil
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func deepCopy_v1beta1_Job(in Job, out *Job, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_JobSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_JobStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
- out.Type = in.Type
- out.Status = in.Status
- if err := deepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func deepCopy_v1beta1_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Job, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_Job(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
- if in.Parallelism != nil {
- out.Parallelism = new(int32)
- *out.Parallelism = *in.Parallelism
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int32)
- *out.Completions = *in.Completions
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := deepCopy_v1beta1_LabelSelector(*in.Selector, out.Selector, c); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if in.AutoSelector != nil {
- out.AutoSelector = new(bool)
- *out.AutoSelector = *in.AutoSelector
- } else {
- out.AutoSelector = nil
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
- if in.Conditions != nil {
- out.Conditions = make([]JobCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := deepCopy_v1beta1_JobCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.StartTime, out.StartTime, c); err != nil {
- return err
- }
- } else {
- out.StartTime = nil
- }
- if in.CompletionTime != nil {
- out.CompletionTime = new(unversioned.Time)
- if err := deepCopy_unversioned_Time(*in.CompletionTime, out.CompletionTime, c); err != nil {
- return err
- }
- } else {
- out.CompletionTime = nil
- }
- out.Active = in.Active
- out.Succeeded = in.Succeeded
- out.Failed = in.Failed
- return nil
-}
-
-func deepCopy_v1beta1_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
- if in.MatchLabels != nil {
- out.MatchLabels = make(map[string]string)
- for key, val := range in.MatchLabels {
- out.MatchLabels[key] = val
- }
- } else {
- out.MatchLabels = nil
- }
- if in.MatchExpressions != nil {
- out.MatchExpressions = make([]LabelSelectorRequirement, len(in.MatchExpressions))
- for i := range in.MatchExpressions {
- if err := deepCopy_v1beta1_LabelSelectorRequirement(in.MatchExpressions[i], &out.MatchExpressions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.MatchExpressions = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
- out.Key = in.Key
- out.Operator = in.Operator
- if in.Values != nil {
- out.Values = make([]string, len(in.Values))
- for i := range in.Values {
- out.Values[i] = in.Values[i]
- }
- } else {
- out.Values = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- out.LabelSelector = in.LabelSelector
- out.FieldSelector = in.FieldSelector
- out.Watch = in.Watch
- out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_PodSecurityPolicy(in PodSecurityPolicy, out *PodSecurityPolicy, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_PodSecurityPolicySpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_PodSecurityPolicyList(in PodSecurityPolicyList, out *PodSecurityPolicyList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]PodSecurityPolicy, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_PodSecurityPolicy(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_PodSecurityPolicySpec(in PodSecurityPolicySpec, out *PodSecurityPolicySpec, c *conversion.Cloner) error {
- out.Privileged = in.Privileged
- if in.Capabilities != nil {
- out.Capabilities = make([]v1.Capability, len(in.Capabilities))
- for i := range in.Capabilities {
- out.Capabilities[i] = in.Capabilities[i]
- }
- } else {
- out.Capabilities = nil
- }
- if in.Volumes != nil {
- out.Volumes = make([]FSType, len(in.Volumes))
- for i := range in.Volumes {
- out.Volumes[i] = in.Volumes[i]
- }
- } else {
- out.Volumes = nil
- }
- out.HostNetwork = in.HostNetwork
- if in.HostPorts != nil {
- out.HostPorts = make([]HostPortRange, len(in.HostPorts))
- for i := range in.HostPorts {
- if err := deepCopy_v1beta1_HostPortRange(in.HostPorts[i], &out.HostPorts[i], c); err != nil {
- return err
- }
- }
- } else {
- out.HostPorts = nil
- }
- out.HostPID = in.HostPID
- out.HostIPC = in.HostIPC
- if err := deepCopy_v1beta1_SELinuxStrategyOptions(in.SELinux, &out.SELinux, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_RunAsUserStrategyOptions(in.RunAsUser, &out.RunAsUser, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_ReplicaSet(in ReplicaSet, out *ReplicaSet, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_ReplicaSetSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_ReplicaSetStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_ReplicaSetList(in ReplicaSetList, out *ReplicaSetList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ReplicaSet, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_ReplicaSet(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_ReplicaSetSpec(in ReplicaSetSpec, out *ReplicaSetSpec, c *conversion.Cloner) error {
- if in.Replicas != nil {
- out.Replicas = new(int32)
- *out.Replicas = *in.Replicas
- } else {
- out.Replicas = nil
- }
- if in.Selector != nil {
- out.Selector = new(LabelSelector)
- if err := deepCopy_v1beta1_LabelSelector(*in.Selector, out.Selector, c); err != nil {
- return err
- }
- } else {
- out.Selector = nil
- }
- if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_ReplicaSetStatus(in ReplicaSetStatus, out *ReplicaSetStatus, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- out.FullyLabeledReplicas = in.FullyLabeledReplicas
- out.ObservedGeneration = in.ObservedGeneration
- return nil
-}
-
-func deepCopy_v1beta1_ReplicationControllerDummy(in ReplicationControllerDummy, out *ReplicationControllerDummy, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_RollbackConfig(in RollbackConfig, out *RollbackConfig, c *conversion.Cloner) error {
- out.Revision = in.Revision
- return nil
-}
-
-func deepCopy_v1beta1_RollingUpdateDeployment(in RollingUpdateDeployment, out *RollingUpdateDeployment, c *conversion.Cloner) error {
- if in.MaxUnavailable != nil {
- out.MaxUnavailable = new(intstr.IntOrString)
- if err := deepCopy_intstr_IntOrString(*in.MaxUnavailable, out.MaxUnavailable, c); err != nil {
- return err
- }
- } else {
- out.MaxUnavailable = nil
- }
- if in.MaxSurge != nil {
- out.MaxSurge = new(intstr.IntOrString)
- if err := deepCopy_intstr_IntOrString(*in.MaxSurge, out.MaxSurge, c); err != nil {
- return err
- }
- } else {
- out.MaxSurge = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_RunAsUserStrategyOptions(in RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, c *conversion.Cloner) error {
- out.Rule = in.Rule
- if in.Ranges != nil {
- out.Ranges = make([]IDRange, len(in.Ranges))
- for i := range in.Ranges {
- if err := deepCopy_v1beta1_IDRange(in.Ranges[i], &out.Ranges[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Ranges = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_SELinuxStrategyOptions(in SELinuxStrategyOptions, out *SELinuxStrategyOptions, c *conversion.Cloner) error {
- out.Rule = in.Rule
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(v1.SELinuxOptions)
- if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
- return err
- }
- if err := deepCopy_v1beta1_ScaleStatus(in.Status, &out.Status, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1beta1_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- return nil
-}
-
-func deepCopy_v1beta1_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
- out.Replicas = in.Replicas
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
- out.TargetSelector = in.TargetSelector
- return nil
-}
-
-func deepCopy_v1beta1_SubresourceReference(in SubresourceReference, out *SubresourceReference, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.Name = in.Name
- out.APIVersion = in.APIVersion
- out.Subresource = in.Subresource
- return nil
-}
-
-func deepCopy_v1beta1_ThirdPartyResource(in ThirdPartyResource, out *ThirdPartyResource, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- out.Description = in.Description
- if in.Versions != nil {
- out.Versions = make([]APIVersion, len(in.Versions))
- for i := range in.Versions {
- if err := deepCopy_v1beta1_APIVersion(in.Versions[i], &out.Versions[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Versions = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_ThirdPartyResourceData(in ThirdPartyResourceData, out *ThirdPartyResourceData, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
- return err
- }
- if in.Data != nil {
- out.Data = make([]uint8, len(in.Data))
- for i := range in.Data {
- out.Data[i] = in.Data[i]
- }
- } else {
- out.Data = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_ThirdPartyResourceDataList(in ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ThirdPartyResourceData, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_ThirdPartyResourceData(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_v1beta1_ThirdPartyResourceList(in ThirdPartyResourceList, out *ThirdPartyResourceList, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- if err := deepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ThirdPartyResource, len(in.Items))
- for i := range in.Items {
- if err := deepCopy_v1beta1_ThirdPartyResource(in.Items[i], &out.Items[i], c); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func deepCopy_intstr_IntOrString(in intstr.IntOrString, out *intstr.IntOrString, c *conversion.Cloner) error {
- out.Type = in.Type
- out.IntVal = in.IntVal
- out.StrVal = in.StrVal
- return nil
-}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_resource_Quantity,
- deepCopy_unversioned_ListMeta,
- deepCopy_unversioned_Time,
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1_AWSElasticBlockStoreVolumeSource,
- deepCopy_v1_AzureFileVolumeSource,
- deepCopy_v1_Capabilities,
- deepCopy_v1_CephFSVolumeSource,
- deepCopy_v1_CinderVolumeSource,
- deepCopy_v1_ConfigMapKeySelector,
- deepCopy_v1_ConfigMapVolumeSource,
- deepCopy_v1_Container,
- deepCopy_v1_ContainerPort,
- deepCopy_v1_DownwardAPIVolumeFile,
- deepCopy_v1_DownwardAPIVolumeSource,
- deepCopy_v1_EmptyDirVolumeSource,
- deepCopy_v1_EnvVar,
- deepCopy_v1_EnvVarSource,
- deepCopy_v1_ExecAction,
- deepCopy_v1_FCVolumeSource,
- deepCopy_v1_FlexVolumeSource,
- deepCopy_v1_FlockerVolumeSource,
- deepCopy_v1_GCEPersistentDiskVolumeSource,
- deepCopy_v1_GitRepoVolumeSource,
- deepCopy_v1_GlusterfsVolumeSource,
- deepCopy_v1_HTTPGetAction,
- deepCopy_v1_HTTPHeader,
- deepCopy_v1_Handler,
- deepCopy_v1_HostPathVolumeSource,
- deepCopy_v1_ISCSIVolumeSource,
- deepCopy_v1_KeyToPath,
- deepCopy_v1_Lifecycle,
- deepCopy_v1_LoadBalancerIngress,
- deepCopy_v1_LoadBalancerStatus,
- deepCopy_v1_LocalObjectReference,
- deepCopy_v1_NFSVolumeSource,
- deepCopy_v1_ObjectFieldSelector,
- deepCopy_v1_ObjectMeta,
- deepCopy_v1_PersistentVolumeClaimVolumeSource,
- deepCopy_v1_PodSecurityContext,
- deepCopy_v1_PodSpec,
- deepCopy_v1_PodTemplateSpec,
- deepCopy_v1_Probe,
- deepCopy_v1_RBDVolumeSource,
- deepCopy_v1_ResourceRequirements,
- deepCopy_v1_SELinuxOptions,
- deepCopy_v1_SecretKeySelector,
- deepCopy_v1_SecretVolumeSource,
- deepCopy_v1_SecurityContext,
- deepCopy_v1_TCPSocketAction,
- deepCopy_v1_Volume,
- deepCopy_v1_VolumeMount,
- deepCopy_v1_VolumeSource,
- deepCopy_v1beta1_APIVersion,
- deepCopy_v1beta1_CPUTargetUtilization,
- deepCopy_v1beta1_DaemonSet,
- deepCopy_v1beta1_DaemonSetList,
- deepCopy_v1beta1_DaemonSetSpec,
- deepCopy_v1beta1_DaemonSetStatus,
- deepCopy_v1beta1_Deployment,
- deepCopy_v1beta1_DeploymentList,
- deepCopy_v1beta1_DeploymentRollback,
- deepCopy_v1beta1_DeploymentSpec,
- deepCopy_v1beta1_DeploymentStatus,
- deepCopy_v1beta1_DeploymentStrategy,
- deepCopy_v1beta1_HTTPIngressPath,
- deepCopy_v1beta1_HTTPIngressRuleValue,
- deepCopy_v1beta1_HorizontalPodAutoscaler,
- deepCopy_v1beta1_HorizontalPodAutoscalerList,
- deepCopy_v1beta1_HorizontalPodAutoscalerSpec,
- deepCopy_v1beta1_HorizontalPodAutoscalerStatus,
- deepCopy_v1beta1_HostPortRange,
- deepCopy_v1beta1_IDRange,
- deepCopy_v1beta1_Ingress,
- deepCopy_v1beta1_IngressBackend,
- deepCopy_v1beta1_IngressList,
- deepCopy_v1beta1_IngressRule,
- deepCopy_v1beta1_IngressRuleValue,
- deepCopy_v1beta1_IngressSpec,
- deepCopy_v1beta1_IngressStatus,
- deepCopy_v1beta1_IngressTLS,
- deepCopy_v1beta1_Job,
- deepCopy_v1beta1_JobCondition,
- deepCopy_v1beta1_JobList,
- deepCopy_v1beta1_JobSpec,
- deepCopy_v1beta1_JobStatus,
- deepCopy_v1beta1_LabelSelector,
- deepCopy_v1beta1_LabelSelectorRequirement,
- deepCopy_v1beta1_ListOptions,
- deepCopy_v1beta1_PodSecurityPolicy,
- deepCopy_v1beta1_PodSecurityPolicyList,
- deepCopy_v1beta1_PodSecurityPolicySpec,
- deepCopy_v1beta1_ReplicaSet,
- deepCopy_v1beta1_ReplicaSetList,
- deepCopy_v1beta1_ReplicaSetSpec,
- deepCopy_v1beta1_ReplicaSetStatus,
- deepCopy_v1beta1_ReplicationControllerDummy,
- deepCopy_v1beta1_RollbackConfig,
- deepCopy_v1beta1_RollingUpdateDeployment,
- deepCopy_v1beta1_RunAsUserStrategyOptions,
- deepCopy_v1beta1_SELinuxStrategyOptions,
- deepCopy_v1beta1_Scale,
- deepCopy_v1beta1_ScaleSpec,
- deepCopy_v1beta1_ScaleStatus,
- deepCopy_v1beta1_SubresourceReference,
- deepCopy_v1beta1_ThirdPartyResource,
- deepCopy_v1beta1_ThirdPartyResourceData,
- deepCopy_v1beta1_ThirdPartyResourceDataList,
- deepCopy_v1beta1_ThirdPartyResourceList,
- deepCopy_intstr_IntOrString,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go
deleted file mode 100644
index 46d4c3785b02ba35a79beb12a5b2b150e4b119bf..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 v1beta1
-
-import (
- "k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/util/intstr"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) {
- scheme.AddDefaultingFuncs(
- func(obj *APIVersion) {
- if len(obj.APIGroup) == 0 {
- obj.APIGroup = GroupName
- }
- },
- func(obj *DaemonSet) {
- labels := obj.Spec.Template.Labels
-
- // TODO: support templates defined elsewhere when we support them in the API
- if labels != nil {
- if obj.Spec.Selector == nil {
- obj.Spec.Selector = &LabelSelector{
- MatchLabels: labels,
- }
- }
- if len(obj.Labels) == 0 {
- obj.Labels = labels
- }
- }
- },
- func(obj *Deployment) {
- // Default labels and selector to labels from pod template spec.
- labels := obj.Spec.Template.Labels
-
- if labels != nil {
- if obj.Spec.Selector == nil {
- obj.Spec.Selector = &LabelSelector{MatchLabels: labels}
- }
- if len(obj.Labels) == 0 {
- obj.Labels = labels
- }
- }
- // Set DeploymentSpec.Replicas to 1 if it is not set.
- if obj.Spec.Replicas == nil {
- obj.Spec.Replicas = new(int32)
- *obj.Spec.Replicas = 1
- }
- strategy := &obj.Spec.Strategy
- // Set default DeploymentStrategyType as RollingUpdate.
- if strategy.Type == "" {
- strategy.Type = RollingUpdateDeploymentStrategyType
- }
- if strategy.Type == RollingUpdateDeploymentStrategyType {
- if strategy.RollingUpdate == nil {
- rollingUpdate := RollingUpdateDeployment{}
- strategy.RollingUpdate = &rollingUpdate
- }
- if strategy.RollingUpdate.MaxUnavailable == nil {
- // Set default MaxUnavailable as 1 by default.
- maxUnavailable := intstr.FromInt(1)
- strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
- }
- if strategy.RollingUpdate.MaxSurge == nil {
- // Set default MaxSurge as 1 by default.
- maxSurge := intstr.FromInt(1)
- strategy.RollingUpdate.MaxSurge = &maxSurge
- }
- }
- },
- func(obj *Job) {
- labels := obj.Spec.Template.Labels
- // TODO: support templates defined elsewhere when we support them in the API
- if labels != nil {
- // if an autoselector is requested, we'll build the selector later with controller-uid and job-name
- autoSelector := bool(obj.Spec.AutoSelector != nil && *obj.Spec.AutoSelector)
-
- // otherwise, we are using a manual selector
- manualSelector := !autoSelector
-
- // and default behavior for an unspecified manual selector is to use the pod template labels
- if manualSelector && obj.Spec.Selector == nil {
- obj.Spec.Selector = &LabelSelector{
- MatchLabels: labels,
- }
- }
- if len(obj.Labels) == 0 {
- obj.Labels = labels
- }
- }
- // For a non-parallel job, you can leave both `.spec.completions` and
- // `.spec.parallelism` unset. When both are unset, both are defaulted to 1.
- if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
- obj.Spec.Completions = new(int32)
- *obj.Spec.Completions = 1
- obj.Spec.Parallelism = new(int32)
- *obj.Spec.Parallelism = 1
- }
- if obj.Spec.Parallelism == nil {
- obj.Spec.Parallelism = new(int32)
- *obj.Spec.Parallelism = 1
- }
- },
- func(obj *HorizontalPodAutoscaler) {
- if obj.Spec.MinReplicas == nil {
- minReplicas := int32(1)
- obj.Spec.MinReplicas = &minReplicas
- }
- if obj.Spec.CPUUtilization == nil {
- obj.Spec.CPUUtilization = &CPUTargetUtilization{TargetPercentage: 80}
- }
- },
- func(obj *ReplicaSet) {
- labels := obj.Spec.Template.Labels
-
- // TODO: support templates defined elsewhere when we support them in the API
- if labels != nil {
- if obj.Spec.Selector == nil {
- obj.Spec.Selector = &LabelSelector{
- MatchLabels: labels,
- }
- }
- if len(obj.Labels) == 0 {
- obj.Labels = labels
- }
- }
- if obj.Spec.Replicas == nil {
- obj.Spec.Replicas = new(int32)
- *obj.Spec.Replicas = 1
- }
- },
- )
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go
deleted file mode 100644
index 026a9f6810ccc000da175d974467226132f82423..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 v1beta1
-
-import (
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/api/v1"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-// GroupName is the group name use in this package
-const GroupName = "extensions"
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1beta1"}
-
-func AddToScheme(scheme *runtime.Scheme) {
- addKnownTypes(scheme)
- addDefaultingFuncs(scheme)
- addConversionFuncs(scheme)
-}
-
-// Adds the list of known types to api.Scheme.
-func addKnownTypes(scheme *runtime.Scheme) {
- scheme.AddKnownTypes(SchemeGroupVersion,
- &Deployment{},
- &DeploymentList{},
- &DeploymentRollback{},
- &HorizontalPodAutoscaler{},
- &HorizontalPodAutoscalerList{},
- &Job{},
- &JobList{},
- &ReplicationControllerDummy{},
- &Scale{},
- &ThirdPartyResource{},
- &ThirdPartyResourceList{},
- &DaemonSetList{},
- &DaemonSet{},
- &ThirdPartyResourceData{},
- &ThirdPartyResourceDataList{},
- &Ingress{},
- &IngressList{},
- &ListOptions{},
- &v1.DeleteOptions{},
- &ReplicaSet{},
- &ReplicaSetList{},
- &PodSecurityPolicy{},
- &PodSecurityPolicyList{},
- )
-}
-
-func (obj *Deployment) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeploymentList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DeploymentRollback) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *HorizontalPodAutoscaler) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *HorizontalPodAutoscalerList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Job) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *JobList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicationControllerDummy) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Scale) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResource) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DaemonSet) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *DaemonSetList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceData) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ThirdPartyResourceDataList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Ingress) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *IngressList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ListOptions) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicaSet) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *ReplicaSetList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodSecurityPolicy) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *PodSecurityPolicyList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/deep_copy_generated.go
deleted file mode 100644
index e7562de5221e96f4a251e887cb4bddd7ae54c2e6..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/deep_copy_generated.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package metrics
-
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.generated.go
deleted file mode 100644
index ecf3e8b36f28afa43c7d26e48d4f6f1298ed288c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.generated.go
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED BY codecgen.
-// ************************************************************
-
-package metrics
-
-import (
- "errors"
- "fmt"
- codec1978 "github.com/ugorji/go/codec"
- pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- "reflect"
- "runtime"
-)
-
-const (
- // ----- content types ----
- codecSelferC_UTF81234 = 1
- codecSelferC_RAW1234 = 0
- // ----- value types used ----
- codecSelferValueTypeArray1234 = 10
- codecSelferValueTypeMap1234 = 9
- // ----- containerStateValues ----
- codecSelfer_containerMapKey1234 = 2
- codecSelfer_containerMapValue1234 = 3
- codecSelfer_containerMapEnd1234 = 4
- codecSelfer_containerArrayElem1234 = 6
- codecSelfer_containerArrayEnd1234 = 7
-)
-
-var (
- codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
- codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
-)
-
-type codecSelfer1234 struct{}
-
-func init() {
- if codec1978.GenVersion != 5 {
- _, file, _, _ := runtime.Caller(0)
- err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
- 5, codec1978.GenVersion, file)
- panic(err)
- }
- if false { // reference the types, but skip this branch at build/run time
- var v0 pkg1_unversioned.TypeMeta
- _ = v0
- }
-}
-
-func (x *RawNode) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Kind != ""
- yyq2[1] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *RawNode) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *RawNode) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *RawNode) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *RawPod) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Kind != ""
- yyq2[1] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *RawPod) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *RawPod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *RawPod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/conversion_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/conversion_generated.go
deleted file mode 100644
index 928d2ca5740d1a98ce0ca2b5bd1beb3719019153..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/conversion_generated.go
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
-
-package v1alpha1
-
-import (
- reflect "reflect"
-
- api "k8s.io/kubernetes/pkg/api"
- metrics "k8s.io/kubernetes/pkg/apis/metrics"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func autoConvert_metrics_RawNode_To_v1alpha1_RawNode(in *metrics.RawNode, out *RawNode, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*metrics.RawNode))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_metrics_RawNode_To_v1alpha1_RawNode(in *metrics.RawNode, out *RawNode, s conversion.Scope) error {
- return autoConvert_metrics_RawNode_To_v1alpha1_RawNode(in, out, s)
-}
-
-func autoConvert_metrics_RawPod_To_v1alpha1_RawPod(in *metrics.RawPod, out *RawPod, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*metrics.RawPod))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_metrics_RawPod_To_v1alpha1_RawPod(in *metrics.RawPod, out *RawPod, s conversion.Scope) error {
- return autoConvert_metrics_RawPod_To_v1alpha1_RawPod(in, out, s)
-}
-
-func autoConvert_v1alpha1_RawNode_To_metrics_RawNode(in *RawNode, out *metrics.RawNode, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RawNode))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1alpha1_RawNode_To_metrics_RawNode(in *RawNode, out *metrics.RawNode, s conversion.Scope) error {
- return autoConvert_v1alpha1_RawNode_To_metrics_RawNode(in, out, s)
-}
-
-func autoConvert_v1alpha1_RawPod_To_metrics_RawPod(in *RawPod, out *metrics.RawPod, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RawPod))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1alpha1_RawPod_To_metrics_RawPod(in *RawPod, out *metrics.RawPod, s conversion.Scope) error {
- return autoConvert_v1alpha1_RawPod_To_metrics_RawPod(in, out, s)
-}
-
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_metrics_RawNode_To_v1alpha1_RawNode,
- autoConvert_metrics_RawPod_To_v1alpha1_RawPod,
- autoConvert_v1alpha1_RawNode_To_metrics_RawNode,
- autoConvert_v1alpha1_RawPod_To_metrics_RawPod,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/deep_copy_generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/deep_copy_generated.go
deleted file mode 100644
index d235d1a480bc9ef99c3fe803dad4845ff20b0cbf..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/deep_copy_generated.go
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
-
-package v1alpha1
-
-import (
- api "k8s.io/kubernetes/pkg/api"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- conversion "k8s.io/kubernetes/pkg/conversion"
-)
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
-}
-
-func deepCopy_v1alpha1_RawNode(in RawNode, out *RawNode, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- return nil
-}
-
-func deepCopy_v1alpha1_RawPod(in RawPod, out *RawPod, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
- return err
- }
- return nil
-}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1alpha1_RawNode,
- deepCopy_v1alpha1_RawPod,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.generated.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.generated.go
deleted file mode 100644
index 2e6d2f3c187e7ebe7ec3ad3db6d6b28b6cec43b2..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.generated.go
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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.
-*/
-
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED BY codecgen.
-// ************************************************************
-
-package v1alpha1
-
-import (
- "errors"
- "fmt"
- codec1978 "github.com/ugorji/go/codec"
- pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- "reflect"
- "runtime"
-)
-
-const (
- // ----- content types ----
- codecSelferC_UTF81234 = 1
- codecSelferC_RAW1234 = 0
- // ----- value types used ----
- codecSelferValueTypeArray1234 = 10
- codecSelferValueTypeMap1234 = 9
- // ----- containerStateValues ----
- codecSelfer_containerMapKey1234 = 2
- codecSelfer_containerMapValue1234 = 3
- codecSelfer_containerMapEnd1234 = 4
- codecSelfer_containerArrayElem1234 = 6
- codecSelfer_containerArrayEnd1234 = 7
-)
-
-var (
- codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
- codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
-)
-
-type codecSelfer1234 struct{}
-
-func init() {
- if codec1978.GenVersion != 5 {
- _, file, _, _ := runtime.Caller(0)
- err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
- 5, codec1978.GenVersion, file)
- panic(err)
- }
- if false { // reference the types, but skip this branch at build/run time
- var v0 pkg1_unversioned.TypeMeta
- _ = v0
- }
-}
-
-func (x *RawNode) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Kind != ""
- yyq2[1] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *RawNode) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *RawNode) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *RawNode) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *RawPod) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Kind != ""
- yyq2[1] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
- } else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *RawPod) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *RawPod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *RawPod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go
deleted file mode 100644
index a4efc232a41a5a8f0dd6cef72ccd409150159148..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 unversioned
-
-import (
- "k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/apis/extensions"
- "k8s.io/kubernetes/pkg/watch"
-)
-
-// HorizontalPodAutoscalersNamespacer has methods to work with HorizontalPodAutoscaler resources in a namespace
-type HorizontalPodAutoscalersNamespacer interface {
- HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface
-}
-
-// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources.
-type HorizontalPodAutoscalerInterface interface {
- List(opts api.ListOptions) (*extensions.HorizontalPodAutoscalerList, error)
- Get(name string) (*extensions.HorizontalPodAutoscaler, error)
- Delete(name string, options *api.DeleteOptions) error
- Create(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
- Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
- UpdateStatus(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
- Watch(opts api.ListOptions) (watch.Interface, error)
-}
-
-// horizontalPodAutoscalers implements HorizontalPodAutoscalersNamespacer interface
-type horizontalPodAutoscalers struct {
- client *ExtensionsClient
- ns string
-}
-
-// newHorizontalPodAutoscalers returns a horizontalPodAutoscalers
-func newHorizontalPodAutoscalers(c *ExtensionsClient, namespace string) *horizontalPodAutoscalers {
- return &horizontalPodAutoscalers{
- client: c,
- ns: namespace,
- }
-}
-
-// List takes label and field selectors, and returns the list of horizontalPodAutoscalers that match those selectors.
-func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *extensions.HorizontalPodAutoscalerList, err error) {
- result = &extensions.HorizontalPodAutoscalerList{}
- err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
- return
-}
-
-// Get takes the name of the horizontalPodAutoscaler, and returns the corresponding HorizontalPodAutoscaler object, and an error if it occurs
-func (c *horizontalPodAutoscalers) Get(name string) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Do().Into(result)
- return
-}
-
-// Delete takes the name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
-func (c *horizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
- return c.client.Delete().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Body(options).Do().Error()
-}
-
-// Create takes the representation of a horizontalPodAutoscaler and creates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Post().Namespace(c.ns).Resource("horizontalPodAutoscalers").Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// UpdateStatus takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).SubResource("status").Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
-func (c *horizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
- return c.client.Get().
- Prefix("watch").
- Namespace(c.ns).
- Resource("horizontalPodAutoscalers").
- VersionedParams(&opts, api.ParameterCodec).
- Watch()
-}
-
-// horizontalPodAutoscalersV1 implements HorizontalPodAutoscalersNamespacer interface using AutoscalingClient internally
-// TODO(piosz): get back to one client implementation once HPA will be graduated to GA completely
-type horizontalPodAutoscalersV1 struct {
- client *AutoscalingClient
- ns string
-}
-
-// newHorizontalPodAutoscalers returns a horizontalPodAutoscalers
-func newHorizontalPodAutoscalersV1(c *AutoscalingClient, namespace string) *horizontalPodAutoscalersV1 {
- return &horizontalPodAutoscalersV1{
- client: c,
- ns: namespace,
- }
-}
-
-// List takes label and field selectors, and returns the list of horizontalPodAutoscalers that match those selectors.
-func (c *horizontalPodAutoscalersV1) List(opts api.ListOptions) (result *extensions.HorizontalPodAutoscalerList, err error) {
- result = &extensions.HorizontalPodAutoscalerList{}
- err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
- return
-}
-
-// Get takes the name of the horizontalPodAutoscaler, and returns the corresponding HorizontalPodAutoscaler object, and an error if it occurs
-func (c *horizontalPodAutoscalersV1) Get(name string) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Do().Into(result)
- return
-}
-
-// Delete takes the name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
-func (c *horizontalPodAutoscalersV1) Delete(name string, options *api.DeleteOptions) error {
- return c.client.Delete().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Body(options).Do().Error()
-}
-
-// Create takes the representation of a horizontalPodAutoscaler and creates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalersV1) Create(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Post().Namespace(c.ns).Resource("horizontalPodAutoscalers").Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalersV1) Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// UpdateStatus takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
-func (c *horizontalPodAutoscalersV1) UpdateStatus(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
- err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).SubResource("status").Body(horizontalPodAutoscaler).Do().Into(result)
- return
-}
-
-// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
-func (c *horizontalPodAutoscalersV1) Watch(opts api.ListOptions) (watch.Interface, error) {
- return c.client.Get().
- Prefix("watch").
- Namespace(c.ns).
- Resource("horizontalPodAutoscalers").
- VersionedParams(&opts, api.ParameterCodec).
- Watch()
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go
deleted file mode 100644
index 88c8a3131c4539665e7019ec35f9a96b4dc5c794..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 fieldpath
-
-import (
- "fmt"
-
- "k8s.io/kubernetes/pkg/api/meta"
-)
-
-// formatMap formats map[string]string to a string.
-func formatMap(m map[string]string) (fmtStr string) {
- for key, value := range m {
- fmtStr += fmt.Sprintf("%v=%q\n", key, value)
- }
-
- return
-}
-
-// ExtractFieldPathAsString extracts the field from the given object
-// and returns it as a string. The object must be a pointer to an
-// API type.
-//
-// Currently, this API is limited to supporting the fieldpaths:
-//
-// 1. metadata.name - The name of an API object
-// 2. metadata.namespace - The namespace of an API object
-func ExtractFieldPathAsString(obj interface{}, fieldPath string) (string, error) {
- accessor, err := meta.Accessor(obj)
- if err != nil {
- return "", nil
- }
-
- switch fieldPath {
- case "metadata.annotations":
- return formatMap(accessor.GetAnnotations()), nil
- case "metadata.labels":
- return formatMap(accessor.GetLabels()), nil
- case "metadata.name":
- return accessor.GetName(), nil
- case "metadata.namespace":
- return accessor.GetNamespace(), nil
- }
-
- return "", fmt.Errorf("Unsupported fieldPath: %v", fieldPath)
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go
deleted file mode 100644
index b785ab676f4099300cf8f444e8a0bff7b6709b87..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 qos
-
-import (
- "k8s.io/kubernetes/pkg/api"
-)
-
-const (
- PodInfraOOMAdj int = -999
- KubeletOOMScoreAdj int = -999
- KubeProxyOOMScoreAdj int = -999
-)
-
-// isMemoryBestEffort returns true if the container's memory requirements are best-effort.
-func isMemoryBestEffort(container *api.Container) bool {
- // A container is memory best-effort if its memory request is unspecified or 0.
- // If a request is specified, then the user expects some kind of resource guarantee.
- return container.Resources.Requests.Memory().Value() == 0
-}
-
-// isMemoryGuaranteed returns true if the container's memory requirements are Guaranteed.
-func isMemoryGuaranteed(container *api.Container) bool {
- // A container is memory guaranteed if its memory request == memory limit.
- // If memory request == memory limit, the user is very confident of resource consumption.
- memoryRequest := container.Resources.Requests.Memory()
- memoryLimit := container.Resources.Limits.Memory()
- return (*memoryRequest).Cmp(*memoryLimit) == 0 && memoryRequest.Value() != 0
-}
-
-// GetContainerOOMAdjust returns the amount by which the OOM score of all processes in the
-// container should be adjusted. The OOM score of a process is the percentage of memory it consumes
-// multiplied by 10 (barring exceptional cases) + a configurable quantity which is between -1000
-// and 1000. Containers with higher OOM scores are killed if the system runs out of memory.
-// See https://lwn.net/Articles/391222/ for more information.
-func GetContainerOOMScoreAdjust(container *api.Container, memoryCapacity int64) int {
- if isMemoryGuaranteed(container) {
- // Memory guaranteed containers should be the last to get killed.
- return -999
- } else if isMemoryBestEffort(container) {
- // Memory best-effort containers should be the first to be killed.
- return 1000
- } else {
- // Burstable containers are a middle tier, between Guaranteed and Best-Effort. Ideally,
- // we want to protect Burstable containers that consume less memory than requested.
- // The formula below is a heuristic. A container requesting for 10% of a system's
- // memory will have an oom score adjust of 900. If a process in container Y
- // uses over 10% of memory, its OOM score will be 1000. The idea is that containers
- // which use more than their request will have an OOM score of 1000 and will be prime
- // targets for OOM kills.
- // Note that this is a heuristic, it won't work if a container has many small processes.
- memoryRequest := container.Resources.Requests.Memory().Value()
- oomScoreAdjust := 1000 - (1000*memoryRequest)/memoryCapacity
- // A memory guaranteed container using 100% of memory can have an OOM score of 1. Ensure
- // that memory burstable containers have a higher OOM score.
- if oomScoreAdjust < 2 {
- return 2
- }
- return int(oomScoreAdjust)
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion_generator.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion_generator.go
deleted file mode 100644
index 9971b7b20dfcb74b17b21b11b514b26d9b7462da..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion_generator.go
+++ /dev/null
@@ -1,913 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 runtime
-
-import (
- "fmt"
- "io"
- "log"
- "path"
- "reflect"
- goruntime "runtime"
- "sort"
- "strings"
-
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/util/sets"
-)
-
-type ConversionGenerator interface {
- GenerateConversionsForType(groupVersion unversioned.GroupVersion, reflection reflect.Type) error
- WriteConversionFunctions(w io.Writer) error
- RegisterConversionFunctions(w io.Writer, pkg string) error
- AddImport(pkg string) string
- RepackImports(exclude sets.String)
- WriteImports(w io.Writer) error
- OverwritePackage(pkg, overwrite string)
- AssumePrivateConversions()
-}
-
-func NewConversionGenerator(scheme *Scheme, targetPkg string) ConversionGenerator {
- g := &conversionGenerator{
- scheme: scheme,
-
- nameFormat: "Convert_%s_%s_To_%s_%s",
- generatedNamePrefix: "auto",
- targetPkg: targetPkg,
-
- publicFuncs: make(map[typePair]functionName),
- convertibles: make(map[reflect.Type]reflect.Type),
- overridden: make(map[reflect.Type]bool),
- pkgOverwrites: make(map[string]string),
- imports: make(map[string]string),
- shortImports: make(map[string]string),
- }
- g.targetPackage(targetPkg)
- g.AddImport("reflect")
- g.AddImport("k8s.io/kubernetes/pkg/conversion")
- return g
-}
-
-var complexTypes []reflect.Kind = []reflect.Kind{reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct}
-
-type functionName struct {
- name string
- packageName string
-}
-
-type conversionGenerator struct {
- scheme *Scheme
-
- nameFormat string
- generatedNamePrefix string
- targetPkg string
-
- publicFuncs map[typePair]functionName
- convertibles map[reflect.Type]reflect.Type
- overridden map[reflect.Type]bool
- // If pkgOverwrites is set for a given package name, that package name
- // will be replaced while writing conversion function. If empty, package
- // name will be omitted.
- pkgOverwrites map[string]string
- // map of package names to shortname
- imports map[string]string
- // map of short names to package names
- shortImports map[string]string
-
- // A buffer that is used for storing lines that needs to be written.
- linesToPrint []string
-
- // if true, we assume conversions on the scheme are not available to us in the current package
- assumePrivateConversions bool
-}
-
-func (g *conversionGenerator) AssumePrivateConversions() {
- g.assumePrivateConversions = true
-}
-
-func (g *conversionGenerator) AddImport(pkg string) string {
- return g.addImportByPath(pkg)
-}
-
-func (g *conversionGenerator) GenerateConversionsForType(gv unversioned.GroupVersion, reflection reflect.Type) error {
- kind := reflection.Name()
- // TODO this is equivalent to what it did before, but it needs to be fixed for the proper group
- internalVersion := gv
- internalVersion.Version = APIVersionInternal
-
- internalObj, err := g.scheme.New(internalVersion.WithKind(kind))
- if err != nil {
- return fmt.Errorf("cannot create an object of type %v in internal version", kind)
- }
- internalObjType := reflect.TypeOf(internalObj)
- if internalObjType.Kind() != reflect.Ptr {
- return fmt.Errorf("created object should be of type Ptr: %v", internalObjType.Kind())
- }
- inErr := g.generateConversionsBetween(reflection, internalObjType.Elem())
- outErr := g.generateConversionsBetween(internalObjType.Elem(), reflection)
- if inErr != nil || outErr != nil {
- return fmt.Errorf("errors: %v, %v", inErr, outErr)
- }
- return nil
-}
-
-// primitiveConversion returns true if the two types can be converted via a cast.
-func primitiveConversion(inType, outType reflect.Type) (string, bool) {
- switch inType.Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
- reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
- reflect.Float32, reflect.Float64:
- switch outType.Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
- reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
- reflect.Float32, reflect.Float64:
- return outType.Name(), true
- }
- }
- return "", false
-}
-
-func (g *conversionGenerator) generateConversionsBetween(inType, outType reflect.Type) error {
- existingConversion := g.scheme.Converter().HasConversionFunc(inType, outType) && g.scheme.Converter().HasConversionFunc(outType, inType)
-
- // Avoid processing the same type multiple times.
- if value, found := g.convertibles[inType]; found {
- if value != outType {
- return fmt.Errorf("multiple possible convertibles for %v", inType)
- }
- return nil
- }
- if inType == outType {
- switch inType.Kind() {
- case reflect.Ptr:
- return g.generateConversionsBetween(inType.Elem(), inType.Elem())
- case reflect.Struct:
- // pointers to structs invoke new(inType)
- g.addImportByPath(inType.PkgPath())
- }
- g.rememberConversionFunction(inType, inType, false)
- // Don't generate conversion methods for the same type.
- return nil
- }
-
- if _, ok := primitiveConversion(inType, outType); ok {
- return nil
- }
-
- if inType.Kind() != outType.Kind() {
- if existingConversion {
- g.rememberConversionFunction(inType, outType, false)
- g.rememberConversionFunction(outType, inType, false)
- return nil
- }
- return fmt.Errorf("cannot convert types of different kinds: %v %v", inType, outType)
- }
-
- g.addImportByPath(inType.PkgPath())
- g.addImportByPath(outType.PkgPath())
-
- // We should be able to generate conversions both sides.
- switch inType.Kind() {
- case reflect.Map:
- inErr := g.generateConversionsForMap(inType, outType)
- outErr := g.generateConversionsForMap(outType, inType)
- if !existingConversion && (inErr != nil || outErr != nil) {
- return inErr
- }
- // We don't add it to g.convertibles - maps should be handled correctly
- // inside appropriate conversion functions.
- return nil
- case reflect.Ptr:
- inErr := g.generateConversionsBetween(inType.Elem(), outType.Elem())
- outErr := g.generateConversionsBetween(outType.Elem(), inType.Elem())
- if !existingConversion && (inErr != nil || outErr != nil) {
- return inErr
- }
- // We don't add it to g.convertibles - maps should be handled correctly
- // inside appropriate conversion functions.
- return nil
- case reflect.Slice:
- inErr := g.generateConversionsForSlice(inType, outType)
- outErr := g.generateConversionsForSlice(outType, inType)
- if !existingConversion && (inErr != nil || outErr != nil) {
- return inErr
- }
- // We don't add it to g.convertibles - slices should be handled correctly
- // inside appropriate conversion functions.
- return nil
- case reflect.Interface:
- // TODO(wojtek-t): Currently we don't support converting interfaces.
- return fmt.Errorf("interfaces are not supported")
- case reflect.Struct:
- inErr := g.generateConversionsForStruct(inType, outType)
- outErr := g.generateConversionsForStruct(outType, inType)
- if !existingConversion && (inErr != nil || outErr != nil) {
- return inErr
- }
- g.rememberConversionFunction(inType, outType, true)
- if existingConversion {
- g.overridden[inType] = true
- }
- g.convertibles[inType] = outType
- return nil
- default:
- // All simple types should be handled correctly with default conversion.
- return nil
- }
-}
-
-func isComplexType(reflection reflect.Type) bool {
- for _, complexType := range complexTypes {
- if complexType == reflection.Kind() {
- return true
- }
- }
- return false
-}
-
-func (g *conversionGenerator) rememberConversionFunction(inType, outType reflect.Type, willGenerate bool) {
- if _, ok := g.publicFuncs[typePair{inType, outType}]; ok {
- return
- }
-
- if v, ok := g.scheme.Converter().ConversionFuncValue(inType, outType); ok {
- if fn := goruntime.FuncForPC(v.Pointer()); fn != nil {
- name := fn.Name()
- var p, n string
- if last := strings.LastIndex(name, "."); last != -1 {
- p = name[:last]
- n = name[last+1:]
- } else {
- n = name
- }
- if isPublic(n) {
- g.AddImport(p)
- g.publicFuncs[typePair{inType, outType}] = functionName{name: n, packageName: p}
- } else {
- log.Printf("WARNING: Cannot generate conversion %v -> %v, method %q is private", inType, outType, fn.Name())
- }
- } else {
- log.Printf("WARNING: Cannot generate conversion %v -> %v, method is not accessible", inType, outType)
- }
- } else if willGenerate {
- g.publicFuncs[typePair{inType, outType}] = functionName{name: g.conversionFunctionName(inType, outType)}
- }
-}
-
-func isPublic(name string) bool {
- return strings.ToUpper(name[:1]) == name[:1]
-}
-
-func (g *conversionGenerator) generateConversionsForMap(inType, outType reflect.Type) error {
- inKey := inType.Key()
- outKey := outType.Key()
- g.addImportByPath(inKey.PkgPath())
- g.addImportByPath(outKey.PkgPath())
- if err := g.generateConversionsBetween(inKey, outKey); err != nil {
- return err
- }
- inValue := inType.Elem()
- outValue := outType.Elem()
- g.addImportByPath(inValue.PkgPath())
- g.addImportByPath(outValue.PkgPath())
- if err := g.generateConversionsBetween(inValue, outValue); err != nil {
- return err
- }
- return nil
-}
-
-func (g *conversionGenerator) generateConversionsForSlice(inType, outType reflect.Type) error {
- inElem := inType.Elem()
- outElem := outType.Elem()
- // slice conversion requires the package for the destination type in order to instantiate the map
- g.addImportByPath(outElem.PkgPath())
- if err := g.generateConversionsBetween(inElem, outElem); err != nil {
- return err
- }
- return nil
-}
-
-func (g *conversionGenerator) generateConversionsForStruct(inType, outType reflect.Type) error {
- for i := 0; i < inType.NumField(); i++ {
- inField := inType.Field(i)
- outField, found := outType.FieldByName(inField.Name)
- if !found {
- return fmt.Errorf("couldn't find a corresponding field %v in %v", inField.Name, outType)
- }
- if isComplexType(inField.Type) {
- if err := g.generateConversionsBetween(inField.Type, outField.Type); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-// A buffer of lines that will be written.
-type bufferedLine struct {
- line string
- indentation int
-}
-
-type buffer struct {
- lines []bufferedLine
-}
-
-func newBuffer() *buffer {
- return &buffer{
- lines: make([]bufferedLine, 0),
- }
-}
-
-func (b *buffer) addLine(line string, indent int) {
- b.lines = append(b.lines, bufferedLine{line, indent})
-}
-
-func (b *buffer) flushLines(w io.Writer) error {
- for _, line := range b.lines {
- indentation := strings.Repeat("\t", line.indentation)
- fullLine := fmt.Sprintf("%s%s", indentation, line.line)
- if _, err := io.WriteString(w, fullLine); err != nil {
- return err
- }
- }
- return nil
-}
-
-type byName []reflect.Type
-
-func (s byName) Len() int {
- return len(s)
-}
-
-func (s byName) Less(i, j int) bool {
- fullNameI := s[i].PkgPath() + "/" + s[i].Name()
- fullNameJ := s[j].PkgPath() + "/" + s[j].Name()
- return fullNameI < fullNameJ
-}
-
-func (s byName) Swap(i, j int) {
- s[i], s[j] = s[j], s[i]
-}
-
-func (g *conversionGenerator) targetPackage(pkg string) {
- g.imports[pkg] = ""
- g.shortImports[""] = pkg
-}
-
-func (g *conversionGenerator) RepackImports(exclude sets.String) {
- var packages []string
- for key := range g.imports {
- packages = append(packages, key)
- }
- sort.Strings(packages)
- g.imports = make(map[string]string)
- g.shortImports = make(map[string]string)
- g.targetPackage(g.targetPkg)
- for _, pkg := range packages {
- if !exclude.Has(pkg) {
- g.addImportByPath(pkg)
- }
- }
-}
-
-func (g *conversionGenerator) WriteImports(w io.Writer) error {
- var packages []string
- for key := range g.imports {
- packages = append(packages, key)
- }
- sort.Strings(packages)
-
- buffer := newBuffer()
- indent := 0
- buffer.addLine("import (\n", indent)
- for _, importPkg := range packages {
- if len(importPkg) == 0 {
- continue
- }
- if len(g.imports[importPkg]) == 0 {
- continue
- }
- buffer.addLine(fmt.Sprintf("%s \"%s\"\n", g.imports[importPkg], importPkg), indent+1)
- }
- buffer.addLine(")\n", indent)
- buffer.addLine("\n", indent)
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-func (g *conversionGenerator) WriteConversionFunctions(w io.Writer) error {
- // It's desired to print conversion functions always in the same order
- // (e.g. for better tracking of what has really been added).
- var keys []reflect.Type
- for key := range g.convertibles {
- keys = append(keys, key)
- }
- sort.Sort(byName(keys))
-
- buffer := newBuffer()
- indent := 0
- for _, inType := range keys {
- outType := g.convertibles[inType]
- // All types in g.convertibles are structs.
- if inType.Kind() != reflect.Struct {
- return fmt.Errorf("non-struct conversions are not-supported")
- }
- if err := g.writeConversionForType(buffer, inType, outType, indent); err != nil {
- return err
- }
- }
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-func (g *conversionGenerator) writeRegisterHeader(b *buffer, pkg string, indent int) {
- b.addLine("func init() {\n", indent)
- b.addLine(fmt.Sprintf("err := %s.AddGeneratedConversionFuncs(\n", pkg), indent+1)
-}
-
-func (g *conversionGenerator) writeRegisterFooter(b *buffer, indent int) {
- b.addLine(")\n", indent+1)
- b.addLine("if err != nil {\n", indent+1)
- b.addLine("// If one of the conversion functions is malformed, detect it immediately.\n", indent+2)
- b.addLine("panic(err)\n", indent+2)
- b.addLine("}\n", indent+1)
- b.addLine("}\n", indent)
- b.addLine("\n", indent)
-}
-
-func (g *conversionGenerator) RegisterConversionFunctions(w io.Writer, pkg string) error {
- // Write conversion function names alphabetically ordered.
- var names []string
- for inType, outType := range g.convertibles {
- names = append(names, g.generatedFunctionName(inType, outType))
- }
- sort.Strings(names)
-
- buffer := newBuffer()
- indent := 0
- g.writeRegisterHeader(buffer, pkg, indent)
- for _, name := range names {
- buffer.addLine(fmt.Sprintf("%s,\n", name), indent+2)
- }
- g.writeRegisterFooter(buffer, indent)
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-func (g *conversionGenerator) addImportByPath(pkg string) string {
- if name, ok := g.imports[pkg]; ok {
- return name
- }
- name := path.Base(pkg)
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- if dirname := path.Base(path.Dir(pkg)); len(dirname) > 0 {
- name = dirname + name
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- if subdirname := path.Base(path.Dir(path.Dir(pkg))); len(subdirname) > 0 {
- name = subdirname + name
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- }
- }
- for i := 2; i < 100; i++ {
- generatedName := fmt.Sprintf("%s%d", name, i)
- if _, ok := g.shortImports[generatedName]; !ok {
- g.imports[pkg] = generatedName
- g.shortImports[generatedName] = pkg
- return generatedName
- }
- }
- panic(fmt.Sprintf("unable to find a unique name for the package path %q: %v", pkg, g.shortImports))
-}
-
-func (g *conversionGenerator) typeName(inType reflect.Type) string {
- switch inType.Kind() {
- case reflect.Slice:
- return fmt.Sprintf("[]%s", g.typeName(inType.Elem()))
- case reflect.Ptr:
- return fmt.Sprintf("*%s", g.typeName(inType.Elem()))
- case reflect.Map:
- if len(inType.Name()) == 0 {
- return fmt.Sprintf("map[%s]%s", g.typeName(inType.Key()), g.typeName(inType.Elem()))
- }
- fallthrough
- default:
- pkg, name := inType.PkgPath(), inType.Name()
- if len(name) == 0 && inType.Kind() == reflect.Struct {
- return "struct{}"
- }
- if len(pkg) == 0 {
- // Default package.
- return name
- }
- if val, found := g.pkgOverwrites[pkg]; found {
- pkg = val
- }
- if len(pkg) == 0 {
- return name
- }
- short := g.addImportByPath(pkg)
- if len(short) > 0 {
- return fmt.Sprintf("%s.%s", short, name)
- }
- return name
- }
-}
-
-func (g *conversionGenerator) writeDefaultingFunc(b *buffer, inType reflect.Type, indent int) error {
- getStmt := "if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {\n"
- b.addLine(getStmt, indent)
- callFormat := "defaulting.(func(*%s))(in)\n"
- callStmt := fmt.Sprintf(callFormat, g.typeName(inType))
- b.addLine(callStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func packageForName(inType reflect.Type) string {
- if inType.PkgPath() == "" {
- return ""
- }
- slices := strings.Split(inType.PkgPath(), "/")
- return slices[len(slices)-1]
-}
-
-func (g *conversionGenerator) conversionFunctionName(inType, outType reflect.Type) string {
- funcNameFormat := g.nameFormat
- inPkg := packageForName(inType)
- outPkg := packageForName(outType)
- funcName := fmt.Sprintf(funcNameFormat, inPkg, inType.Name(), outPkg, outType.Name())
- return funcName
-}
-
-func (g *conversionGenerator) conversionFunctionCall(inType, outType reflect.Type, scopeName string, args ...string) string {
- if named, ok := g.publicFuncs[typePair{inType, outType}]; ok {
- args[len(args)-1] = scopeName
- name := named.name
- localPackageName, ok := g.imports[named.packageName]
- if !ok {
- panic(fmt.Sprintf("have not defined an import for %s", named.packageName))
- }
- if len(named.packageName) > 0 && len(localPackageName) > 0 {
- name = localPackageName + "." + name
- }
- return fmt.Sprintf("%s(%s)", name, strings.Join(args, ", "))
- }
- log.Printf("WARNING: Using reflection to convert %v -> %v (no public conversion)", inType, outType)
- return fmt.Sprintf("%s.Convert(%s)", scopeName, strings.Join(args, ", "))
-}
-
-func (g *conversionGenerator) generatedFunctionName(inType, outType reflect.Type) string {
- return g.generatedNamePrefix + g.conversionFunctionName(inType, outType)
-}
-
-func (g *conversionGenerator) writeHeader(b *buffer, name, inType, outType string, indent int) {
- format := "func %s(in *%s, out *%s, s conversion.Scope) error {\n"
- stmt := fmt.Sprintf(format, name, inType, outType)
- b.addLine(stmt, indent)
-}
-
-func (g *conversionGenerator) writeFooter(b *buffer, indent int) {
- b.addLine("return nil\n", indent+1)
- b.addLine("}\n", indent)
-}
-
-func (g *conversionGenerator) writeConversionForMap(b *buffer, inField, outField reflect.StructField, indent int) error {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- makeFormat := "out.%s = make(%s)\n"
- makeStmt := fmt.Sprintf(makeFormat, outField.Name, g.typeName(outField.Type))
- b.addLine(makeStmt, indent+1)
- forFormat := "for key, val := range in.%s {\n"
- forStmt := fmt.Sprintf(forFormat, inField.Name)
- b.addLine(forStmt, indent+1)
-
- // Whether we need to explicitly create a new value.
- newValue := false
- if isComplexType(inField.Type.Elem()) || !inField.Type.Elem().ConvertibleTo(outField.Type.Elem()) {
- newValue = true
- newFormat := "newVal := %s{}\n"
- newStmt := fmt.Sprintf(newFormat, g.typeName(outField.Type.Elem()))
- b.addLine(newStmt, indent+2)
- call := g.conversionFunctionCall(inField.Type.Elem(), outField.Type.Elem(), "s", "&val", "&newVal", "0")
- convertStmt := fmt.Sprintf("if err := %s; err != nil {\n", call)
- b.addLine(convertStmt, indent+2)
- b.addLine("return err\n", indent+3)
- b.addLine("}\n", indent+2)
- }
- if inField.Type.Key().ConvertibleTo(outField.Type.Key()) {
- value := "val"
- if newValue {
- value = "newVal"
- }
- assignStmt := ""
- if inField.Type.Key().AssignableTo(outField.Type.Key()) {
- assignStmt = fmt.Sprintf("out.%s[key] = %s\n", outField.Name, value)
- } else {
- assignStmt = fmt.Sprintf("out.%s[%s(key)] = %s\n", outField.Name, g.typeName(outField.Type.Key()), value)
- }
- b.addLine(assignStmt, indent+2)
- } else {
- // TODO(wojtek-t): Support maps with keys that are non-convertible to each other.
- return fmt.Errorf("conversions between unconvertible keys in map are not supported.")
- }
- b.addLine("}\n", indent+1)
- b.addLine("} else {\n", indent)
- nilFormat := "out.%s = nil\n"
- nilStmt := fmt.Sprintf(nilFormat, outField.Name)
- b.addLine(nilStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *conversionGenerator) writeConversionForSlice(b *buffer, inField, outField reflect.StructField, indent int) error {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- makeFormat := "out.%s = make(%s, len(in.%s))\n"
- makeStmt := fmt.Sprintf(makeFormat, outField.Name, g.typeName(outField.Type), inField.Name)
- b.addLine(makeStmt, indent+1)
- forFormat := "for i := range in.%s {\n"
- forStmt := fmt.Sprintf(forFormat, inField.Name)
- b.addLine(forStmt, indent+1)
-
- assigned := false
- switch inField.Type.Elem().Kind() {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- // Don't copy these via assignment/conversion!
- default:
- // This should handle all simple types.
- if inField.Type.Elem().AssignableTo(outField.Type.Elem()) {
- assignFormat := "out.%s[i] = in.%s[i]\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, inField.Name)
- b.addLine(assignStmt, indent+2)
- assigned = true
- } else if inField.Type.Elem().ConvertibleTo(outField.Type.Elem()) {
- assignFormat := "out.%s[i] = %s(in.%s[i])\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, g.typeName(outField.Type.Elem()), inField.Name)
- b.addLine(assignStmt, indent+2)
- assigned = true
- }
- }
- if !assigned {
- call := g.conversionFunctionCall(inField.Type.Elem(), outField.Type.Elem(), "s", "&in."+inField.Name+"[i]", "&out."+outField.Name+"[i]", "0")
- assignStmt := fmt.Sprintf("if err := %s; err != nil {\n", call)
- b.addLine(assignStmt, indent+2)
- b.addLine("return err\n", indent+3)
- b.addLine("}\n", indent+2)
- }
- b.addLine("}\n", indent+1)
- b.addLine("} else {\n", indent)
- nilFormat := "out.%s = nil\n"
- nilStmt := fmt.Sprintf(nilFormat, outField.Name)
- b.addLine(nilStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *conversionGenerator) writeConversionForPtr(b *buffer, inField, outField reflect.StructField, indent int) error {
- switch inField.Type.Elem().Kind() {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- // Don't copy these via assignment/conversion!
- default:
- // This should handle pointers to all simple types.
- assignable := inField.Type.Elem().AssignableTo(outField.Type.Elem())
- convertible := inField.Type.Elem().ConvertibleTo(outField.Type.Elem())
- if assignable || convertible {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- newFormat := "out.%s = new(%s)\n"
- newStmt := fmt.Sprintf(newFormat, outField.Name, g.typeName(outField.Type.Elem()))
- b.addLine(newStmt, indent+1)
- }
- if assignable {
- assignFormat := "*out.%s = *in.%s\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, inField.Name)
- b.addLine(assignStmt, indent+1)
- } else if convertible {
- assignFormat := "*out.%s = %s(*in.%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, g.typeName(outField.Type.Elem()), inField.Name)
- b.addLine(assignStmt, indent+1)
- }
- if assignable || convertible {
- b.addLine("} else {\n", indent)
- nilFormat := "out.%s = nil\n"
- nilStmt := fmt.Sprintf(nilFormat, outField.Name)
- b.addLine(nilStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
- }
- }
-
- b.addLine(fmt.Sprintf("// unable to generate simple pointer conversion for %v -> %v\n", inField.Type.Elem(), outField.Type.Elem()), indent)
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- assignStmt := ""
- if _, ok := g.publicFuncs[typePair{inField.Type.Elem(), outField.Type.Elem()}]; ok {
- newFormat := "out.%s = new(%s)\n"
- newStmt := fmt.Sprintf(newFormat, outField.Name, g.typeName(outField.Type.Elem()))
- b.addLine(newStmt, indent+1)
- call := g.conversionFunctionCall(inField.Type.Elem(), outField.Type.Elem(), "s", "in."+inField.Name, "out."+outField.Name, "0")
- assignStmt = fmt.Sprintf("if err := %s; err != nil {\n", call)
- } else {
- call := g.conversionFunctionCall(inField.Type.Elem(), outField.Type.Elem(), "s", "&in."+inField.Name, "&out."+outField.Name, "0")
- assignStmt = fmt.Sprintf("if err := %s; err != nil {\n", call)
- }
- b.addLine(assignStmt, indent+1)
- b.addLine("return err\n", indent+2)
- b.addLine("}\n", indent+1)
- b.addLine("} else {\n", indent)
- nilFormat := "out.%s = nil\n"
- nilStmt := fmt.Sprintf(nilFormat, outField.Name)
- b.addLine(nilStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *conversionGenerator) canTryConversion(b *buffer, inType reflect.Type, inField, outField reflect.StructField, indent int) (bool, error) {
- if inField.Type.Kind() != outField.Type.Kind() {
- if !g.overridden[inType] {
- return false, fmt.Errorf("input %s.%s (%s) does not match output (%s) and conversion is not overridden", inType, inField.Name, inField.Type.Kind(), outField.Type.Kind())
- }
- b.addLine(fmt.Sprintf("// in.%s has no peer in out\n", inField.Name), indent)
- return false, nil
- }
- return true, nil
-}
-
-func (g *conversionGenerator) writeConversionForStruct(b *buffer, inType, outType reflect.Type, indent int) error {
- for i := 0; i < inType.NumField(); i++ {
- inField := inType.Field(i)
- outField, found := outType.FieldByName(inField.Name)
- if !found {
- if !g.overridden[inType] {
- return fmt.Errorf("input %s.%s has no peer in output %s and conversion is not overridden", inType, inField.Name, outType)
- }
- b.addLine(fmt.Sprintf("// in.%s has no peer in out\n", inField.Name), indent)
- continue
- }
-
- if g.scheme.Converter().IsConversionIgnored(inField.Type, outField.Type) {
- continue
- }
-
- existsConversion := g.scheme.Converter().HasConversionFunc(inField.Type, outField.Type)
- _, hasPublicConversion := g.publicFuncs[typePair{inField.Type, outField.Type}]
- // TODO: This allows a private conversion for a slice to take precedence over a public
- // conversion for the field, even though that is technically slower. We should report when
- // we generate an inefficient conversion.
- if existsConversion || hasPublicConversion {
- // Use the conversion method that is already defined.
- call := g.conversionFunctionCall(inField.Type, outField.Type, "s", "&in."+inField.Name, "&out."+outField.Name, "0")
- assignStmt := fmt.Sprintf("if err := %s; err != nil {\n", call)
- b.addLine(assignStmt, indent)
- b.addLine("return err\n", indent+1)
- b.addLine("}\n", indent)
- continue
- }
-
- switch inField.Type.Kind() {
- case reflect.Map:
- if try, err := g.canTryConversion(b, inType, inField, outField, indent); err != nil {
- return err
- } else if !try {
- continue
- }
- if err := g.writeConversionForMap(b, inField, outField, indent); err != nil {
- return err
- }
- continue
- case reflect.Ptr:
- if try, err := g.canTryConversion(b, inType, inField, outField, indent); err != nil {
- return err
- } else if !try {
- continue
- }
- if err := g.writeConversionForPtr(b, inField, outField, indent); err != nil {
- return err
- }
- continue
- case reflect.Slice:
- if try, err := g.canTryConversion(b, inType, inField, outField, indent); err != nil {
- return err
- } else if !try {
- continue
- }
- if err := g.writeConversionForSlice(b, inField, outField, indent); err != nil {
- return err
- }
- continue
- case reflect.Interface, reflect.Struct:
- // Don't copy these via assignment/conversion!
- default:
- // This should handle all simple types.
- if inField.Type.AssignableTo(outField.Type) {
- assignFormat := "out.%s = in.%s\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, inField.Name)
- b.addLine(assignStmt, indent)
- continue
- }
- if inField.Type.ConvertibleTo(outField.Type) {
- assignFormat := "out.%s = %s(in.%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, outField.Name, g.typeName(outField.Type), inField.Name)
- b.addLine(assignStmt, indent)
- continue
- }
- }
-
- call := g.conversionFunctionCall(inField.Type, outField.Type, "s", "&in."+inField.Name, "&out."+outField.Name, "0")
- assignStmt := fmt.Sprintf("if err := %s; err != nil {\n", call)
- b.addLine(assignStmt, indent)
- b.addLine("return err\n", indent+1)
- b.addLine("}\n", indent)
- }
- return nil
-}
-
-func (g *conversionGenerator) writeConversionForType(b *buffer, inType, outType reflect.Type, indent int) error {
- // Always emit the auto-generated name.
- autoFuncName := g.generatedFunctionName(inType, outType)
- g.writeHeader(b, autoFuncName, g.typeName(inType), g.typeName(outType), indent)
- if err := g.writeDefaultingFunc(b, inType, indent+1); err != nil {
- return err
- }
- switch inType.Kind() {
- case reflect.Struct:
- if err := g.writeConversionForStruct(b, inType, outType, indent+1); err != nil {
- return err
- }
- default:
- return fmt.Errorf("type not supported: %v", inType)
- }
- g.writeFooter(b, indent)
- b.addLine("\n", 0)
-
- if !g.overridden[inType] {
- // Also emit the "user-facing" name.
- userFuncName := g.conversionFunctionName(inType, outType)
- g.writeHeader(b, userFuncName, g.typeName(inType), g.typeName(outType), indent)
- b.addLine(fmt.Sprintf("return %s(in, out, s)\n", autoFuncName), indent+1)
- b.addLine("}\n\n", 0)
- }
-
- return nil
-}
-
-func (g *conversionGenerator) existsConversionFunction(inType, outType reflect.Type) bool {
- if val, found := g.convertibles[inType]; found && val == outType {
- return true
- }
- if val, found := g.convertibles[outType]; found && val == inType {
- return true
- }
- return false
-}
-
-// TODO(wojtek-t): We should somehow change the conversion methods registered under:
-// pkg/runtime/scheme.go to implement the naming convention for conversion functions
-// and get rid of this hack.
-type typePair struct {
- inType reflect.Type
- outType reflect.Type
-}
-
-var defaultConversions []typePair = []typePair{}
-
-func (g *conversionGenerator) OverwritePackage(pkg, overwrite string) {
- g.pkgOverwrites[pkg] = overwrite
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/deep_copy_generator.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/deep_copy_generator.go
deleted file mode 100644
index 4790969f12994a7c3c22880b71bfa0f25d155f70..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/deep_copy_generator.go
+++ /dev/null
@@ -1,609 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 runtime
-
-import (
- "fmt"
- "io"
- "path"
- "reflect"
- "sort"
- "strings"
-
- "k8s.io/kubernetes/pkg/util/sets"
-)
-
-// TODO(wojtek-t): As suggested in #8320, we should consider the strategy
-// to first do the shallow copy and then recurse into things that need a
-// deep copy (maps, pointers, slices). That sort of copy function would
-// need one parameter - a pointer to the thing it's supposed to expand,
-// and it would involve a lot less memory copying.
-type DeepCopyGenerator interface {
- // Adds a type to a generator.
- // If the type is non-struct, it will return an error, otherwise deep-copy
- // functions for this type and all nested types will be generated.
- AddType(inType reflect.Type) error
-
- // ReplaceType registers a type that should be used instead of the type
- // with the provided pkgPath and name.
- ReplaceType(pkgPath, name string, in interface{})
-
- // AddImport registers a package name with the generator and returns its
- // short name.
- AddImport(pkgPath string) string
-
- // RepackImports creates a stable ordering of import short names
- RepackImports()
-
- // Writes all imports that are necessary for deep-copy function and
- // their registration.
- WriteImports(w io.Writer) error
-
- // Writes deel-copy functions for all types added via AddType() method
- // and their nested types.
- WriteDeepCopyFunctions(w io.Writer) error
-
- // Writes an init() function that registers all the generated deep-copy
- // functions.
- RegisterDeepCopyFunctions(w io.Writer, pkg string) error
-
- // When generating code, all references to "pkg" package name will be
- // replaced with "overwrite". It is used mainly to replace references
- // to name of the package in which the code will be created with empty
- // string.
- OverwritePackage(pkg, overwrite string)
-}
-
-func NewDeepCopyGenerator(scheme *Scheme, targetPkg string, include sets.String) DeepCopyGenerator {
- g := &deepCopyGenerator{
- scheme: scheme,
- targetPkg: targetPkg,
- copyables: make(map[reflect.Type]bool),
- imports: make(map[string]string),
- shortImports: make(map[string]string),
- pkgOverwrites: make(map[string]string),
- replace: make(map[pkgPathNamePair]reflect.Type),
- include: include,
- }
- g.targetPackage(targetPkg)
- g.AddImport("k8s.io/kubernetes/pkg/conversion")
- return g
-}
-
-type pkgPathNamePair struct {
- PkgPath string
- Name string
-}
-
-type deepCopyGenerator struct {
- scheme *Scheme
- targetPkg string
- copyables map[reflect.Type]bool
- // map of package names to shortname
- imports map[string]string
- // map of short names to package names
- shortImports map[string]string
- pkgOverwrites map[string]string
- replace map[pkgPathNamePair]reflect.Type
- include sets.String
-}
-
-func (g *deepCopyGenerator) addImportByPath(pkg string) string {
- if name, ok := g.imports[pkg]; ok {
- return name
- }
- name := path.Base(pkg)
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- if dirname := path.Base(path.Dir(pkg)); len(dirname) > 0 {
- name = dirname + name
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- if subdirname := path.Base(path.Dir(path.Dir(pkg))); len(subdirname) > 0 {
- name = subdirname + name
- if _, ok := g.shortImports[name]; !ok {
- g.imports[pkg] = name
- g.shortImports[name] = pkg
- return name
- }
- }
- }
- for i := 2; i < 100; i++ {
- generatedName := fmt.Sprintf("%s%d", name, i)
- if _, ok := g.shortImports[generatedName]; !ok {
- g.imports[pkg] = generatedName
- g.shortImports[generatedName] = pkg
- return generatedName
- }
- }
- panic(fmt.Sprintf("unable to find a unique name for the package path %q: %v", pkg, g.shortImports))
-}
-
-func (g *deepCopyGenerator) targetPackage(pkg string) {
- g.imports[pkg] = ""
- g.shortImports[""] = pkg
-}
-
-func (g *deepCopyGenerator) addAllRecursiveTypes(inType reflect.Type) error {
- if _, found := g.copyables[inType]; found {
- return nil
- }
- switch inType.Kind() {
- case reflect.Map:
- if err := g.addAllRecursiveTypes(inType.Key()); err != nil {
- return err
- }
- if err := g.addAllRecursiveTypes(inType.Elem()); err != nil {
- return err
- }
- case reflect.Slice, reflect.Ptr:
- if err := g.addAllRecursiveTypes(inType.Elem()); err != nil {
- return err
- }
- case reflect.Interface:
- g.addImportByPath(inType.PkgPath())
- return nil
- case reflect.Struct:
- g.addImportByPath(inType.PkgPath())
- found := false
- for s := range g.include {
- if strings.HasPrefix(inType.PkgPath(), s) {
- found = true
- break
- }
- }
- if !found {
- return nil
- }
- for i := 0; i < inType.NumField(); i++ {
- inField := inType.Field(i)
- if err := g.addAllRecursiveTypes(inField.Type); err != nil {
- return err
- }
- }
- g.copyables[inType] = true
- default:
- // Simple types should be copied automatically.
- }
- return nil
-}
-
-func (g *deepCopyGenerator) AddImport(pkg string) string {
- return g.addImportByPath(pkg)
-}
-
-// ReplaceType registers a replacement type to be used instead of the named type
-func (g *deepCopyGenerator) ReplaceType(pkgPath, name string, t interface{}) {
- g.replace[pkgPathNamePair{pkgPath, name}] = reflect.TypeOf(t)
-}
-
-func (g *deepCopyGenerator) AddType(inType reflect.Type) error {
- if inType.Kind() != reflect.Struct {
- return fmt.Errorf("non-struct copies are not supported")
- }
- return g.addAllRecursiveTypes(inType)
-}
-
-func (g *deepCopyGenerator) RepackImports() {
- var packages []string
- for key := range g.imports {
- packages = append(packages, key)
- }
- sort.Strings(packages)
- g.imports = make(map[string]string)
- g.shortImports = make(map[string]string)
-
- g.targetPackage(g.targetPkg)
- for _, pkg := range packages {
- g.addImportByPath(pkg)
- }
-}
-
-func (g *deepCopyGenerator) WriteImports(w io.Writer) error {
- var packages []string
- for key := range g.imports {
- packages = append(packages, key)
- }
- sort.Strings(packages)
-
- buffer := newBuffer()
- indent := 0
- buffer.addLine("import (\n", indent)
- for _, importPkg := range packages {
- if len(importPkg) == 0 {
- continue
- }
- if len(g.imports[importPkg]) == 0 {
- continue
- }
- buffer.addLine(fmt.Sprintf("%s \"%s\"\n", g.imports[importPkg], importPkg), indent+1)
- }
- buffer.addLine(")\n", indent)
- buffer.addLine("\n", indent)
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-type byPkgAndName []reflect.Type
-
-func (s byPkgAndName) Len() int {
- return len(s)
-}
-
-func (s byPkgAndName) Less(i, j int) bool {
- fullNameI := s[i].PkgPath() + "/" + s[i].Name()
- fullNameJ := s[j].PkgPath() + "/" + s[j].Name()
- return fullNameI < fullNameJ
-}
-
-func (s byPkgAndName) Swap(i, j int) {
- s[i], s[j] = s[j], s[i]
-}
-
-func (g *deepCopyGenerator) nameForType(inType reflect.Type) string {
- switch inType.Kind() {
- case reflect.Slice:
- return fmt.Sprintf("[]%s", g.typeName(inType.Elem()))
- case reflect.Ptr:
- return fmt.Sprintf("*%s", g.typeName(inType.Elem()))
- case reflect.Map:
- if len(inType.Name()) == 0 {
- return fmt.Sprintf("map[%s]%s", g.typeName(inType.Key()), g.typeName(inType.Elem()))
- }
- fallthrough
- default:
- pkg, name := inType.PkgPath(), inType.Name()
- if len(name) == 0 && inType.Kind() == reflect.Struct {
- return "struct{}"
- }
- if len(pkg) == 0 {
- // Default package.
- return name
- }
- if val, found := g.pkgOverwrites[pkg]; found {
- pkg = val
- }
- if len(pkg) == 0 {
- return name
- }
- short := g.addImportByPath(pkg)
- if len(short) > 0 {
- return fmt.Sprintf("%s.%s", short, name)
- }
- return name
- }
-}
-
-func (g *deepCopyGenerator) typeName(inType reflect.Type) string {
- if t, ok := g.replace[pkgPathNamePair{inType.PkgPath(), inType.Name()}]; ok {
- return g.nameForType(t)
- }
- return g.nameForType(inType)
-}
-
-func (g *deepCopyGenerator) deepCopyFunctionName(inType reflect.Type) string {
- funcNameFormat := "deepCopy_%s_%s"
- inPkg := packageForName(inType)
- funcName := fmt.Sprintf(funcNameFormat, inPkg, inType.Name())
- return funcName
-}
-
-func (g *deepCopyGenerator) writeHeader(b *buffer, inType reflect.Type, indent int) {
- format := "func %s(in %s, out *%s, c *conversion.Cloner) error {\n"
- stmt := fmt.Sprintf(format, g.deepCopyFunctionName(inType), g.typeName(inType), g.typeName(inType))
- b.addLine(stmt, indent)
-}
-
-func (g *deepCopyGenerator) writeFooter(b *buffer, indent int) {
- b.addLine("return nil\n", indent+1)
- b.addLine("}\n", indent)
-}
-
-func (g *deepCopyGenerator) WriteDeepCopyFunctions(w io.Writer) error {
- var keys []reflect.Type
- for key := range g.copyables {
- keys = append(keys, key)
- }
- sort.Sort(byPkgAndName(keys))
-
- buffer := newBuffer()
- indent := 0
- for _, inType := range keys {
- if err := g.writeDeepCopyForType(buffer, inType, indent); err != nil {
- return err
- }
- buffer.addLine("\n", 0)
- }
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-func (g *deepCopyGenerator) writeDeepCopyForMap(b *buffer, inField reflect.StructField, indent int) error {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- newFormat := "out.%s = make(%s)\n"
- newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type))
- b.addLine(newStmt, indent+1)
- forFormat := "for key, val := range in.%s {\n"
- forStmt := fmt.Sprintf(forFormat, inField.Name)
- b.addLine(forStmt, indent+1)
-
- switch inField.Type.Key().Kind() {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- return fmt.Errorf("not supported")
- default:
- switch inField.Type.Elem().Kind() {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- if _, found := g.copyables[inField.Type.Elem()]; found {
- newFormat := "newVal := new(%s)\n"
- newStmt := fmt.Sprintf(newFormat, g.typeName(inField.Type.Elem()))
- b.addLine(newStmt, indent+2)
- assignFormat := "if err := %s(val, newVal, c); err != nil {\n"
- funcName := g.deepCopyFunctionName(inField.Type.Elem())
- assignStmt := fmt.Sprintf(assignFormat, funcName)
- b.addLine(assignStmt, indent+2)
- b.addLine("return err\n", indent+3)
- b.addLine("}\n", indent+2)
- setFormat := "out.%s[key] = *newVal\n"
- setStmt := fmt.Sprintf(setFormat, inField.Name)
- b.addLine(setStmt, indent+2)
- } else {
- ifStmt := "if newVal, err := c.DeepCopy(val); err != nil {\n"
- b.addLine(ifStmt, indent+2)
- b.addLine("return err\n", indent+3)
- b.addLine("} else {\n", indent+2)
- assignFormat := "out.%s[key] = newVal.(%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type.Elem()))
- b.addLine(assignStmt, indent+3)
- b.addLine("}\n", indent+2)
- }
- default:
- assignFormat := "out.%s[key] = val\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name)
- b.addLine(assignStmt, indent+2)
- }
- }
- b.addLine("}\n", indent+1)
- b.addLine("} else {\n", indent)
- elseFormat := "out.%s = nil\n"
- elseStmt := fmt.Sprintf(elseFormat, inField.Name)
- b.addLine(elseStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *deepCopyGenerator) writeDeepCopyForPtr(b *buffer, inField reflect.StructField, indent int) error {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
-
- kind := inField.Type.Elem().Kind()
- switch kind {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- if _, found := g.copyables[inField.Type.Elem()]; found {
- newFormat := "out.%s = new(%s)\n"
- newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type.Elem()))
- b.addLine(newStmt, indent+1)
- assignFormat := "if err := %s(*in.%s, out.%s, c); err != nil {\n"
- funcName := g.deepCopyFunctionName(inField.Type.Elem())
- assignStmt := fmt.Sprintf(assignFormat, funcName, inField.Name, inField.Name)
- b.addLine(assignStmt, indent+1)
- b.addLine("return err\n", indent+2)
- b.addLine("}\n", indent+1)
- } else {
- ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent+1)
- b.addLine("return err\n", indent+2)
- if kind != reflect.Struct {
- b.addLine("} else if newVal == nil {\n", indent+1)
- b.addLine(fmt.Sprintf("out.%s = nil\n", inField.Name), indent+2)
- }
- b.addLine("} else {\n", indent+1)
- assignFormat := "out.%s = newVal.(%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type))
- b.addLine(assignStmt, indent+2)
- b.addLine("}\n", indent+1)
- }
- default:
- newFormat := "out.%s = new(%s)\n"
- newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type.Elem()))
- b.addLine(newStmt, indent+1)
- assignFormat := "*out.%s = *in.%s\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name)
- b.addLine(assignStmt, indent+1)
- }
- b.addLine("} else {\n", indent)
- elseFormat := "out.%s = nil\n"
- elseStmt := fmt.Sprintf(elseFormat, inField.Name)
- b.addLine(elseStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *deepCopyGenerator) writeDeepCopyForSlice(b *buffer, inField reflect.StructField, indent int) error {
- ifFormat := "if in.%s != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- newFormat := "out.%s = make(%s, len(in.%s))\n"
- newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type), inField.Name)
- b.addLine(newStmt, indent+1)
- forFormat := "for i := range in.%s {\n"
- forStmt := fmt.Sprintf(forFormat, inField.Name)
- b.addLine(forStmt, indent+1)
-
- kind := inField.Type.Elem().Kind()
- switch kind {
- case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct:
- if _, found := g.copyables[inField.Type.Elem()]; found {
- assignFormat := "if err := %s(in.%s[i], &out.%s[i], c); err != nil {\n"
- funcName := g.deepCopyFunctionName(inField.Type.Elem())
- assignStmt := fmt.Sprintf(assignFormat, funcName, inField.Name, inField.Name)
- b.addLine(assignStmt, indent+2)
- b.addLine("return err\n", indent+3)
- b.addLine("}\n", indent+2)
- } else {
- ifFormat := "if newVal, err := c.DeepCopy(in.%s[i]); err != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent+2)
- b.addLine("return err\n", indent+3)
- if kind != reflect.Struct {
- b.addLine("} else if newVal == nil {\n", indent+2)
- b.addLine(fmt.Sprintf("out.%s[i] = nil\n", inField.Name), indent+3)
- }
- b.addLine("} else {\n", indent+2)
- assignFormat := "out.%s[i] = newVal.(%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type.Elem()))
- b.addLine(assignStmt, indent+3)
- b.addLine("}\n", indent+2)
- }
- default:
- assignFormat := "out.%s[i] = in.%s[i]\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name)
- b.addLine(assignStmt, indent+2)
- }
- b.addLine("}\n", indent+1)
- b.addLine("} else {\n", indent)
- elseFormat := "out.%s = nil\n"
- elseStmt := fmt.Sprintf(elseFormat, inField.Name)
- b.addLine(elseStmt, indent+1)
- b.addLine("}\n", indent)
- return nil
-}
-
-func (g *deepCopyGenerator) writeDeepCopyForStruct(b *buffer, inType reflect.Type, indent int) error {
- for i := 0; i < inType.NumField(); i++ {
- inField := inType.Field(i)
- switch inField.Type.Kind() {
- case reflect.Map:
- if err := g.writeDeepCopyForMap(b, inField, indent); err != nil {
- return err
- }
- case reflect.Ptr:
- if err := g.writeDeepCopyForPtr(b, inField, indent); err != nil {
- return err
- }
- case reflect.Slice:
- if err := g.writeDeepCopyForSlice(b, inField, indent); err != nil {
- return err
- }
- case reflect.Interface:
- ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- b.addLine("return err\n", indent+1)
- b.addLine("} else if newVal == nil {\n", indent)
- b.addLine(fmt.Sprintf("out.%s = nil\n", inField.Name), indent+1)
- b.addLine("} else {\n", indent)
- copyFormat := "out.%s = newVal.(%s)\n"
- copyStmt := fmt.Sprintf(copyFormat, inField.Name, g.typeName(inField.Type))
- b.addLine(copyStmt, indent+1)
- b.addLine("}\n", indent)
- case reflect.Struct:
- if _, found := g.copyables[inField.Type]; found {
- ifFormat := "if err := %s(in.%s, &out.%s, c); err != nil {\n"
- funcName := g.deepCopyFunctionName(inField.Type)
- ifStmt := fmt.Sprintf(ifFormat, funcName, inField.Name, inField.Name)
- b.addLine(ifStmt, indent)
- b.addLine("return err\n", indent+1)
- b.addLine("}\n", indent)
- } else {
- ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n"
- ifStmt := fmt.Sprintf(ifFormat, inField.Name)
- b.addLine(ifStmt, indent)
- b.addLine("return err\n", indent+1)
- b.addLine("} else {\n", indent)
- assignFormat := "out.%s = newVal.(%s)\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type))
- b.addLine(assignStmt, indent+1)
- b.addLine("}\n", indent)
- }
- default:
- // This should handle all simple types.
- assignFormat := "out.%s = in.%s\n"
- assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name)
- b.addLine(assignStmt, indent)
- }
- }
- return nil
-}
-
-func (g *deepCopyGenerator) writeDeepCopyForType(b *buffer, inType reflect.Type, indent int) error {
- g.writeHeader(b, inType, indent)
- switch inType.Kind() {
- case reflect.Struct:
- if err := g.writeDeepCopyForStruct(b, inType, indent+1); err != nil {
- return err
- }
- default:
- return fmt.Errorf("type not supported: %v", inType)
- }
- g.writeFooter(b, indent)
- return nil
-}
-
-func (g *deepCopyGenerator) writeRegisterHeader(b *buffer, pkg string, indent int) {
- b.addLine("func init() {\n", indent)
- registerFormat := "err := %s.AddGeneratedDeepCopyFuncs(\n"
- b.addLine(fmt.Sprintf(registerFormat, pkg), indent+1)
-}
-
-func (g *deepCopyGenerator) writeRegisterFooter(b *buffer, indent int) {
- b.addLine(")\n", indent+1)
- b.addLine("if err != nil {\n", indent+1)
- b.addLine("// if one of the deep copy functions is malformed, detect it immediately.\n", indent+2)
- b.addLine("panic(err)\n", indent+2)
- b.addLine("}\n", indent+1)
- b.addLine("}\n", indent)
- b.addLine("\n", indent)
-}
-
-func (g *deepCopyGenerator) RegisterDeepCopyFunctions(w io.Writer, pkg string) error {
- var keys []reflect.Type
- for key := range g.copyables {
- keys = append(keys, key)
- }
- sort.Sort(byPkgAndName(keys))
-
- buffer := newBuffer()
- indent := 0
- g.writeRegisterHeader(buffer, pkg, indent)
- for _, inType := range keys {
- funcStmt := fmt.Sprintf("%s,\n", g.deepCopyFunctionName(inType))
- buffer.addLine(funcStmt, indent+2)
- }
- g.writeRegisterFooter(buffer, indent)
- if err := buffer.flushLines(w); err != nil {
- return err
- }
- return nil
-}
-
-func (g *deepCopyGenerator) OverwritePackage(pkg, overwrite string) {
- g.pkgOverwrites[pkg] = overwrite
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/helper.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/helper.go
deleted file mode 100644
index 4a76e81dc9f951ec3034b39d5be85d4160b19376..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/helper.go
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 runtime
-
-import (
- "fmt"
- "reflect"
-
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/conversion"
- "k8s.io/kubernetes/pkg/util/errors"
-)
-
-type objectTyperToTyper struct {
- typer ObjectTyper
-}
-
-func (t objectTyperToTyper) ObjectKind(obj Object) (*unversioned.GroupVersionKind, bool, error) {
- gvk, err := t.typer.ObjectKind(obj)
- if err != nil {
- return nil, false, err
- }
- unversionedType, ok := t.typer.IsUnversioned(obj)
- if !ok {
- // ObjectTyper violates its contract
- return nil, false, fmt.Errorf("typer returned a kind for %v, but then reported it was not in the scheme with IsUnversioned", reflect.TypeOf(obj))
- }
- return &gvk, unversionedType, nil
-}
-
-func ObjectTyperToTyper(typer ObjectTyper) Typer {
- return objectTyperToTyper{typer: typer}
-}
-
-// fieldPtr puts the address of fieldName, which must be a member of v,
-// into dest, which must be an address of a variable to which this field's
-// address can be assigned.
-func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error {
- field := v.FieldByName(fieldName)
- if !field.IsValid() {
- return fmt.Errorf("couldn't find %v field in %#v", fieldName, v.Interface())
- }
- v, err := conversion.EnforcePtr(dest)
- if err != nil {
- return err
- }
- field = field.Addr()
- if field.Type().AssignableTo(v.Type()) {
- v.Set(field)
- return nil
- }
- if field.Type().ConvertibleTo(v.Type()) {
- v.Set(field.Convert(v.Type()))
- return nil
- }
- return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), v.Type())
-}
-
-// EncodeList ensures that each object in an array is converted to a Unknown{} in serialized form.
-// TODO: accept a content type.
-func EncodeList(e Encoder, objects []Object, overrides ...unversioned.GroupVersion) error {
- var errs []error
- for i := range objects {
- data, err := Encode(e, objects[i], overrides...)
- if err != nil {
- errs = append(errs, err)
- continue
- }
- objects[i] = &Unknown{RawJSON: data}
- }
- return errors.NewAggregate(errs)
-}
-
-func decodeListItem(obj *Unknown, decoders []Decoder) (Object, error) {
- for _, decoder := range decoders {
- obj, err := Decode(decoder, obj.RawJSON)
- if err != nil {
- if IsNotRegisteredError(err) {
- continue
- }
- return nil, err
- }
- return obj, nil
- }
- // could not decode, so leave the object as Unknown, but give the decoders the
- // chance to set Unknown.TypeMeta if it is available.
- for _, decoder := range decoders {
- if err := DecodeInto(decoder, obj.RawJSON, obj); err == nil {
- return obj, nil
- }
- }
- return obj, nil
-}
-
-// DecodeList alters the list in place, attempting to decode any objects found in
-// the list that have the Unknown type. Any errors that occur are returned
-// after the entire list is processed. Decoders are tried in order.
-func DecodeList(objects []Object, decoders ...Decoder) []error {
- errs := []error(nil)
- for i, obj := range objects {
- switch t := obj.(type) {
- case *Unknown:
- decoded, err := decodeListItem(t, decoders)
- if err != nil {
- errs = append(errs, err)
- break
- }
- objects[i] = decoded
- }
- }
- return errs
-}
-
-// MultiObjectTyper returns the types of objects across multiple schemes in order.
-type MultiObjectTyper []ObjectTyper
-
-var _ ObjectTyper = MultiObjectTyper{}
-
-func (m MultiObjectTyper) ObjectKind(obj Object) (gvk unversioned.GroupVersionKind, err error) {
- for _, t := range m {
- gvk, err = t.ObjectKind(obj)
- if err == nil {
- return
- }
- }
- return
-}
-
-func (m MultiObjectTyper) ObjectKinds(obj Object) (gvks []unversioned.GroupVersionKind, err error) {
- for _, t := range m {
- gvks, err = t.ObjectKinds(obj)
- if err == nil {
- return
- }
- }
- return
-}
-
-func (m MultiObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
- for _, t := range m {
- if t.Recognizes(gvk) {
- return true
- }
- }
- return false
-}
-
-func (m MultiObjectTyper) IsUnversioned(obj Object) (bool, bool) {
- for _, t := range m {
- if unversioned, ok := t.IsUnversioned(obj); ok {
- return unversioned, true
- }
- }
- return false, false
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go
deleted file mode 100644
index 6f6310d9c83a555d91ea303d463654d844f4d41b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 serializer
-
-import (
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/runtime/serializer/json"
- "k8s.io/kubernetes/pkg/runtime/serializer/recognizer"
- "k8s.io/kubernetes/pkg/runtime/serializer/versioning"
-)
-
-type serializerType struct {
- AcceptContentTypes []string
- ContentType string
- FileExtensions []string
- Serializer runtime.Serializer
- PrettySerializer runtime.Serializer
-}
-
-// NewCodecFactory provides methods for retrieving serializers for the supported wire formats
-// and conversion wrappers to define preferred internal and external versions. In the future,
-// as the internal version is used less, callers may instead use a defaulting serializer and
-// only convert objects which are shared internally (Status, common API machinery).
-// TODO: allow other codecs to be compiled in?
-// TODO: accept a scheme interface
-func NewCodecFactory(scheme *runtime.Scheme) CodecFactory {
- return newCodecFactory(scheme, json.DefaultMetaFactory)
-}
-
-// newCodecFactory is a helper for testing that allows a different metafactory to be specified.
-func newCodecFactory(scheme *runtime.Scheme, mf json.MetaFactory) CodecFactory {
- jsonSerializer := json.NewSerializer(mf, scheme, runtime.ObjectTyperToTyper(scheme), false)
- jsonPrettySerializer := json.NewSerializer(mf, scheme, runtime.ObjectTyperToTyper(scheme), true)
- yamlSerializer := json.NewYAMLSerializer(mf, scheme, runtime.ObjectTyperToTyper(scheme))
- serializers := []serializerType{
- {
- AcceptContentTypes: []string{"application/json"},
- ContentType: "application/json",
- FileExtensions: []string{"json"},
- Serializer: jsonSerializer,
- PrettySerializer: jsonPrettySerializer,
- },
- {
- AcceptContentTypes: []string{"application/yaml"},
- ContentType: "application/yaml",
- FileExtensions: []string{"yaml"},
- Serializer: yamlSerializer,
- },
- }
- decoders := make([]runtime.Decoder, 0, len(serializers))
- accepts := []string{}
- alreadyAccepted := make(map[string]struct{})
- for _, d := range serializers {
- decoders = append(decoders, d.Serializer)
- for _, mediaType := range d.AcceptContentTypes {
- if _, ok := alreadyAccepted[mediaType]; ok {
- continue
- }
- alreadyAccepted[mediaType] = struct{}{}
- accepts = append(accepts, mediaType)
- }
- }
- return CodecFactory{
- scheme: scheme,
- serializers: serializers,
- universal: recognizer.NewDecoder(decoders...),
- accepts: accepts,
-
- legacySerializer: jsonSerializer,
- }
-}
-
-// CodecFactory provides methods for retrieving codecs and serializers for specific
-// versions and content types.
-type CodecFactory struct {
- scheme *runtime.Scheme
- serializers []serializerType
- universal runtime.Decoder
- accepts []string
-
- legacySerializer runtime.Serializer
-}
-
-var _ runtime.NegotiatedSerializer = &CodecFactory{}
-
-// SupportedMediaTypes returns the RFC2046 media types that this factory has serializers for.
-func (f CodecFactory) SupportedMediaTypes() []string {
- return f.accepts
-}
-
-// LegacyCodec encodes output to a given API version, and decodes output into the internal form from
-// any recognized source. The returned codec will always encode output to JSON.
-//
-// This method is deprecated - clients and servers should negotiate a serializer by mime-type and
-// invoke CodecForVersions. Callers that need only to read data should use UniversalDecoder().
-func (f CodecFactory) LegacyCodec(version ...unversioned.GroupVersion) runtime.Codec {
- return f.CodecForVersions(runtime.NewCodec(f.legacySerializer, f.universal), version, nil)
-}
-
-// UniversalDeserializer can convert any stored data recognized by this factory into a Go object that satisfies
-// runtime.Object. It does not perform conversion. It does not perform defaulting.
-func (f CodecFactory) UniversalDeserializer() runtime.Decoder {
- return f.universal
-}
-
-// UniversalDecoder returns a runtime.Decoder capable of decoding all known API objects in all known formats. Used
-// by clients that do not need to encode objects but want to deserialize API objects stored on disk. Only decodes
-// objects in groups registered with the scheme. The GroupVersions passed may be used to select alternate
-// versions of objects to return - by default, runtime.APIVersionInternal is used. If any versions are specified,
-// unrecognized groups will be returned in the version they are encoded as (no conversion). This decoder performs
-// defaulting.
-//
-// TODO: the decoder will eventually be removed in favor of dealing with objects in their versioned form
-func (f CodecFactory) UniversalDecoder(versions ...unversioned.GroupVersion) runtime.Decoder {
- return f.CodecForVersions(runtime.NoopEncoder{f.universal}, nil, versions)
-}
-
-// CodecFor creates a codec with the provided serializer. If an object is decoded and its group is not in the list,
-// it will default to runtime.APIVersionInternal. If encode is not specified for an object's group, the object is not
-// converted. If encode or decode are nil, no conversion is performed.
-func (f CodecFactory) CodecForVersions(serializer runtime.Serializer, encode []unversioned.GroupVersion, decode []unversioned.GroupVersion) runtime.Codec {
- return versioning.NewCodecForScheme(f.scheme, serializer, encode, decode)
-}
-
-// DecoderToVersion returns a decoder that targets the provided group version.
-func (f CodecFactory) DecoderToVersion(serializer runtime.Serializer, gv unversioned.GroupVersion) runtime.Decoder {
- return f.CodecForVersions(serializer, nil, []unversioned.GroupVersion{gv})
-}
-
-// EncoderForVersion returns an encoder that targets the provided group version.
-func (f CodecFactory) EncoderForVersion(serializer runtime.Serializer, gv unversioned.GroupVersion) runtime.Encoder {
- return f.CodecForVersions(serializer, []unversioned.GroupVersion{gv}, nil)
-}
-
-// SerializerForMediaType returns a serializer that matches the provided RFC2046 mediaType, or false if no such
-// serializer exists
-func (f CodecFactory) SerializerForMediaType(mediaType string, options map[string]string) (runtime.Serializer, bool) {
- for _, s := range f.serializers {
- for _, accepted := range s.AcceptContentTypes {
- if accepted == mediaType {
- if v, ok := options["pretty"]; ok && v == "1" && s.PrettySerializer != nil {
- return s.PrettySerializer, true
- }
- return s.Serializer, true
- }
- }
- }
- return nil, false
-}
-
-// SerializerForFileExtension returns a serializer for the provided extension, or false if no serializer matches.
-func (f CodecFactory) SerializerForFileExtension(extension string) (runtime.Serializer, bool) {
- for _, s := range f.serializers {
- for _, ext := range s.FileExtensions {
- if extension == ext {
- return s.Serializer, true
- }
- }
- }
- return nil, false
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go
deleted file mode 100644
index 14a2cb3e841f9f0e488b18f7f8dd5dc21e53e1f9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 recognizer
-
-import (
- "bytes"
- "fmt"
- "io"
-
- "k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/runtime"
-)
-
-type RecognizingDecoder interface {
- runtime.Decoder
- RecognizesData(peek io.Reader) (bool, error)
-}
-
-func NewDecoder(decoders ...runtime.Decoder) runtime.Decoder {
- recognizing, blind := []RecognizingDecoder{}, []runtime.Decoder{}
- for _, d := range decoders {
- if r, ok := d.(RecognizingDecoder); ok {
- recognizing = append(recognizing, r)
- } else {
- blind = append(blind, d)
- }
- }
- return &decoder{
- recognizing: recognizing,
- blind: blind,
- }
-}
-
-type decoder struct {
- recognizing []RecognizingDecoder
- blind []runtime.Decoder
-}
-
-func (d *decoder) Decode(data []byte, gvk *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
- var lastErr error
- for _, r := range d.recognizing {
- buf := bytes.NewBuffer(data)
- ok, err := r.RecognizesData(buf)
- if err != nil {
- lastErr = err
- continue
- }
- if !ok {
- continue
- }
- return r.Decode(data, gvk, into)
- }
- for _, d := range d.blind {
- out, actual, err := d.Decode(data, gvk, into)
- if err != nil {
- lastErr = err
- continue
- }
- return out, actual, nil
- }
- if lastErr == nil {
- lastErr = fmt.Errorf("no serialization format matched the provided data")
- }
- return nil, nil, lastErr
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/types.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/types.go
deleted file mode 100644
index c2007cc92ee96b9d639291a0273bd40a1d4678d9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/types.go
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 runtime
-
-// Note that the types provided in this file are not versioned and are intended to be
-// safe to use from within all versions of every API object.
-
-// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
-// like this:
-// type MyAwesomeAPIObject struct {
-// runtime.TypeMeta `json:",inline"`
-// ... // other fields
-// }
-// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *unversioned.GroupVersionKind) { unversioned.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
-//
-// TypeMeta is provided here for convenience. You may use it directly from this package or define
-// your own with the same fields.
-//
-// +protobuf=true
-type TypeMeta struct {
- APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty"`
- Kind string `json:"kind,omitempty" yaml:"kind,omitempty"`
-}
-
-// 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.)
-//
-// +protobuf=true
-type RawExtension struct {
- // RawJSON is the underlying serialization of this object.
- RawJSON []byte
- // Object can hold a representation of this extension - useful for working with versioned
- // structs.
- Object Object `json:"-"`
-}
-
-// Unknown allows api objects with unknown types to be passed-through. This can be used
-// to deal with the API objects from a plug-in. Unknown objects still have functioning
-// TypeMeta features-- kind, version, etc.
-// TODO: Make this object have easy access to field based accessors and settors for
-// metadata and field mutatation.
-//
-// +protobuf=true
-type Unknown struct {
- TypeMeta `json:",inline"`
- // RawJSON will hold the complete JSON of the object which couldn't be matched
- // with a registered type. Most likely, nothing should be done with this
- // except for passing it through the system.
- RawJSON []byte
-}
-
-// Unstructured allows objects that do not have Golang structs registered to be manipulated
-// generically. This can be used to deal with the API objects from a plug-in. Unstructured
-// objects still have functioning TypeMeta features-- kind, version, etc.
-// TODO: Make this object have easy access to field based accessors and settors for
-// metadata and field mutatation.
-type Unstructured struct {
- TypeMeta `json:",inline"`
-
- // Name is populated from metadata (if present) upon deserialization
- Name string
-
- // Object is a JSON compatible map with string, float, int, []interface{}, or map[string]interface{}
- // children.
- Object map[string]interface{}
-}
-
-// UnstructuredList allows lists that do not have Golang structs
-// registered to be manipulated generically. This can be used to deal
-// with the API lists from a plug-in.
-type UnstructuredList struct {
- TypeMeta `json:",inline"`
-
- // Items is a list of unstructured objects.
- Items []*Unstructured `json:"items"`
-}
-
-// VersionedObjects is used by Decoders to give callers a way to access all versions
-// of an object during the decoding process.
-type VersionedObjects struct {
- // Objects is the set of objects retrieved during decoding, in order of conversion.
- // The 0 index is the object as serialized on the wire. If conversion has occurred,
- // other objects may be present. The right most object is the same as would be returned
- // by a normal Decode call.
- Objects []Object
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/bool_flag.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/bool_flag.go
deleted file mode 100644
index 768fc30350b61dbbb37313ccd2338ed903cb9664..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/bool_flag.go
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "fmt"
- "strconv"
-)
-
-// BoolFlag is a boolean flag compatible with flags and pflags that keeps track of whether it had a value supplied or not.
-// Getting this flag to act like a normal bool, where true/false are not required needs a little bit of extra code, example:
-// f := cmd.Flags().VarPF(&BoolFlagVar, "flagname", "", "help about the flag")
-// f.NoOptDefVal = "true"
-type BoolFlag struct {
- // If Set has been invoked this value is true
- provided bool
- // The exact value provided on the flag
- value bool
-}
-
-func (f *BoolFlag) Default(value bool) {
- f.value = value
-}
-
-func (f BoolFlag) String() string {
- return fmt.Sprintf("%t", f.value)
-}
-
-func (f BoolFlag) Value() bool {
- return f.value
-}
-
-func (f *BoolFlag) Set(value string) error {
- boolVal, err := strconv.ParseBool(value)
- if err != nil {
- return err
- }
-
- f.value = boolVal
- f.provided = true
-
- return nil
-}
-
-func (f BoolFlag) Provided() bool {
- return f.provided
-}
-
-func (f *BoolFlag) Type() string {
- return "bool"
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/cache.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/cache.go
deleted file mode 100644
index 47e30ca31d097610980cc9cce7e1434529dbece5..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/cache.go
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "sync"
-)
-
-const (
- shardsCount int = 32
-)
-
-type Cache []*cacheShard
-
-func NewCache(maxSize int) Cache {
- cache := make(Cache, shardsCount)
- for i := 0; i < shardsCount; i++ {
- cache[i] = &cacheShard{
- items: make(map[uint64]interface{}),
- maxSize: maxSize / shardsCount,
- }
- }
- return cache
-}
-
-func (c Cache) getShard(index uint64) *cacheShard {
- return c[index%uint64(shardsCount)]
-}
-
-// Returns true if object already existed, false otherwise.
-func (c *Cache) Add(index uint64, obj interface{}) bool {
- return c.getShard(index).add(index, obj)
-}
-
-func (c *Cache) Get(index uint64) (obj interface{}, found bool) {
- return c.getShard(index).get(index)
-}
-
-type cacheShard struct {
- items map[uint64]interface{}
- sync.RWMutex
- maxSize int
-}
-
-// Returns true if object already existed, false otherwise.
-func (s *cacheShard) add(index uint64, obj interface{}) bool {
- s.Lock()
- defer s.Unlock()
- _, isOverwrite := s.items[index]
- s.items[index] = obj
- if len(s.items) > s.maxSize {
- var randomKey uint64
- for randomKey = range s.items {
- break
- }
- delete(s.items, randomKey)
- }
- return isOverwrite
-}
-
-func (s *cacheShard) get(index uint64) (obj interface{}, found bool) {
- s.RLock()
- defer s.RUnlock()
- obj, found = s.items[index]
- return
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/configuration_map.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/configuration_map.go
deleted file mode 100644
index cf2b326a9085d4e1ddd12703168e18804f164de9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/configuration_map.go
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "fmt"
- "sort"
- "strings"
-)
-
-type ConfigurationMap map[string]string
-
-func (m *ConfigurationMap) String() string {
- pairs := []string{}
- for k, v := range *m {
- pairs = append(pairs, fmt.Sprintf("%s=%s", k, v))
- }
- sort.Strings(pairs)
- return strings.Join(pairs, ",")
-}
-
-func (m *ConfigurationMap) Set(value string) error {
- for _, s := range strings.Split(value, ",") {
- if len(s) == 0 {
- continue
- }
- arr := strings.SplitN(s, "=", 2)
- if len(arr) == 2 {
- (*m)[strings.TrimSpace(arr[0])] = strings.TrimSpace(arr[1])
- } else {
- (*m)[strings.TrimSpace(arr[0])] = ""
- }
- }
- return nil
-}
-
-func (*ConfigurationMap) Type() string {
- return "mapStringString"
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crlf.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crlf.go
deleted file mode 100644
index 935785ce974b1d6116690290982d90a202cd28d8..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crlf.go
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "bytes"
- "io"
-)
-
-type crlfWriter struct {
- io.Writer
-}
-
-// NewCRLFWriter implements a CR/LF line ending writer used for normalizing
-// text for Windows platforms.
-func NewCRLFWriter(w io.Writer) io.Writer {
- return crlfWriter{w}
-}
-
-func (w crlfWriter) Write(b []byte) (n int, err error) {
- for i, written := 0, 0; ; {
- next := bytes.Index(b[i:], []byte("\n"))
- if next == -1 {
- n, err := w.Writer.Write(b[i:])
- return written + n, err
- }
- next = next + i
- n, err := w.Writer.Write(b[i:next])
- if err != nil {
- return written + n, err
- }
- written += n
- n, err = w.Writer.Write([]byte("\r\n"))
- if err != nil {
- if n > 1 {
- n = 1
- }
- return written + n, err
- }
- written += 1
- i = next + 1
- }
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deadlock-detector.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deadlock-detector.go
deleted file mode 100644
index b89fb23de3edcacd1bed4ec7a354c0c7e35f5c80..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deadlock-detector.go
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "os"
- "sync"
- "time"
-
- "github.com/golang/glog"
-)
-
-type rwMutexToLockableAdapter struct {
- rw *sync.RWMutex
-}
-
-func (r *rwMutexToLockableAdapter) Lock() {
- r.rw.RLock()
-}
-
-func (r *rwMutexToLockableAdapter) Unlock() {
- r.rw.RUnlock()
-}
-
-type deadlockDetector struct {
- name string
- lock sync.Locker
- maxLockPeriod time.Duration
- exiter exiter
- exitChannelFn func() <-chan time.Time
- // Really only useful for testing
- stopChannel <-chan bool
-}
-
-// DeadlockWatchdogReadLock creates a watchdog on read/write mutex. If the mutex can not be acquired
-// for read access within 'maxLockPeriod', the program exits via glog.Exitf() or os.Exit() if that fails
-// 'name' is a semantic name that is useful for the user and is printed on exit.
-func DeadlockWatchdogReadLock(lock *sync.RWMutex, name string, maxLockPeriod time.Duration) {
- DeadlockWatchdog(&rwMutexToLockableAdapter{lock}, name, maxLockPeriod)
-}
-
-func DeadlockWatchdog(lock sync.Locker, name string, maxLockPeriod time.Duration) {
- if maxLockPeriod <= 0 {
- panic("maxLockPeriod is <= 0, that can't be what you wanted")
- }
- detector := &deadlockDetector{
- lock: lock,
- name: name,
- maxLockPeriod: maxLockPeriod,
- exitChannelFn: func() <-chan time.Time { return time.After(maxLockPeriod) },
- stopChannel: make(chan bool),
- }
- go detector.run()
-}
-
-// Useful for injecting tests
-type exiter interface {
- Exitf(format string, args ...interface{})
-}
-
-type realExiter struct{}
-
-func (realExiter) Exitf(format string, args ...interface{}) {
- func() {
- defer func() {
- // Let's just be extra sure we die, even if Exitf panics
- if r := recover(); r != nil {
- glog.Errorf(format, args...)
- os.Exit(2)
- }
- }()
- glog.Exitf(format, args...)
- }()
-}
-
-func (d *deadlockDetector) run() {
- for {
- if !d.runOnce() {
- return
- }
- time.Sleep(d.maxLockPeriod / 2)
- }
-}
-
-func (d *deadlockDetector) runOnce() bool {
- ch := make(chan bool, 1)
- go func() {
- d.lock.Lock()
- d.lock.Unlock()
-
- ch <- true
- }()
- exitCh := d.exitChannelFn()
- select {
- case <-exitCh:
- d.exiter.Exitf("Deadlock on %s, exiting", d.name)
- // return is here for when we use a fake exiter in testing
- return false
- case <-ch:
- glog.V(6).Infof("%s is not deadlocked", d.name)
- case <-d.stopChannel:
- glog.V(4).Infof("Stopping deadlock detector for %s", d.name)
- return false
- }
- return true
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/diff.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/diff.go
deleted file mode 100644
index 4e203cb937237c43a3524a874132fdf21d5a7613..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/diff.go
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "bytes"
- "encoding/json"
- "fmt"
- "strings"
- "text/tabwriter"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-// StringDiff diffs a and b and returns a human readable diff.
-func StringDiff(a, b string) string {
- ba := []byte(a)
- bb := []byte(b)
- out := []byte{}
- i := 0
- for ; i < len(ba) && i < len(bb); i++ {
- if ba[i] != bb[i] {
- break
- }
- out = append(out, ba[i])
- }
- out = append(out, []byte("\n\nA: ")...)
- out = append(out, ba[i:]...)
- out = append(out, []byte("\n\nB: ")...)
- out = append(out, bb[i:]...)
- out = append(out, []byte("\n\n")...)
- return string(out)
-}
-
-// ObjectDiff writes the two objects out as JSON and prints out the identical part of
-// the objects followed by the remaining part of 'a' and finally the remaining part of 'b'.
-// For debugging tests.
-func ObjectDiff(a, b interface{}) string {
- ab, err := json.Marshal(a)
- if err != nil {
- panic(fmt.Sprintf("a: %v", err))
- }
- bb, err := json.Marshal(b)
- if err != nil {
- panic(fmt.Sprintf("b: %v", err))
- }
- return StringDiff(string(ab), string(bb))
-}
-
-// ObjectGoPrintDiff is like ObjectDiff, but uses go-spew to print the objects,
-// which shows absolutely everything by recursing into every single pointer
-// (go's %#v formatters OTOH stop at a certain point). This is needed when you
-// can't figure out why reflect.DeepEqual is returning false and nothing is
-// showing you differences. This will.
-func ObjectGoPrintDiff(a, b interface{}) string {
- s := spew.ConfigState{DisableMethods: true}
- return StringDiff(
- s.Sprintf("%#v", a),
- s.Sprintf("%#v", b),
- )
-}
-
-// ObjectGoPrintSideBySide prints a and b as textual dumps side by side,
-// enabling easy visual scanning for mismatches.
-func ObjectGoPrintSideBySide(a, b interface{}) string {
- s := spew.ConfigState{
- Indent: " ",
- // Extra deep spew.
- DisableMethods: true,
- }
- sA := s.Sdump(a)
- sB := s.Sdump(b)
-
- linesA := strings.Split(sA, "\n")
- linesB := strings.Split(sB, "\n")
- width := 0
- for _, s := range linesA {
- l := len(s)
- if l > width {
- width = l
- }
- }
- for _, s := range linesB {
- l := len(s)
- if l > width {
- width = l
- }
- }
- buf := &bytes.Buffer{}
- w := tabwriter.NewWriter(buf, width, 0, 1, ' ', 0)
- max := len(linesA)
- if len(linesB) > max {
- max = len(linesB)
- }
- for i := 0; i < max; i++ {
- var a, b string
- if i < len(linesA) {
- a = linesA[i]
- }
- if i < len(linesB) {
- b = linesB[i]
- }
- fmt.Fprintf(w, "%s\t%s\n", a, b)
- }
- w.Flush()
- return buf.String()
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/env.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/env.go
deleted file mode 100644
index 6a479bd949993cd93947e2a4bf364e8a814059f9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/env.go
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- "os"
- "strconv"
-)
-
-func GetEnvAsStringOrFallback(key, defaultValue string) string {
- if v := os.Getenv(key); v != "" {
- return v
- }
- return defaultValue
-}
-
-func GetEnvAsIntOrFallback(key string, defaultValue int) (int, error) {
- if v := os.Getenv(key); v != "" {
- value, err := strconv.Atoi(v)
- if err != nil {
- return defaultValue, err
- }
- return value, nil
- }
- return defaultValue, nil
-}
-
-func GetEnvAsFloat64OrFallback(key string, defaultValue float64) (float64, error) {
- if v := os.Getenv(key); v != "" {
- value, err := strconv.ParseFloat(v, 64)
- if err != nil {
- return defaultValue, err
- }
- return value, nil
- }
- return defaultValue, nil
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/flags.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/flags.go
deleted file mode 100644
index 3d5799243cf19af87a4f9a3961e5ff1348130a07..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/flags.go
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 util
-
-import (
- goflag "flag"
- "strings"
-
- "github.com/golang/glog"
- "github.com/spf13/pflag"
-)
-
-// WordSepNormalizeFunc changes all flags that contain "_" separators
-func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
- if strings.Contains(name, "_") {
- return pflag.NormalizedName(strings.Replace(name, "_", "-", -1))
- }
- return pflag.NormalizedName(name)
-}
-
-// WarnWordSepNormalizeFunc changes and warns for flags that contain "_" separators
-func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
- if strings.Contains(name, "_") {
- nname := strings.Replace(name, "_", "-", -1)
- glog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", name, nname)
-
- return pflag.NormalizedName(nname)
- }
- return pflag.NormalizedName(name)
-}
-
-// InitFlags normalizes and parses the command line flags
-func InitFlags() {
- pflag.CommandLine.SetNormalizeFunc(WordSepNormalizeFunc)
- pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
- pflag.Parse()
-}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/types.go b/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/types.go
deleted file mode 100644
index 28ee0dec75f32235ffe82f0e0216034566187d6a..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/types.go
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 json
-
-import (
- "encoding/json"
- "fmt"
- "reflect"
-
- "k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/watch"
-)
-
-// WatchEvent objects are streamed from the api server in response to a watch request.
-// These are not API objects and may not be changed in a backward-incompatible way.
-// TODO: move to a public, versioned object now that RawExtension conversions are possible
-// in the schema.
-type WatchEvent struct {
- // The type of the watch event; added, modified, deleted, or error.
- Type watch.EventType `json:"type,omitempty" description:"the type of watch event; may be ADDED, MODIFIED, DELETED, or ERROR"`
-
- // For added or modified objects, this is the new object; for deleted objects,
- // it's the state of the object immediately prior to its deletion.
- // For errors, it's an api.Status.
- Object runtime.RawExtension `json:"object,omitempty" description:"the object being watched; will match the type of the resource endpoint or be a Status object if the type is ERROR"`
-}
-
-// Object converts a watch.Event into an appropriately serializable JSON object
-func Object(encoder runtime.Encoder, event *watch.Event) (interface{}, error) {
- obj, ok := event.Object.(runtime.Object)
- if !ok {
- return nil, fmt.Errorf("the event object cannot be safely converted to JSON: %v", reflect.TypeOf(event.Object).Name())
- }
- data, err := runtime.Encode(encoder, obj)
- if err != nil {
- return nil, err
- }
- return &WatchEvent{event.Type, runtime.RawExtension{RawJSON: json.RawMessage(data)}}, nil
-}
diff --git a/Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/LICENSE b/Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/LICENSE
deleted file mode 100644
index efa1aa1896a5d6459b5c980d3bb02afa426797f2..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/LICENSE
+++ /dev/null
@@ -1,57 +0,0 @@
-Copyright (c) 2012 Péter Surányi. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-Portions of inf.Dec's source code have been derived from Go and are
-covered by the following license:
-----------------------------------------------------------------------
-
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/executors/kubernetes/exec.go b/executors/kubernetes/exec.go
index 3683b39adb8ed71d1c4f97ad4dc7b75669b6bd64..64307844f0f6b40b6dfbdb7b444a4697292f0604 100644
--- a/executors/kubernetes/exec.go
+++ b/executors/kubernetes/exec.go
@@ -23,6 +23,7 @@ import (
"k8s.io/kubernetes/pkg/client/restclient"
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
+ kubelet_remotecommand "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
)
// RemoteExecutor defines the interface accepted by the Exec command - provided for test stubbing
@@ -38,7 +39,8 @@ func (*DefaultRemoteExecutor) Execute(method string, url *url.URL, config *restc
if err != nil {
return err
}
- return exec.Stream(stdin, stdout, stderr, tty)
+
+ return exec.Stream([]string{kubelet_remotecommand.StreamProtocolV1Name}, stdin, stdout, stderr, tty)
}
// ExecOptions declare the arguments accepted by the Exec command
diff --git a/executors/kubernetes/util.go b/executors/kubernetes/util.go
index b1dd22e44a5117be45e9b29577a4bf16e8cddf33..17411700aa75465664bb9a242d514fa0f7527147 100644
--- a/executors/kubernetes/util.go
+++ b/executors/kubernetes/util.go
@@ -99,16 +99,16 @@ func waitForPodRunning(ctx context.Context, c *client.Client, pod *api.Pod, out
// values for Kubernetes. This allows users to write "500m" for CPU,
// and "50Mi" for memory (etc.)
func limits(cpu, memory string) (api.ResourceList, error) {
- var rCPU, rMem *resource.Quantity
+ var rCPU, rMem resource.Quantity
var err error
- parse := func(s string) (*resource.Quantity, error) {
- var q *resource.Quantity
+ parse := func(s string) (resource.Quantity, error) {
+ var q resource.Quantity
if len(s) == 0 {
return q, nil
}
if q, err = resource.ParseQuantity(s); err != nil {
- return nil, fmt.Errorf("error parsing resource limit: %s", err.Error())
+ return q, fmt.Errorf("error parsing resource limit: %s", err.Error())
}
return q, nil
}
@@ -123,11 +123,12 @@ func limits(cpu, memory string) (api.ResourceList, error) {
l := make(api.ResourceList)
- if rCPU != nil {
- l[api.ResourceLimitsCPU] = *rCPU
+ q := resource.Quantity{}
+ if rCPU != q {
+ l[api.ResourceLimitsCPU] = rCPU
}
- if rMem != nil {
- l[api.ResourceLimitsMemory] = *rMem
+ if rMem != q {
+ l[api.ResourceLimitsMemory] = rMem
}
return l, nil
diff --git a/vendor/github.com/beorn7/perks/LICENSE b/vendor/github.com/beorn7/perks/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..339177be663638902a2fa9f9efe8433e4473c1a4
--- /dev/null
+++ b/vendor/github.com/beorn7/perks/LICENSE
@@ -0,0 +1,20 @@
+Copyright (C) 2013 Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/beorn7/perks/quantile/exampledata.txt b/vendor/github.com/beorn7/perks/quantile/exampledata.txt
similarity index 100%
rename from Godeps/_workspace/src/github.com/beorn7/perks/quantile/exampledata.txt
rename to vendor/github.com/beorn7/perks/quantile/exampledata.txt
diff --git a/Godeps/_workspace/src/github.com/beorn7/perks/quantile/stream.go b/vendor/github.com/beorn7/perks/quantile/stream.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/beorn7/perks/quantile/stream.go
rename to vendor/github.com/beorn7/perks/quantile/stream.go
index 587b1fc5ba86281ec38b1f3ec41ab2bba0840ae3..f4cabd66956723454f73ca43c500a4a7a2aebf2a 100644
--- a/Godeps/_workspace/src/github.com/beorn7/perks/quantile/stream.go
+++ b/vendor/github.com/beorn7/perks/quantile/stream.go
@@ -133,7 +133,7 @@ func (s *Stream) Query(q float64) float64 {
if l == 0 {
return 0
}
- i := int(float64(l) * q)
+ i := int(math.Ceil(float64(l) * q))
if i > 0 {
i -= 1
}
diff --git a/Godeps/_workspace/src/github.com/blang/semver/LICENSE b/vendor/github.com/blang/semver/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/blang/semver/LICENSE
rename to vendor/github.com/blang/semver/LICENSE
diff --git a/Godeps/_workspace/src/github.com/blang/semver/README.md b/vendor/github.com/blang/semver/README.md
similarity index 50%
rename from Godeps/_workspace/src/github.com/blang/semver/README.md
rename to vendor/github.com/blang/semver/README.md
index 5171c5c55713940d8bb6be3f9daf7f54b1d74564..4399639e230f189074e5334c94f72d267d9eb1f3 100644
--- a/Godeps/_workspace/src/github.com/blang/semver/README.md
+++ b/vendor/github.com/blang/semver/README.md
@@ -40,10 +40,52 @@ Features
- Comparator-like comparisons
- Compare Helper Methods
- InPlace manipulation
+- Ranges `>=1.0.0 <2.0.0 || >=3.0.0 !3.0.1-beta.1`
- Sortable (implements sort.Interface)
- database/sql compatible (sql.Scanner/Valuer)
- encoding/json compatible (json.Marshaler/Unmarshaler)
+Ranges
+------
+
+A `Range` is a set of conditions which specify which versions satisfy the range.
+
+A condition is composed of an operator and a version. The supported operators are:
+
+- `<1.0.0` Less than `1.0.0`
+- `<=1.0.0` Less than or equal to `1.0.0`
+- `>1.0.0` Greater than `1.0.0`
+- `>=1.0.0` Greater than or equal to `1.0.0`
+- `1.0.0`, `=1.0.0`, `==1.0.0` Equal to `1.0.0`
+- `!1.0.0`, `!=1.0.0` Not equal to `1.0.0`. Excludes version `1.0.0`.
+
+A `Range` can link multiple `Ranges` separated by space:
+
+Ranges can be linked by logical AND:
+
+ - `>1.0.0 <2.0.0` would match between both ranges, so `1.1.1` and `1.8.7` but not `1.0.0` or `2.0.0`
+ - `>1.0.0 <3.0.0 !2.0.3-beta.2` would match every version between `1.0.0` and `3.0.0` except `2.0.3-beta.2`
+
+Ranges can also be linked by logical OR:
+
+ - `<2.0.0 || >=3.0.0` would match `1.x.x` and `3.x.x` but not `2.x.x`
+
+AND has a higher precedence than OR. It's not possible to use brackets.
+
+Ranges can be combined by both AND and OR
+
+ - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1`
+
+Range usage:
+
+```
+v, err := semver.Parse("1.2.3")
+range, err := semver.ParseRange(">1.0.0 <2.0.0 || >=3.0.0")
+if range(v) {
+ //valid
+}
+
+```
Example
-----
@@ -103,23 +145,30 @@ if err != nil {
}
```
+
Benchmarks
-----
- BenchmarkParseSimple 5000000 328 ns/op 49 B/op 1 allocs/op
- BenchmarkParseComplex 1000000 2105 ns/op 263 B/op 7 allocs/op
- BenchmarkParseAverage 1000000 1301 ns/op 168 B/op 4 allocs/op
- BenchmarkStringSimple 10000000 130 ns/op 5 B/op 1 allocs/op
- BenchmarkStringLarger 5000000 280 ns/op 32 B/op 2 allocs/op
- BenchmarkStringComplex 3000000 512 ns/op 80 B/op 3 allocs/op
- BenchmarkStringAverage 5000000 387 ns/op 47 B/op 2 allocs/op
- BenchmarkValidateSimple 500000000 7.92 ns/op 0 B/op 0 allocs/op
- BenchmarkValidateComplex 2000000 923 ns/op 0 B/op 0 allocs/op
- BenchmarkValidateAverage 5000000 452 ns/op 0 B/op 0 allocs/op
- BenchmarkCompareSimple 100000000 11.2 ns/op 0 B/op 0 allocs/op
- BenchmarkCompareComplex 50000000 40.9 ns/op 0 B/op 0 allocs/op
- BenchmarkCompareAverage 50000000 43.8 ns/op 0 B/op 0 allocs/op
- BenchmarkSort 5000000 436 ns/op 259 B/op 2 allocs/op
+ BenchmarkParseSimple-4 5000000 390 ns/op 48 B/op 1 allocs/op
+ BenchmarkParseComplex-4 1000000 1813 ns/op 256 B/op 7 allocs/op
+ BenchmarkParseAverage-4 1000000 1171 ns/op 163 B/op 4 allocs/op
+ BenchmarkStringSimple-4 20000000 119 ns/op 16 B/op 1 allocs/op
+ BenchmarkStringLarger-4 10000000 206 ns/op 32 B/op 2 allocs/op
+ BenchmarkStringComplex-4 5000000 324 ns/op 80 B/op 3 allocs/op
+ BenchmarkStringAverage-4 5000000 273 ns/op 53 B/op 2 allocs/op
+ BenchmarkValidateSimple-4 200000000 9.33 ns/op 0 B/op 0 allocs/op
+ BenchmarkValidateComplex-4 3000000 469 ns/op 0 B/op 0 allocs/op
+ BenchmarkValidateAverage-4 5000000 256 ns/op 0 B/op 0 allocs/op
+ BenchmarkCompareSimple-4 100000000 11.8 ns/op 0 B/op 0 allocs/op
+ BenchmarkCompareComplex-4 50000000 30.8 ns/op 0 B/op 0 allocs/op
+ BenchmarkCompareAverage-4 30000000 41.5 ns/op 0 B/op 0 allocs/op
+ BenchmarkSort-4 3000000 419 ns/op 256 B/op 2 allocs/op
+ BenchmarkRangeParseSimple-4 2000000 850 ns/op 192 B/op 5 allocs/op
+ BenchmarkRangeParseAverage-4 1000000 1677 ns/op 400 B/op 10 allocs/op
+ BenchmarkRangeParseComplex-4 300000 5214 ns/op 1440 B/op 30 allocs/op
+ BenchmarkRangeMatchSimple-4 50000000 25.6 ns/op 0 B/op 0 allocs/op
+ BenchmarkRangeMatchAverage-4 30000000 56.4 ns/op 0 B/op 0 allocs/op
+ BenchmarkRangeMatchComplex-4 10000000 153 ns/op 0 B/op 0 allocs/op
See benchmark cases at [semver_test.go](semver_test.go)
diff --git a/Godeps/_workspace/src/github.com/blang/semver/json.go b/vendor/github.com/blang/semver/json.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/blang/semver/json.go
rename to vendor/github.com/blang/semver/json.go
diff --git a/vendor/github.com/blang/semver/range.go b/vendor/github.com/blang/semver/range.go
new file mode 100644
index 0000000000000000000000000000000000000000..238e1312d5e07f92c88f8a503cdc3cd64cad9671
--- /dev/null
+++ b/vendor/github.com/blang/semver/range.go
@@ -0,0 +1,233 @@
+package semver
+
+import (
+ "fmt"
+ "strings"
+ "unicode"
+)
+
+type comparator func(Version, Version) bool
+
+var (
+ compEQ comparator = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) == 0
+ }
+ compNE = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) != 0
+ }
+ compGT = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) == 1
+ }
+ compGE = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) >= 0
+ }
+ compLT = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) == -1
+ }
+ compLE = func(v1 Version, v2 Version) bool {
+ return v1.Compare(v2) <= 0
+ }
+)
+
+type versionRange struct {
+ v Version
+ c comparator
+}
+
+// rangeFunc creates a Range from the given versionRange.
+func (vr *versionRange) rangeFunc() Range {
+ return Range(func(v Version) bool {
+ return vr.c(v, vr.v)
+ })
+}
+
+// Range represents a range of versions.
+// A Range can be used to check if a Version satisfies it:
+//
+// range, err := semver.ParseRange(">1.0.0 <2.0.0")
+// range(semver.MustParse("1.1.1") // returns true
+type Range func(Version) bool
+
+// OR combines the existing Range with another Range using logical OR.
+func (rf Range) OR(f Range) Range {
+ return Range(func(v Version) bool {
+ return rf(v) || f(v)
+ })
+}
+
+// AND combines the existing Range with another Range using logical AND.
+func (rf Range) AND(f Range) Range {
+ return Range(func(v Version) bool {
+ return rf(v) && f(v)
+ })
+}
+
+// ParseRange parses a range and returns a Range.
+// If the range could not be parsed an error is returned.
+//
+// Valid ranges are:
+// - "<1.0.0"
+// - "<=1.0.0"
+// - ">1.0.0"
+// - ">=1.0.0"
+// - "1.0.0", "=1.0.0", "==1.0.0"
+// - "!1.0.0", "!=1.0.0"
+//
+// A Range can consist of multiple ranges separated by space:
+// Ranges can be linked by logical AND:
+// - ">1.0.0 <2.0.0" would match between both ranges, so "1.1.1" and "1.8.7" but not "1.0.0" or "2.0.0"
+// - ">1.0.0 <3.0.0 !2.0.3-beta.2" would match every version between 1.0.0 and 3.0.0 except 2.0.3-beta.2
+//
+// Ranges can also be linked by logical OR:
+// - "<2.0.0 || >=3.0.0" would match "1.x.x" and "3.x.x" but not "2.x.x"
+//
+// AND has a higher precedence than OR. It's not possible to use brackets.
+//
+// Ranges can be combined by both AND and OR
+//
+// - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1`
+func ParseRange(s string) (Range, error) {
+ parts := splitAndTrim(s)
+ orParts, err := splitORParts(parts)
+ if err != nil {
+ return nil, err
+ }
+ var orFn Range
+ for _, p := range orParts {
+ var andFn Range
+ for _, ap := range p {
+ opStr, vStr, err := splitComparatorVersion(ap)
+ if err != nil {
+ return nil, err
+ }
+ vr, err := buildVersionRange(opStr, vStr)
+ if err != nil {
+ return nil, fmt.Errorf("Could not parse Range %q: %s", ap, err)
+ }
+ rf := vr.rangeFunc()
+
+ // Set function
+ if andFn == nil {
+ andFn = rf
+ } else { // Combine with existing function
+ andFn = andFn.AND(rf)
+ }
+ }
+ if orFn == nil {
+ orFn = andFn
+ } else {
+ orFn = orFn.OR(andFn)
+ }
+
+ }
+ return orFn, nil
+}
+
+// splitORParts splits the already cleaned parts by '||'.
+// Checks for invalid positions of the operator and returns an
+// error if found.
+func splitORParts(parts []string) ([][]string, error) {
+ var ORparts [][]string
+ last := 0
+ for i, p := range parts {
+ if p == "||" {
+ if i == 0 {
+ return nil, fmt.Errorf("First element in range is '||'")
+ }
+ ORparts = append(ORparts, parts[last:i])
+ last = i + 1
+ }
+ }
+ if last == len(parts) {
+ return nil, fmt.Errorf("Last element in range is '||'")
+ }
+ ORparts = append(ORparts, parts[last:])
+ return ORparts, nil
+}
+
+// buildVersionRange takes a slice of 2: operator and version
+// and builds a versionRange, otherwise an error.
+func buildVersionRange(opStr, vStr string) (*versionRange, error) {
+ c := parseComparator(opStr)
+ if c == nil {
+ return nil, fmt.Errorf("Could not parse comparator %q in %q", opStr, strings.Join([]string{opStr, vStr}, ""))
+ }
+ v, err := Parse(vStr)
+ if err != nil {
+ return nil, fmt.Errorf("Could not parse version %q in %q: %s", vStr, strings.Join([]string{opStr, vStr}, ""), err)
+ }
+
+ return &versionRange{
+ v: v,
+ c: c,
+ }, nil
+
+}
+
+// splitAndTrim splits a range string by spaces and cleans leading and trailing spaces
+func splitAndTrim(s string) (result []string) {
+ last := 0
+ for i := 0; i < len(s); i++ {
+ if s[i] == ' ' {
+ if last < i-1 {
+ result = append(result, s[last:i])
+ }
+ last = i + 1
+ }
+ }
+ if last < len(s)-1 {
+ result = append(result, s[last:])
+ }
+ // parts := strings.Split(s, " ")
+ // for _, x := range parts {
+ // if s := strings.TrimSpace(x); len(s) != 0 {
+ // result = append(result, s)
+ // }
+ // }
+ return
+}
+
+// splitComparatorVersion splits the comparator from the version.
+// Spaces between the comparator and the version are not allowed.
+// Input must be free of leading or trailing spaces.
+func splitComparatorVersion(s string) (string, string, error) {
+ i := strings.IndexFunc(s, unicode.IsDigit)
+ if i == -1 {
+ return "", "", fmt.Errorf("Could not get version from string: %q", s)
+ }
+ return strings.TrimSpace(s[0:i]), s[i:], nil
+}
+
+func parseComparator(s string) comparator {
+ switch s {
+ case "==":
+ fallthrough
+ case "":
+ fallthrough
+ case "=":
+ return compEQ
+ case ">":
+ return compGT
+ case ">=":
+ return compGE
+ case "<":
+ return compLT
+ case "<=":
+ return compLE
+ case "!":
+ fallthrough
+ case "!=":
+ return compNE
+ }
+
+ return nil
+}
+
+// MustParseRange is like ParseRange but panics if the range cannot be parsed.
+func MustParseRange(s string) Range {
+ r, err := ParseRange(s)
+ if err != nil {
+ panic(`semver: ParseRange(` + s + `): ` + err.Error())
+ }
+ return r
+}
diff --git a/Godeps/_workspace/src/github.com/blang/semver/semver.go b/vendor/github.com/blang/semver/semver.go
similarity index 91%
rename from Godeps/_workspace/src/github.com/blang/semver/semver.go
rename to vendor/github.com/blang/semver/semver.go
index bbf85ce972d1594d2262f16db4f75f45104e5e7f..8ee0842e6ac7fb63b325d417a579f9648d7aa218 100644
--- a/Godeps/_workspace/src/github.com/blang/semver/semver.go
+++ b/vendor/github.com/blang/semver/semver.go
@@ -200,6 +200,29 @@ func Make(s string) (Version, error) {
return Parse(s)
}
+// ParseTolerant allows for certain version specifications that do not strictly adhere to semver
+// specs to be parsed by this library. It does so by normalizing versions before passing them to
+// Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions
+// with only major and minor components specified
+func ParseTolerant(s string) (Version, error) {
+ s = strings.TrimSpace(s)
+ s = strings.TrimPrefix(s, "v")
+
+ // Split into major.minor.(patch+pr+meta)
+ parts := strings.SplitN(s, ".", 3)
+ if len(parts) < 3 {
+ if strings.ContainsAny(parts[len(parts)-1], "+-") {
+ return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data")
+ }
+ for len(parts) < 3 {
+ parts = append(parts, "0")
+ }
+ s = strings.Join(parts, ".")
+ }
+
+ return Parse(s)
+}
+
// Parse parses version string and returns a validated Version or error
func Parse(s string) (Version, error) {
if len(s) == 0 {
diff --git a/Godeps/_workspace/src/github.com/blang/semver/sort.go b/vendor/github.com/blang/semver/sort.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/blang/semver/sort.go
rename to vendor/github.com/blang/semver/sort.go
diff --git a/Godeps/_workspace/src/github.com/blang/semver/sql.go b/vendor/github.com/blang/semver/sql.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/blang/semver/sql.go
rename to vendor/github.com/blang/semver/sql.go
diff --git a/vendor/github.com/coreos/go-oidc/LICENSE b/vendor/github.com/coreos/go-oidc/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e06d2081865a766a8668acc12878f98b27fc9ea0
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/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 {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/vendor/github.com/coreos/go-oidc/NOTICE b/vendor/github.com/coreos/go-oidc/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..b39ddfa5cbdeaaf7cc8ff22ea50c972575b885c0
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/NOTICE
@@ -0,0 +1,5 @@
+CoreOS Project
+Copyright 2014 CoreOS, Inc
+
+This product includes software developed at CoreOS, Inc.
+(http://www.coreos.com/).
diff --git a/vendor/github.com/coreos/go-oidc/http/client.go b/vendor/github.com/coreos/go-oidc/http/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..fd079b4950f0c68fd00e5607f6ce231c54bbde25
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/http/client.go
@@ -0,0 +1,7 @@
+package http
+
+import "net/http"
+
+type Client interface {
+ Do(*http.Request) (*http.Response, error)
+}
diff --git a/vendor/github.com/coreos/go-oidc/http/http.go b/vendor/github.com/coreos/go-oidc/http/http.go
new file mode 100644
index 0000000000000000000000000000000000000000..c3f51215133670ad26ca8319d7dc7c4a02ccf77b
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/http/http.go
@@ -0,0 +1,156 @@
+package http
+
+import (
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "log"
+ "net/http"
+ "net/url"
+ "path"
+ "strconv"
+ "strings"
+ "time"
+)
+
+func WriteError(w http.ResponseWriter, code int, msg string) {
+ e := struct {
+ Error string `json:"error"`
+ }{
+ Error: msg,
+ }
+ b, err := json.Marshal(e)
+ if err != nil {
+ log.Printf("go-oidc: failed to marshal %#v: %v", e, err)
+ code = http.StatusInternalServerError
+ b = []byte(`{"error":"server_error"}`)
+ }
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(code)
+ w.Write(b)
+}
+
+// BasicAuth parses a username and password from the request's
+// Authorization header. This was pulled from golang master:
+// https://codereview.appspot.com/76540043
+func BasicAuth(r *http.Request) (username, password string, ok bool) {
+ auth := r.Header.Get("Authorization")
+ if auth == "" {
+ return
+ }
+
+ if !strings.HasPrefix(auth, "Basic ") {
+ return
+ }
+ c, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(auth, "Basic "))
+ if err != nil {
+ return
+ }
+ cs := string(c)
+ s := strings.IndexByte(cs, ':')
+ if s < 0 {
+ return
+ }
+ return cs[:s], cs[s+1:], true
+}
+
+func cacheControlMaxAge(hdr string) (time.Duration, bool, error) {
+ for _, field := range strings.Split(hdr, ",") {
+ parts := strings.SplitN(strings.TrimSpace(field), "=", 2)
+ k := strings.ToLower(strings.TrimSpace(parts[0]))
+ if k != "max-age" {
+ continue
+ }
+
+ if len(parts) == 1 {
+ return 0, false, errors.New("max-age has no value")
+ }
+
+ v := strings.TrimSpace(parts[1])
+ if v == "" {
+ return 0, false, errors.New("max-age has empty value")
+ }
+
+ age, err := strconv.Atoi(v)
+ if err != nil {
+ return 0, false, err
+ }
+
+ if age <= 0 {
+ return 0, false, nil
+ }
+
+ return time.Duration(age) * time.Second, true, nil
+ }
+
+ return 0, false, nil
+}
+
+func expires(date, expires string) (time.Duration, bool, error) {
+ if date == "" || expires == "" {
+ return 0, false, nil
+ }
+
+ te, err := time.Parse(time.RFC1123, expires)
+ if err != nil {
+ return 0, false, err
+ }
+
+ td, err := time.Parse(time.RFC1123, date)
+ if err != nil {
+ return 0, false, err
+ }
+
+ ttl := te.Sub(td)
+
+ // headers indicate data already expired, caller should not
+ // have to care about this case
+ if ttl <= 0 {
+ return 0, false, nil
+ }
+
+ return ttl, true, nil
+}
+
+func Cacheable(hdr http.Header) (time.Duration, bool, error) {
+ ttl, ok, err := cacheControlMaxAge(hdr.Get("Cache-Control"))
+ if err != nil || ok {
+ return ttl, ok, err
+ }
+
+ return expires(hdr.Get("Date"), hdr.Get("Expires"))
+}
+
+// MergeQuery appends additional query values to an existing URL.
+func MergeQuery(u url.URL, q url.Values) url.URL {
+ uv := u.Query()
+ for k, vs := range q {
+ for _, v := range vs {
+ uv.Add(k, v)
+ }
+ }
+ u.RawQuery = uv.Encode()
+ return u
+}
+
+// NewResourceLocation appends a resource id to the end of the requested URL path.
+func NewResourceLocation(reqURL *url.URL, id string) string {
+ var u url.URL
+ u = *reqURL
+ u.Path = path.Join(u.Path, id)
+ u.RawQuery = ""
+ u.Fragment = ""
+ return u.String()
+}
+
+// CopyRequest returns a clone of the provided *http.Request.
+// The returned object is a shallow copy of the struct and a
+// deep copy of its Header field.
+func CopyRequest(r *http.Request) *http.Request {
+ r2 := *r
+ r2.Header = make(http.Header)
+ for k, s := range r.Header {
+ r2.Header[k] = s
+ }
+ return &r2
+}
diff --git a/vendor/github.com/coreos/go-oidc/http/url.go b/vendor/github.com/coreos/go-oidc/http/url.go
new file mode 100644
index 0000000000000000000000000000000000000000..df60eb1a6b5ae4ad6ba75c5aef4b6b1a06039baf
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/http/url.go
@@ -0,0 +1,29 @@
+package http
+
+import (
+ "errors"
+ "net/url"
+)
+
+// ParseNonEmptyURL checks that a string is a parsable URL which is also not empty
+// since `url.Parse("")` does not return an error. Must contian a scheme and a host.
+func ParseNonEmptyURL(u string) (*url.URL, error) {
+ if u == "" {
+ return nil, errors.New("url is empty")
+ }
+
+ ur, err := url.Parse(u)
+ if err != nil {
+ return nil, err
+ }
+
+ if ur.Scheme == "" {
+ return nil, errors.New("url scheme is empty")
+ }
+
+ if ur.Host == "" {
+ return nil, errors.New("url host is empty")
+ }
+
+ return ur, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/claims.go b/vendor/github.com/coreos/go-oidc/jose/claims.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b48bfd230b075cbd7069c5744737ca4eb84e5e1
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/claims.go
@@ -0,0 +1,126 @@
+package jose
+
+import (
+ "encoding/json"
+ "fmt"
+ "math"
+ "time"
+)
+
+type Claims map[string]interface{}
+
+func (c Claims) Add(name string, value interface{}) {
+ c[name] = value
+}
+
+func (c Claims) StringClaim(name string) (string, bool, error) {
+ cl, ok := c[name]
+ if !ok {
+ return "", false, nil
+ }
+
+ v, ok := cl.(string)
+ if !ok {
+ return "", false, fmt.Errorf("unable to parse claim as string: %v", name)
+ }
+
+ return v, true, nil
+}
+
+func (c Claims) StringsClaim(name string) ([]string, bool, error) {
+ cl, ok := c[name]
+ if !ok {
+ return nil, false, nil
+ }
+
+ if v, ok := cl.([]string); ok {
+ return v, true, nil
+ }
+
+ // When unmarshaled, []string will become []interface{}.
+ if v, ok := cl.([]interface{}); ok {
+ var ret []string
+ for _, vv := range v {
+ str, ok := vv.(string)
+ if !ok {
+ return nil, false, fmt.Errorf("unable to parse claim as string array: %v", name)
+ }
+ ret = append(ret, str)
+ }
+ return ret, true, nil
+ }
+
+ return nil, false, fmt.Errorf("unable to parse claim as string array: %v", name)
+}
+
+func (c Claims) Int64Claim(name string) (int64, bool, error) {
+ cl, ok := c[name]
+ if !ok {
+ return 0, false, nil
+ }
+
+ v, ok := cl.(int64)
+ if !ok {
+ vf, ok := cl.(float64)
+ if !ok {
+ return 0, false, fmt.Errorf("unable to parse claim as int64: %v", name)
+ }
+ v = int64(vf)
+ }
+
+ return v, true, nil
+}
+
+func (c Claims) Float64Claim(name string) (float64, bool, error) {
+ cl, ok := c[name]
+ if !ok {
+ return 0, false, nil
+ }
+
+ v, ok := cl.(float64)
+ if !ok {
+ vi, ok := cl.(int64)
+ if !ok {
+ return 0, false, fmt.Errorf("unable to parse claim as float64: %v", name)
+ }
+ v = float64(vi)
+ }
+
+ return v, true, nil
+}
+
+func (c Claims) TimeClaim(name string) (time.Time, bool, error) {
+ v, ok, err := c.Float64Claim(name)
+ if !ok || err != nil {
+ return time.Time{}, ok, err
+ }
+
+ s := math.Trunc(v)
+ ns := (v - s) * math.Pow(10, 9)
+ return time.Unix(int64(s), int64(ns)).UTC(), true, nil
+}
+
+func decodeClaims(payload []byte) (Claims, error) {
+ var c Claims
+ if err := json.Unmarshal(payload, &c); err != nil {
+ return nil, fmt.Errorf("malformed JWT claims, unable to decode: %v", err)
+ }
+ return c, nil
+}
+
+func marshalClaims(c Claims) ([]byte, error) {
+ b, err := json.Marshal(c)
+ if err != nil {
+ return nil, err
+ }
+ return b, nil
+}
+
+func encodeClaims(c Claims) (string, error) {
+ b, err := marshalClaims(c)
+ if err != nil {
+ return "", err
+ }
+
+ return encodeSegment(b), nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/jose.go b/vendor/github.com/coreos/go-oidc/jose/jose.go
new file mode 100644
index 0000000000000000000000000000000000000000..6209926596c9b9cf649c2a89a48ba24933677537
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/jose.go
@@ -0,0 +1,112 @@
+package jose
+
+import (
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "strings"
+)
+
+const (
+ HeaderMediaType = "typ"
+ HeaderKeyAlgorithm = "alg"
+ HeaderKeyID = "kid"
+)
+
+const (
+ // Encryption Algorithm Header Parameter Values for JWS
+ // See: https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40#page-6
+ AlgHS256 = "HS256"
+ AlgHS384 = "HS384"
+ AlgHS512 = "HS512"
+ AlgRS256 = "RS256"
+ AlgRS384 = "RS384"
+ AlgRS512 = "RS512"
+ AlgES256 = "ES256"
+ AlgES384 = "ES384"
+ AlgES512 = "ES512"
+ AlgPS256 = "PS256"
+ AlgPS384 = "PS384"
+ AlgPS512 = "PS512"
+ AlgNone = "none"
+)
+
+const (
+ // Algorithm Header Parameter Values for JWE
+ // See: https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40#section-4.1
+ AlgRSA15 = "RSA1_5"
+ AlgRSAOAEP = "RSA-OAEP"
+ AlgRSAOAEP256 = "RSA-OAEP-256"
+ AlgA128KW = "A128KW"
+ AlgA192KW = "A192KW"
+ AlgA256KW = "A256KW"
+ AlgDir = "dir"
+ AlgECDHES = "ECDH-ES"
+ AlgECDHESA128KW = "ECDH-ES+A128KW"
+ AlgECDHESA192KW = "ECDH-ES+A192KW"
+ AlgECDHESA256KW = "ECDH-ES+A256KW"
+ AlgA128GCMKW = "A128GCMKW"
+ AlgA192GCMKW = "A192GCMKW"
+ AlgA256GCMKW = "A256GCMKW"
+ AlgPBES2HS256A128KW = "PBES2-HS256+A128KW"
+ AlgPBES2HS384A192KW = "PBES2-HS384+A192KW"
+ AlgPBES2HS512A256KW = "PBES2-HS512+A256KW"
+)
+
+const (
+ // Encryption Algorithm Header Parameter Values for JWE
+ // See: https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40#page-22
+ EncA128CBCHS256 = "A128CBC-HS256"
+ EncA128CBCHS384 = "A128CBC-HS384"
+ EncA256CBCHS512 = "A256CBC-HS512"
+ EncA128GCM = "A128GCM"
+ EncA192GCM = "A192GCM"
+ EncA256GCM = "A256GCM"
+)
+
+type JOSEHeader map[string]string
+
+func (j JOSEHeader) Validate() error {
+ if _, exists := j[HeaderKeyAlgorithm]; !exists {
+ return fmt.Errorf("header missing %q parameter", HeaderKeyAlgorithm)
+ }
+
+ return nil
+}
+
+func decodeHeader(seg string) (JOSEHeader, error) {
+ b, err := decodeSegment(seg)
+ if err != nil {
+ return nil, err
+ }
+
+ var h JOSEHeader
+ err = json.Unmarshal(b, &h)
+ if err != nil {
+ return nil, err
+ }
+
+ return h, nil
+}
+
+func encodeHeader(h JOSEHeader) (string, error) {
+ b, err := json.Marshal(h)
+ if err != nil {
+ return "", err
+ }
+
+ return encodeSegment(b), nil
+}
+
+// Decode JWT specific base64url encoding with padding stripped
+func decodeSegment(seg string) ([]byte, error) {
+ if l := len(seg) % 4; l != 0 {
+ seg += strings.Repeat("=", 4-l)
+ }
+ return base64.URLEncoding.DecodeString(seg)
+}
+
+// Encode JWT specific base64url encoding with padding stripped
+func encodeSegment(seg []byte) string {
+ return strings.TrimRight(base64.URLEncoding.EncodeToString(seg), "=")
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/jwk.go b/vendor/github.com/coreos/go-oidc/jose/jwk.go
new file mode 100644
index 0000000000000000000000000000000000000000..b7a8e235583ac0bc5a659e3f7df523dd36a72856
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/jwk.go
@@ -0,0 +1,135 @@
+package jose
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/binary"
+ "encoding/json"
+ "math/big"
+ "strings"
+)
+
+// JSON Web Key
+// https://tools.ietf.org/html/draft-ietf-jose-json-web-key-36#page-5
+type JWK struct {
+ ID string
+ Type string
+ Alg string
+ Use string
+ Exponent int
+ Modulus *big.Int
+ Secret []byte
+}
+
+type jwkJSON struct {
+ ID string `json:"kid"`
+ Type string `json:"kty"`
+ Alg string `json:"alg"`
+ Use string `json:"use"`
+ Exponent string `json:"e"`
+ Modulus string `json:"n"`
+}
+
+func (j *JWK) MarshalJSON() ([]byte, error) {
+ t := jwkJSON{
+ ID: j.ID,
+ Type: j.Type,
+ Alg: j.Alg,
+ Use: j.Use,
+ Exponent: encodeExponent(j.Exponent),
+ Modulus: encodeModulus(j.Modulus),
+ }
+
+ return json.Marshal(&t)
+}
+
+func (j *JWK) UnmarshalJSON(data []byte) error {
+ var t jwkJSON
+ err := json.Unmarshal(data, &t)
+ if err != nil {
+ return err
+ }
+
+ e, err := decodeExponent(t.Exponent)
+ if err != nil {
+ return err
+ }
+
+ n, err := decodeModulus(t.Modulus)
+ if err != nil {
+ return err
+ }
+
+ j.ID = t.ID
+ j.Type = t.Type
+ j.Alg = t.Alg
+ j.Use = t.Use
+ j.Exponent = e
+ j.Modulus = n
+
+ return nil
+}
+
+type JWKSet struct {
+ Keys []JWK `json:"keys"`
+}
+
+func decodeExponent(e string) (int, error) {
+ decE, err := decodeBase64URLPaddingOptional(e)
+ if err != nil {
+ return 0, err
+ }
+ var eBytes []byte
+ if len(decE) < 8 {
+ eBytes = make([]byte, 8-len(decE), 8)
+ eBytes = append(eBytes, decE...)
+ } else {
+ eBytes = decE
+ }
+ eReader := bytes.NewReader(eBytes)
+ var E uint64
+ err = binary.Read(eReader, binary.BigEndian, &E)
+ if err != nil {
+ return 0, err
+ }
+ return int(E), nil
+}
+
+func encodeExponent(e int) string {
+ b := make([]byte, 8)
+ binary.BigEndian.PutUint64(b, uint64(e))
+ var idx int
+ for ; idx < 8; idx++ {
+ if b[idx] != 0x0 {
+ break
+ }
+ }
+ return base64.URLEncoding.EncodeToString(b[idx:])
+}
+
+// Turns a URL encoded modulus of a key into a big int.
+func decodeModulus(n string) (*big.Int, error) {
+ decN, err := decodeBase64URLPaddingOptional(n)
+ if err != nil {
+ return nil, err
+ }
+ N := big.NewInt(0)
+ N.SetBytes(decN)
+ return N, nil
+}
+
+func encodeModulus(n *big.Int) string {
+ return base64.URLEncoding.EncodeToString(n.Bytes())
+}
+
+// decodeBase64URLPaddingOptional decodes Base64 whether there is padding or not.
+// The stdlib version currently doesn't handle this.
+// We can get rid of this is if this bug:
+// https://github.com/golang/go/issues/4237
+// ever closes.
+func decodeBase64URLPaddingOptional(e string) ([]byte, error) {
+ if m := len(e) % 4; m != 0 {
+ e += strings.Repeat("=", 4-m)
+ }
+ return base64.URLEncoding.DecodeString(e)
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/jws.go b/vendor/github.com/coreos/go-oidc/jose/jws.go
new file mode 100644
index 0000000000000000000000000000000000000000..1049ece831c5c5c3b7140c761e340ce4385a7ed1
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/jws.go
@@ -0,0 +1,51 @@
+package jose
+
+import (
+ "fmt"
+ "strings"
+)
+
+type JWS struct {
+ RawHeader string
+ Header JOSEHeader
+ RawPayload string
+ Payload []byte
+ Signature []byte
+}
+
+// Given a raw encoded JWS token parses it and verifies the structure.
+func ParseJWS(raw string) (JWS, error) {
+ parts := strings.Split(raw, ".")
+ if len(parts) != 3 {
+ return JWS{}, fmt.Errorf("malformed JWS, only %d segments", len(parts))
+ }
+
+ rawSig := parts[2]
+ jws := JWS{
+ RawHeader: parts[0],
+ RawPayload: parts[1],
+ }
+
+ header, err := decodeHeader(jws.RawHeader)
+ if err != nil {
+ return JWS{}, fmt.Errorf("malformed JWS, unable to decode header, %s", err)
+ }
+ if err = header.Validate(); err != nil {
+ return JWS{}, fmt.Errorf("malformed JWS, %s", err)
+ }
+ jws.Header = header
+
+ payload, err := decodeSegment(jws.RawPayload)
+ if err != nil {
+ return JWS{}, fmt.Errorf("malformed JWS, unable to decode payload: %s", err)
+ }
+ jws.Payload = payload
+
+ sig, err := decodeSegment(rawSig)
+ if err != nil {
+ return JWS{}, fmt.Errorf("malformed JWS, unable to decode signature: %s", err)
+ }
+ jws.Signature = sig
+
+ return jws, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/jwt.go b/vendor/github.com/coreos/go-oidc/jose/jwt.go
new file mode 100644
index 0000000000000000000000000000000000000000..3b3e9634b002d20f5df069a2a8192f5d4db06766
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/jwt.go
@@ -0,0 +1,82 @@
+package jose
+
+import "strings"
+
+type JWT JWS
+
+func ParseJWT(token string) (jwt JWT, err error) {
+ jws, err := ParseJWS(token)
+ if err != nil {
+ return
+ }
+
+ return JWT(jws), nil
+}
+
+func NewJWT(header JOSEHeader, claims Claims) (jwt JWT, err error) {
+ jwt = JWT{}
+
+ jwt.Header = header
+ jwt.Header[HeaderMediaType] = "JWT"
+
+ claimBytes, err := marshalClaims(claims)
+ if err != nil {
+ return
+ }
+ jwt.Payload = claimBytes
+
+ eh, err := encodeHeader(header)
+ if err != nil {
+ return
+ }
+ jwt.RawHeader = eh
+
+ ec, err := encodeClaims(claims)
+ if err != nil {
+ return
+ }
+ jwt.RawPayload = ec
+
+ return
+}
+
+func (j *JWT) KeyID() (string, bool) {
+ kID, ok := j.Header[HeaderKeyID]
+ return kID, ok
+}
+
+func (j *JWT) Claims() (Claims, error) {
+ return decodeClaims(j.Payload)
+}
+
+// Encoded data part of the token which may be signed.
+func (j *JWT) Data() string {
+ return strings.Join([]string{j.RawHeader, j.RawPayload}, ".")
+}
+
+// Full encoded JWT token string in format: header.claims.signature
+func (j *JWT) Encode() string {
+ d := j.Data()
+ s := encodeSegment(j.Signature)
+ return strings.Join([]string{d, s}, ".")
+}
+
+func NewSignedJWT(claims Claims, s Signer) (*JWT, error) {
+ header := JOSEHeader{
+ HeaderKeyAlgorithm: s.Alg(),
+ HeaderKeyID: s.ID(),
+ }
+
+ jwt, err := NewJWT(header, claims)
+ if err != nil {
+ return nil, err
+ }
+
+ sig, err := s.Sign([]byte(jwt.Data()))
+ if err != nil {
+ return nil, err
+ }
+ jwt.Signature = sig
+
+ return &jwt, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/sig.go b/vendor/github.com/coreos/go-oidc/jose/sig.go
new file mode 100755
index 0000000000000000000000000000000000000000..7b2b253cca53548829e5e0f25310d7462be22d44
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/sig.go
@@ -0,0 +1,24 @@
+package jose
+
+import (
+ "fmt"
+)
+
+type Verifier interface {
+ ID() string
+ Alg() string
+ Verify(sig []byte, data []byte) error
+}
+
+type Signer interface {
+ Verifier
+ Sign(data []byte) (sig []byte, err error)
+}
+
+func NewVerifier(jwk JWK) (Verifier, error) {
+ if jwk.Type != "RSA" {
+ return nil, fmt.Errorf("unsupported key type %q", jwk.Type)
+ }
+
+ return NewVerifierRSA(jwk)
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/sig_hmac.go b/vendor/github.com/coreos/go-oidc/jose/sig_hmac.go
new file mode 100755
index 0000000000000000000000000000000000000000..b3ca3ef3d491a8a5f8e09ac3c879fef8b0560e15
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/sig_hmac.go
@@ -0,0 +1,67 @@
+package jose
+
+import (
+ "bytes"
+ "crypto"
+ "crypto/hmac"
+ _ "crypto/sha256"
+ "errors"
+ "fmt"
+)
+
+type VerifierHMAC struct {
+ KeyID string
+ Hash crypto.Hash
+ Secret []byte
+}
+
+type SignerHMAC struct {
+ VerifierHMAC
+}
+
+func NewVerifierHMAC(jwk JWK) (*VerifierHMAC, error) {
+ if jwk.Alg != "" && jwk.Alg != "HS256" {
+ return nil, fmt.Errorf("unsupported key algorithm %q", jwk.Alg)
+ }
+
+ v := VerifierHMAC{
+ KeyID: jwk.ID,
+ Secret: jwk.Secret,
+ Hash: crypto.SHA256,
+ }
+
+ return &v, nil
+}
+
+func (v *VerifierHMAC) ID() string {
+ return v.KeyID
+}
+
+func (v *VerifierHMAC) Alg() string {
+ return "HS256"
+}
+
+func (v *VerifierHMAC) Verify(sig []byte, data []byte) error {
+ h := hmac.New(v.Hash.New, v.Secret)
+ h.Write(data)
+ if !bytes.Equal(sig, h.Sum(nil)) {
+ return errors.New("invalid hmac signature")
+ }
+ return nil
+}
+
+func NewSignerHMAC(kid string, secret []byte) *SignerHMAC {
+ return &SignerHMAC{
+ VerifierHMAC: VerifierHMAC{
+ KeyID: kid,
+ Secret: secret,
+ Hash: crypto.SHA256,
+ },
+ }
+}
+
+func (s *SignerHMAC) Sign(data []byte) ([]byte, error) {
+ h := hmac.New(s.Hash.New, s.Secret)
+ h.Write(data)
+ return h.Sum(nil), nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/jose/sig_rsa.go b/vendor/github.com/coreos/go-oidc/jose/sig_rsa.go
new file mode 100755
index 0000000000000000000000000000000000000000..004e45dd835c02b1c3a0566d7c73f924113e4cf9
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/jose/sig_rsa.go
@@ -0,0 +1,67 @@
+package jose
+
+import (
+ "crypto"
+ "crypto/rand"
+ "crypto/rsa"
+ "fmt"
+)
+
+type VerifierRSA struct {
+ KeyID string
+ Hash crypto.Hash
+ PublicKey rsa.PublicKey
+}
+
+type SignerRSA struct {
+ PrivateKey rsa.PrivateKey
+ VerifierRSA
+}
+
+func NewVerifierRSA(jwk JWK) (*VerifierRSA, error) {
+ if jwk.Alg != "" && jwk.Alg != "RS256" {
+ return nil, fmt.Errorf("unsupported key algorithm %q", jwk.Alg)
+ }
+
+ v := VerifierRSA{
+ KeyID: jwk.ID,
+ PublicKey: rsa.PublicKey{
+ N: jwk.Modulus,
+ E: jwk.Exponent,
+ },
+ Hash: crypto.SHA256,
+ }
+
+ return &v, nil
+}
+
+func NewSignerRSA(kid string, key rsa.PrivateKey) *SignerRSA {
+ return &SignerRSA{
+ PrivateKey: key,
+ VerifierRSA: VerifierRSA{
+ KeyID: kid,
+ PublicKey: key.PublicKey,
+ Hash: crypto.SHA256,
+ },
+ }
+}
+
+func (v *VerifierRSA) ID() string {
+ return v.KeyID
+}
+
+func (v *VerifierRSA) Alg() string {
+ return "RS256"
+}
+
+func (v *VerifierRSA) Verify(sig []byte, data []byte) error {
+ h := v.Hash.New()
+ h.Write(data)
+ return rsa.VerifyPKCS1v15(&v.PublicKey, v.Hash, h.Sum(nil), sig)
+}
+
+func (s *SignerRSA) Sign(data []byte) ([]byte, error) {
+ h := s.Hash.New()
+ h.Write(data)
+ return rsa.SignPKCS1v15(rand.Reader, &s.PrivateKey, s.Hash, h.Sum(nil))
+}
diff --git a/vendor/github.com/coreos/go-oidc/key/key.go b/vendor/github.com/coreos/go-oidc/key/key.go
new file mode 100644
index 0000000000000000000000000000000000000000..208c1fc1492ce9f4e4f208f19ce381bab872e3d1
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/key/key.go
@@ -0,0 +1,153 @@
+package key
+
+import (
+ "crypto/rand"
+ "crypto/rsa"
+ "encoding/hex"
+ "encoding/json"
+ "io"
+ "time"
+
+ "github.com/coreos/go-oidc/jose"
+)
+
+func NewPublicKey(jwk jose.JWK) *PublicKey {
+ return &PublicKey{jwk: jwk}
+}
+
+type PublicKey struct {
+ jwk jose.JWK
+}
+
+func (k *PublicKey) MarshalJSON() ([]byte, error) {
+ return json.Marshal(&k.jwk)
+}
+
+func (k *PublicKey) UnmarshalJSON(data []byte) error {
+ var jwk jose.JWK
+ if err := json.Unmarshal(data, &jwk); err != nil {
+ return err
+ }
+ k.jwk = jwk
+ return nil
+}
+
+func (k *PublicKey) ID() string {
+ return k.jwk.ID
+}
+
+func (k *PublicKey) Verifier() (jose.Verifier, error) {
+ return jose.NewVerifierRSA(k.jwk)
+}
+
+type PrivateKey struct {
+ KeyID string
+ PrivateKey *rsa.PrivateKey
+}
+
+func (k *PrivateKey) ID() string {
+ return k.KeyID
+}
+
+func (k *PrivateKey) Signer() jose.Signer {
+ return jose.NewSignerRSA(k.ID(), *k.PrivateKey)
+}
+
+func (k *PrivateKey) JWK() jose.JWK {
+ return jose.JWK{
+ ID: k.KeyID,
+ Type: "RSA",
+ Alg: "RS256",
+ Use: "sig",
+ Exponent: k.PrivateKey.PublicKey.E,
+ Modulus: k.PrivateKey.PublicKey.N,
+ }
+}
+
+type KeySet interface {
+ ExpiresAt() time.Time
+}
+
+type PublicKeySet struct {
+ keys []PublicKey
+ index map[string]*PublicKey
+ expiresAt time.Time
+}
+
+func NewPublicKeySet(jwks []jose.JWK, exp time.Time) *PublicKeySet {
+ keys := make([]PublicKey, len(jwks))
+ index := make(map[string]*PublicKey)
+ for i, jwk := range jwks {
+ keys[i] = *NewPublicKey(jwk)
+ index[keys[i].ID()] = &keys[i]
+ }
+ return &PublicKeySet{
+ keys: keys,
+ index: index,
+ expiresAt: exp,
+ }
+}
+
+func (s *PublicKeySet) ExpiresAt() time.Time {
+ return s.expiresAt
+}
+
+func (s *PublicKeySet) Keys() []PublicKey {
+ return s.keys
+}
+
+func (s *PublicKeySet) Key(id string) *PublicKey {
+ return s.index[id]
+}
+
+type PrivateKeySet struct {
+ keys []*PrivateKey
+ ActiveKeyID string
+ expiresAt time.Time
+}
+
+func NewPrivateKeySet(keys []*PrivateKey, exp time.Time) *PrivateKeySet {
+ return &PrivateKeySet{
+ keys: keys,
+ ActiveKeyID: keys[0].ID(),
+ expiresAt: exp.UTC(),
+ }
+}
+
+func (s *PrivateKeySet) Keys() []*PrivateKey {
+ return s.keys
+}
+
+func (s *PrivateKeySet) ExpiresAt() time.Time {
+ return s.expiresAt
+}
+
+func (s *PrivateKeySet) Active() *PrivateKey {
+ for i, k := range s.keys {
+ if k.ID() == s.ActiveKeyID {
+ return s.keys[i]
+ }
+ }
+
+ return nil
+}
+
+type GeneratePrivateKeyFunc func() (*PrivateKey, error)
+
+func GeneratePrivateKey() (*PrivateKey, error) {
+ pk, err := rsa.GenerateKey(rand.Reader, 2048)
+ if err != nil {
+ return nil, err
+ }
+ keyID := make([]byte, 20)
+ if _, err := io.ReadFull(rand.Reader, keyID); err != nil {
+ return nil, err
+ }
+
+ k := PrivateKey{
+ KeyID: hex.EncodeToString(keyID),
+ PrivateKey: pk,
+ }
+
+ return &k, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/key/manager.go b/vendor/github.com/coreos/go-oidc/key/manager.go
new file mode 100644
index 0000000000000000000000000000000000000000..476ab6a8d2b9261aa3d51c979683d6137d1ea8ca
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/key/manager.go
@@ -0,0 +1,99 @@
+package key
+
+import (
+ "errors"
+ "time"
+
+ "github.com/jonboulle/clockwork"
+
+ "github.com/coreos/go-oidc/jose"
+ "github.com/coreos/pkg/health"
+)
+
+type PrivateKeyManager interface {
+ ExpiresAt() time.Time
+ Signer() (jose.Signer, error)
+ JWKs() ([]jose.JWK, error)
+ PublicKeys() ([]PublicKey, error)
+
+ WritableKeySetRepo
+ health.Checkable
+}
+
+func NewPrivateKeyManager() PrivateKeyManager {
+ return &privateKeyManager{
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+type privateKeyManager struct {
+ keySet *PrivateKeySet
+ clock clockwork.Clock
+}
+
+func (m *privateKeyManager) ExpiresAt() time.Time {
+ if m.keySet == nil {
+ return m.clock.Now().UTC()
+ }
+
+ return m.keySet.ExpiresAt()
+}
+
+func (m *privateKeyManager) Signer() (jose.Signer, error) {
+ if err := m.Healthy(); err != nil {
+ return nil, err
+ }
+
+ return m.keySet.Active().Signer(), nil
+}
+
+func (m *privateKeyManager) JWKs() ([]jose.JWK, error) {
+ if err := m.Healthy(); err != nil {
+ return nil, err
+ }
+
+ keys := m.keySet.Keys()
+ jwks := make([]jose.JWK, len(keys))
+ for i, k := range keys {
+ jwks[i] = k.JWK()
+ }
+ return jwks, nil
+}
+
+func (m *privateKeyManager) PublicKeys() ([]PublicKey, error) {
+ jwks, err := m.JWKs()
+ if err != nil {
+ return nil, err
+ }
+ keys := make([]PublicKey, len(jwks))
+ for i, jwk := range jwks {
+ keys[i] = *NewPublicKey(jwk)
+ }
+ return keys, nil
+}
+
+func (m *privateKeyManager) Healthy() error {
+ if m.keySet == nil {
+ return errors.New("private key manager uninitialized")
+ }
+
+ if len(m.keySet.Keys()) == 0 {
+ return errors.New("private key manager zero keys")
+ }
+
+ if m.keySet.ExpiresAt().Before(m.clock.Now().UTC()) {
+ return errors.New("private key manager keys expired")
+ }
+
+ return nil
+}
+
+func (m *privateKeyManager) Set(keySet KeySet) error {
+ privKeySet, ok := keySet.(*PrivateKeySet)
+ if !ok {
+ return errors.New("unable to cast to PrivateKeySet")
+ }
+
+ m.keySet = privKeySet
+ return nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/key/repo.go b/vendor/github.com/coreos/go-oidc/key/repo.go
new file mode 100644
index 0000000000000000000000000000000000000000..1acdeb3614c54f004ad2d9b23c22a2156a32e364
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/key/repo.go
@@ -0,0 +1,55 @@
+package key
+
+import (
+ "errors"
+ "sync"
+)
+
+var ErrorNoKeys = errors.New("no keys found")
+
+type WritableKeySetRepo interface {
+ Set(KeySet) error
+}
+
+type ReadableKeySetRepo interface {
+ Get() (KeySet, error)
+}
+
+type PrivateKeySetRepo interface {
+ WritableKeySetRepo
+ ReadableKeySetRepo
+}
+
+func NewPrivateKeySetRepo() PrivateKeySetRepo {
+ return &memPrivateKeySetRepo{}
+}
+
+type memPrivateKeySetRepo struct {
+ mu sync.RWMutex
+ pks PrivateKeySet
+}
+
+func (r *memPrivateKeySetRepo) Set(ks KeySet) error {
+ pks, ok := ks.(*PrivateKeySet)
+ if !ok {
+ return errors.New("unable to cast to PrivateKeySet")
+ } else if pks == nil {
+ return errors.New("nil KeySet")
+ }
+
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ r.pks = *pks
+ return nil
+}
+
+func (r *memPrivateKeySetRepo) Get() (KeySet, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.pks.keys == nil {
+ return nil, ErrorNoKeys
+ }
+ return KeySet(&r.pks), nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/key/rotate.go b/vendor/github.com/coreos/go-oidc/key/rotate.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc6cdfb1bd89e39ea5a13103ff992f4c70fa7d62
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/key/rotate.go
@@ -0,0 +1,159 @@
+package key
+
+import (
+ "errors"
+ "log"
+ "time"
+
+ ptime "github.com/coreos/pkg/timeutil"
+ "github.com/jonboulle/clockwork"
+)
+
+var (
+ ErrorPrivateKeysExpired = errors.New("private keys have expired")
+)
+
+func NewPrivateKeyRotator(repo PrivateKeySetRepo, ttl time.Duration) *PrivateKeyRotator {
+ return &PrivateKeyRotator{
+ repo: repo,
+ ttl: ttl,
+
+ keep: 2,
+ generateKey: GeneratePrivateKey,
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+type PrivateKeyRotator struct {
+ repo PrivateKeySetRepo
+ generateKey GeneratePrivateKeyFunc
+ clock clockwork.Clock
+ keep int
+ ttl time.Duration
+}
+
+func (r *PrivateKeyRotator) expiresAt() time.Time {
+ return r.clock.Now().UTC().Add(r.ttl)
+}
+
+func (r *PrivateKeyRotator) Healthy() error {
+ pks, err := r.privateKeySet()
+ if err != nil {
+ return err
+ }
+
+ if r.clock.Now().After(pks.ExpiresAt()) {
+ return ErrorPrivateKeysExpired
+ }
+
+ return nil
+}
+
+func (r *PrivateKeyRotator) privateKeySet() (*PrivateKeySet, error) {
+ ks, err := r.repo.Get()
+ if err != nil {
+ return nil, err
+ }
+
+ pks, ok := ks.(*PrivateKeySet)
+ if !ok {
+ return nil, errors.New("unable to cast to PrivateKeySet")
+ }
+ return pks, nil
+}
+
+func (r *PrivateKeyRotator) nextRotation() (time.Duration, error) {
+ pks, err := r.privateKeySet()
+ if err == ErrorNoKeys {
+ return 0, nil
+ }
+ if err != nil {
+ return 0, err
+ }
+
+ now := r.clock.Now()
+
+ // Ideally, we want to rotate after half the TTL has elapsed.
+ idealRotationTime := pks.ExpiresAt().Add(-r.ttl / 2)
+
+ // If we are past the ideal rotation time, rotate immediatly.
+ return max(0, idealRotationTime.Sub(now)), nil
+}
+
+func max(a, b time.Duration) time.Duration {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func (r *PrivateKeyRotator) Run() chan struct{} {
+ attempt := func() {
+ k, err := r.generateKey()
+ if err != nil {
+ log.Printf("go-oidc: failed generating signing key: %v", err)
+ return
+ }
+
+ exp := r.expiresAt()
+ if err := rotatePrivateKeys(r.repo, k, r.keep, exp); err != nil {
+ log.Printf("go-oidc: key rotation failed: %v", err)
+ return
+ }
+ }
+
+ stop := make(chan struct{})
+ go func() {
+ for {
+ var nextRotation time.Duration
+ var sleep time.Duration
+ var err error
+ for {
+ if nextRotation, err = r.nextRotation(); err == nil {
+ break
+ }
+ sleep = ptime.ExpBackoff(sleep, time.Minute)
+ log.Printf("go-oidc: error getting nextRotation, retrying in %v: %v", sleep, err)
+ time.Sleep(sleep)
+ }
+
+ select {
+ case <-r.clock.After(nextRotation):
+ attempt()
+ case <-stop:
+ return
+ }
+ }
+ }()
+
+ return stop
+}
+
+func rotatePrivateKeys(repo PrivateKeySetRepo, k *PrivateKey, keep int, exp time.Time) error {
+ ks, err := repo.Get()
+ if err != nil && err != ErrorNoKeys {
+ return err
+ }
+
+ var keys []*PrivateKey
+ if ks != nil {
+ pks, ok := ks.(*PrivateKeySet)
+ if !ok {
+ return errors.New("unable to cast to PrivateKeySet")
+ }
+ keys = pks.Keys()
+ }
+
+ keys = append([]*PrivateKey{k}, keys...)
+ if l := len(keys); l > keep {
+ keys = keys[0:keep]
+ }
+
+ nks := PrivateKeySet{
+ keys: keys,
+ ActiveKeyID: k.ID(),
+ expiresAt: exp,
+ }
+
+ return repo.Set(KeySet(&nks))
+}
diff --git a/vendor/github.com/coreos/go-oidc/key/sync.go b/vendor/github.com/coreos/go-oidc/key/sync.go
new file mode 100644
index 0000000000000000000000000000000000000000..b887f7b5a5600fb035ea61ff4f0133267d75fb5d
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/key/sync.go
@@ -0,0 +1,91 @@
+package key
+
+import (
+ "errors"
+ "log"
+ "time"
+
+ "github.com/jonboulle/clockwork"
+
+ "github.com/coreos/pkg/timeutil"
+)
+
+func NewKeySetSyncer(r ReadableKeySetRepo, w WritableKeySetRepo) *KeySetSyncer {
+ return &KeySetSyncer{
+ readable: r,
+ writable: w,
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+type KeySetSyncer struct {
+ readable ReadableKeySetRepo
+ writable WritableKeySetRepo
+ clock clockwork.Clock
+}
+
+func (s *KeySetSyncer) Run() chan struct{} {
+ stop := make(chan struct{})
+ go func() {
+ var failing bool
+ var next time.Duration
+ for {
+ exp, err := syncKeySet(s.readable, s.writable, s.clock)
+ if err != nil || exp == 0 {
+ if !failing {
+ failing = true
+ next = time.Second
+ } else {
+ next = timeutil.ExpBackoff(next, time.Minute)
+ }
+ if exp == 0 {
+ log.Printf("Synced to already expired key set, retrying in %v: %v", next, err)
+
+ } else {
+ log.Printf("Failed syncing key set, retrying in %v: %v", next, err)
+ }
+ } else {
+ failing = false
+ next = exp / 2
+ }
+
+ select {
+ case <-s.clock.After(next):
+ continue
+ case <-stop:
+ return
+ }
+ }
+ }()
+
+ return stop
+}
+
+func Sync(r ReadableKeySetRepo, w WritableKeySetRepo) (time.Duration, error) {
+ return syncKeySet(r, w, clockwork.NewRealClock())
+}
+
+// syncKeySet copies the keyset from r to the KeySet at w and returns the duration in which the KeySet will expire.
+// If keyset has already expired, returns a zero duration.
+func syncKeySet(r ReadableKeySetRepo, w WritableKeySetRepo, clock clockwork.Clock) (exp time.Duration, err error) {
+ var ks KeySet
+ ks, err = r.Get()
+ if err != nil {
+ return
+ }
+
+ if ks == nil {
+ err = errors.New("no source KeySet")
+ return
+ }
+
+ if err = w.Set(ks); err != nil {
+ return
+ }
+
+ now := clock.Now()
+ if ks.ExpiresAt().After(now) {
+ exp = ks.ExpiresAt().Sub(now)
+ }
+ return
+}
diff --git a/vendor/github.com/coreos/go-oidc/oauth2/error.go b/vendor/github.com/coreos/go-oidc/oauth2/error.go
new file mode 100644
index 0000000000000000000000000000000000000000..50d890949a2342d3a07aa25054eb4b362953967f
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oauth2/error.go
@@ -0,0 +1,29 @@
+package oauth2
+
+const (
+ ErrorAccessDenied = "access_denied"
+ ErrorInvalidClient = "invalid_client"
+ ErrorInvalidGrant = "invalid_grant"
+ ErrorInvalidRequest = "invalid_request"
+ ErrorServerError = "server_error"
+ ErrorUnauthorizedClient = "unauthorized_client"
+ ErrorUnsupportedGrantType = "unsupported_grant_type"
+ ErrorUnsupportedResponseType = "unsupported_response_type"
+)
+
+type Error struct {
+ Type string `json:"error"`
+ Description string `json:"error_description,omitempty"`
+ State string `json:"state,omitempty"`
+}
+
+func (e *Error) Error() string {
+ if e.Description != "" {
+ return e.Type + ": " + e.Description
+ }
+ return e.Type
+}
+
+func NewError(typ string) *Error {
+ return &Error{Type: typ}
+}
diff --git a/vendor/github.com/coreos/go-oidc/oauth2/oauth2.go b/vendor/github.com/coreos/go-oidc/oauth2/oauth2.go
new file mode 100644
index 0000000000000000000000000000000000000000..72d1d6715bfd77edc281ca3ab9a554d77512ae78
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oauth2/oauth2.go
@@ -0,0 +1,416 @@
+package oauth2
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "mime"
+ "net/http"
+ "net/url"
+ "sort"
+ "strconv"
+ "strings"
+
+ phttp "github.com/coreos/go-oidc/http"
+)
+
+// ResponseTypesEqual compares two response_type values. If either
+// contains a space, it is treated as an unordered list. For example,
+// comparing "code id_token" and "id_token code" would evaluate to true.
+func ResponseTypesEqual(r1, r2 string) bool {
+ if !strings.Contains(r1, " ") || !strings.Contains(r2, " ") {
+ // fast route, no split needed
+ return r1 == r2
+ }
+
+ // split, sort, and compare
+ r1Fields := strings.Fields(r1)
+ r2Fields := strings.Fields(r2)
+ if len(r1Fields) != len(r2Fields) {
+ return false
+ }
+ sort.Strings(r1Fields)
+ sort.Strings(r2Fields)
+ for i, r1Field := range r1Fields {
+ if r1Field != r2Fields[i] {
+ return false
+ }
+ }
+ return true
+}
+
+const (
+ // OAuth2.0 response types registered by OIDC.
+ //
+ // See: https://openid.net/specs/oauth-v2-multiple-response-types-1_0.html#RegistryContents
+ ResponseTypeCode = "code"
+ ResponseTypeCodeIDToken = "code id_token"
+ ResponseTypeCodeIDTokenToken = "code id_token token"
+ ResponseTypeIDToken = "id_token"
+ ResponseTypeIDTokenToken = "id_token token"
+ ResponseTypeToken = "token"
+ ResponseTypeNone = "none"
+)
+
+const (
+ GrantTypeAuthCode = "authorization_code"
+ GrantTypeClientCreds = "client_credentials"
+ GrantTypeUserCreds = "password"
+ GrantTypeImplicit = "implicit"
+ GrantTypeRefreshToken = "refresh_token"
+
+ AuthMethodClientSecretPost = "client_secret_post"
+ AuthMethodClientSecretBasic = "client_secret_basic"
+ AuthMethodClientSecretJWT = "client_secret_jwt"
+ AuthMethodPrivateKeyJWT = "private_key_jwt"
+)
+
+type Config struct {
+ Credentials ClientCredentials
+ Scope []string
+ RedirectURL string
+ AuthURL string
+ TokenURL string
+
+ // Must be one of the AuthMethodXXX methods above. Right now, only
+ // AuthMethodClientSecretPost and AuthMethodClientSecretBasic are supported.
+ AuthMethod string
+}
+
+type Client struct {
+ hc phttp.Client
+ creds ClientCredentials
+ scope []string
+ authURL *url.URL
+ redirectURL *url.URL
+ tokenURL *url.URL
+ authMethod string
+}
+
+type ClientCredentials struct {
+ ID string
+ Secret string
+}
+
+func NewClient(hc phttp.Client, cfg Config) (c *Client, err error) {
+ if len(cfg.Credentials.ID) == 0 {
+ err = errors.New("missing client id")
+ return
+ }
+
+ if len(cfg.Credentials.Secret) == 0 {
+ err = errors.New("missing client secret")
+ return
+ }
+
+ if cfg.AuthMethod == "" {
+ cfg.AuthMethod = AuthMethodClientSecretBasic
+ } else if cfg.AuthMethod != AuthMethodClientSecretPost && cfg.AuthMethod != AuthMethodClientSecretBasic {
+ err = fmt.Errorf("auth method %q is not supported", cfg.AuthMethod)
+ return
+ }
+
+ au, err := phttp.ParseNonEmptyURL(cfg.AuthURL)
+ if err != nil {
+ return
+ }
+
+ tu, err := phttp.ParseNonEmptyURL(cfg.TokenURL)
+ if err != nil {
+ return
+ }
+
+ // Allow empty redirect URL in the case where the client
+ // only needs to verify a given token.
+ ru, err := url.Parse(cfg.RedirectURL)
+ if err != nil {
+ return
+ }
+
+ c = &Client{
+ creds: cfg.Credentials,
+ scope: cfg.Scope,
+ redirectURL: ru,
+ authURL: au,
+ tokenURL: tu,
+ hc: hc,
+ authMethod: cfg.AuthMethod,
+ }
+
+ return
+}
+
+// Return the embedded HTTP client
+func (c *Client) HttpClient() phttp.Client {
+ return c.hc
+}
+
+// Generate the url for initial redirect to oauth provider.
+func (c *Client) AuthCodeURL(state, accessType, prompt string) string {
+ v := c.commonURLValues()
+ v.Set("state", state)
+ if strings.ToLower(accessType) == "offline" {
+ v.Set("access_type", "offline")
+ }
+
+ if prompt != "" {
+ v.Set("prompt", prompt)
+ }
+ v.Set("response_type", "code")
+
+ q := v.Encode()
+ u := *c.authURL
+ if u.RawQuery == "" {
+ u.RawQuery = q
+ } else {
+ u.RawQuery += "&" + q
+ }
+ return u.String()
+}
+
+func (c *Client) commonURLValues() url.Values {
+ return url.Values{
+ "redirect_uri": {c.redirectURL.String()},
+ "scope": {strings.Join(c.scope, " ")},
+ "client_id": {c.creds.ID},
+ }
+}
+
+func (c *Client) newAuthenticatedRequest(urlToken string, values url.Values) (*http.Request, error) {
+ var req *http.Request
+ var err error
+ switch c.authMethod {
+ case AuthMethodClientSecretPost:
+ values.Set("client_secret", c.creds.Secret)
+ req, err = http.NewRequest("POST", urlToken, strings.NewReader(values.Encode()))
+ if err != nil {
+ return nil, err
+ }
+ case AuthMethodClientSecretBasic:
+ req, err = http.NewRequest("POST", urlToken, strings.NewReader(values.Encode()))
+ if err != nil {
+ return nil, err
+ }
+ encodedID := url.QueryEscape(c.creds.ID)
+ encodedSecret := url.QueryEscape(c.creds.Secret)
+ req.SetBasicAuth(encodedID, encodedSecret)
+ default:
+ panic("misconfigured client: auth method not supported")
+ }
+
+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+ return req, nil
+
+}
+
+// ClientCredsToken posts the client id and secret to obtain a token scoped to the OAuth2 client via the "client_credentials" grant type.
+// May not be supported by all OAuth2 servers.
+func (c *Client) ClientCredsToken(scope []string) (result TokenResponse, err error) {
+ v := url.Values{
+ "scope": {strings.Join(scope, " ")},
+ "grant_type": {GrantTypeClientCreds},
+ }
+
+ req, err := c.newAuthenticatedRequest(c.tokenURL.String(), v)
+ if err != nil {
+ return
+ }
+
+ resp, err := c.hc.Do(req)
+ if err != nil {
+ return
+ }
+ defer resp.Body.Close()
+
+ return parseTokenResponse(resp)
+}
+
+// UserCredsToken posts the username and password to obtain a token scoped to the OAuth2 client via the "password" grant_type
+// May not be supported by all OAuth2 servers.
+func (c *Client) UserCredsToken(username, password string) (result TokenResponse, err error) {
+ v := url.Values{
+ "scope": {strings.Join(c.scope, " ")},
+ "grant_type": {GrantTypeUserCreds},
+ "username": {username},
+ "password": {password},
+ }
+
+ req, err := c.newAuthenticatedRequest(c.tokenURL.String(), v)
+ if err != nil {
+ return
+ }
+
+ resp, err := c.hc.Do(req)
+ if err != nil {
+ return
+ }
+ defer resp.Body.Close()
+
+ return parseTokenResponse(resp)
+}
+
+// RequestToken requests a token from the Token Endpoint with the specified grantType.
+// If 'grantType' == GrantTypeAuthCode, then 'value' should be the authorization code.
+// If 'grantType' == GrantTypeRefreshToken, then 'value' should be the refresh token.
+func (c *Client) RequestToken(grantType, value string) (result TokenResponse, err error) {
+ v := c.commonURLValues()
+
+ v.Set("grant_type", grantType)
+ v.Set("client_secret", c.creds.Secret)
+ switch grantType {
+ case GrantTypeAuthCode:
+ v.Set("code", value)
+ case GrantTypeRefreshToken:
+ v.Set("refresh_token", value)
+ default:
+ err = fmt.Errorf("unsupported grant_type: %v", grantType)
+ return
+ }
+
+ req, err := c.newAuthenticatedRequest(c.tokenURL.String(), v)
+ if err != nil {
+ return
+ }
+
+ resp, err := c.hc.Do(req)
+ if err != nil {
+ return
+ }
+ defer resp.Body.Close()
+
+ return parseTokenResponse(resp)
+}
+
+func parseTokenResponse(resp *http.Response) (result TokenResponse, err error) {
+ body, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return
+ }
+ badStatusCode := resp.StatusCode < 200 || resp.StatusCode > 299
+
+ contentType, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
+ if err != nil {
+ return
+ }
+
+ result = TokenResponse{
+ RawBody: body,
+ }
+
+ newError := func(typ, desc, state string) error {
+ if typ == "" {
+ return fmt.Errorf("unrecognized error %s", body)
+ }
+ return &Error{typ, desc, state}
+ }
+
+ if contentType == "application/x-www-form-urlencoded" || contentType == "text/plain" {
+ var vals url.Values
+ vals, err = url.ParseQuery(string(body))
+ if err != nil {
+ return
+ }
+ if error := vals.Get("error"); error != "" || badStatusCode {
+ err = newError(error, vals.Get("error_description"), vals.Get("state"))
+ return
+ }
+ e := vals.Get("expires_in")
+ if e == "" {
+ e = vals.Get("expires")
+ }
+ if e != "" {
+ result.Expires, err = strconv.Atoi(e)
+ if err != nil {
+ return
+ }
+ }
+ result.AccessToken = vals.Get("access_token")
+ result.TokenType = vals.Get("token_type")
+ result.IDToken = vals.Get("id_token")
+ result.RefreshToken = vals.Get("refresh_token")
+ result.Scope = vals.Get("scope")
+ } else {
+ var r struct {
+ AccessToken string `json:"access_token"`
+ TokenType string `json:"token_type"`
+ IDToken string `json:"id_token"`
+ RefreshToken string `json:"refresh_token"`
+ Scope string `json:"scope"`
+ State string `json:"state"`
+ ExpiresIn json.Number `json:"expires_in"` // Azure AD returns string
+ Expires int `json:"expires"`
+ Error string `json:"error"`
+ Desc string `json:"error_description"`
+ }
+ if err = json.Unmarshal(body, &r); err != nil {
+ return
+ }
+ if r.Error != "" || badStatusCode {
+ err = newError(r.Error, r.Desc, r.State)
+ return
+ }
+ result.AccessToken = r.AccessToken
+ result.TokenType = r.TokenType
+ result.IDToken = r.IDToken
+ result.RefreshToken = r.RefreshToken
+ result.Scope = r.Scope
+ if expiresIn, err := r.ExpiresIn.Int64(); err != nil {
+ result.Expires = r.Expires
+ } else {
+ result.Expires = int(expiresIn)
+ }
+ }
+ return
+}
+
+type TokenResponse struct {
+ AccessToken string
+ TokenType string
+ Expires int
+ IDToken string
+ RefreshToken string // OPTIONAL.
+ Scope string // OPTIONAL, if identical to the scope requested by the client, otherwise, REQUIRED.
+ RawBody []byte // In case callers need some other non-standard info from the token response
+}
+
+type AuthCodeRequest struct {
+ ResponseType string
+ ClientID string
+ RedirectURL *url.URL
+ Scope []string
+ State string
+}
+
+func ParseAuthCodeRequest(q url.Values) (AuthCodeRequest, error) {
+ acr := AuthCodeRequest{
+ ResponseType: q.Get("response_type"),
+ ClientID: q.Get("client_id"),
+ State: q.Get("state"),
+ Scope: make([]string, 0),
+ }
+
+ qs := strings.TrimSpace(q.Get("scope"))
+ if qs != "" {
+ acr.Scope = strings.Split(qs, " ")
+ }
+
+ err := func() error {
+ if acr.ClientID == "" {
+ return NewError(ErrorInvalidRequest)
+ }
+
+ redirectURL := q.Get("redirect_uri")
+ if redirectURL != "" {
+ ru, err := url.Parse(redirectURL)
+ if err != nil {
+ return NewError(ErrorInvalidRequest)
+ }
+ acr.RedirectURL = ru
+ }
+
+ return nil
+ }()
+
+ return acr, err
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/client.go b/vendor/github.com/coreos/go-oidc/oidc/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a3cb40f6450fb485ea66a00b8caa9e748aac9a3
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/client.go
@@ -0,0 +1,846 @@
+package oidc
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/mail"
+ "net/url"
+ "sync"
+ "time"
+
+ phttp "github.com/coreos/go-oidc/http"
+ "github.com/coreos/go-oidc/jose"
+ "github.com/coreos/go-oidc/key"
+ "github.com/coreos/go-oidc/oauth2"
+)
+
+const (
+ // amount of time that must pass after the last key sync
+ // completes before another attempt may begin
+ keySyncWindow = 5 * time.Second
+)
+
+var (
+ DefaultScope = []string{"openid", "email", "profile"}
+
+ supportedAuthMethods = map[string]struct{}{
+ oauth2.AuthMethodClientSecretBasic: struct{}{},
+ oauth2.AuthMethodClientSecretPost: struct{}{},
+ }
+)
+
+type ClientCredentials oauth2.ClientCredentials
+
+type ClientIdentity struct {
+ Credentials ClientCredentials
+ Metadata ClientMetadata
+}
+
+type JWAOptions struct {
+ // SigningAlg specifies an JWA alg for signing JWTs.
+ //
+ // Specifying this field implies different actions depending on the context. It may
+ // require objects be serialized and signed as a JWT instead of plain JSON, or
+ // require an existing JWT object use the specified alg.
+ //
+ // See: http://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
+ SigningAlg string
+ // EncryptionAlg, if provided, specifies that the returned or sent object be stored
+ // (or nested) within a JWT object and encrypted with the provided JWA alg.
+ EncryptionAlg string
+ // EncryptionEnc specifies the JWA enc algorithm to use with EncryptionAlg. If
+ // EncryptionAlg is provided and EncryptionEnc is omitted, this field defaults
+ // to A128CBC-HS256.
+ //
+ // If EncryptionEnc is provided EncryptionAlg must also be specified.
+ EncryptionEnc string
+}
+
+func (opt JWAOptions) valid() error {
+ if opt.EncryptionEnc != "" && opt.EncryptionAlg == "" {
+ return errors.New("encryption encoding provided with no encryption algorithm")
+ }
+ return nil
+}
+
+func (opt JWAOptions) defaults() JWAOptions {
+ if opt.EncryptionAlg != "" && opt.EncryptionEnc == "" {
+ opt.EncryptionEnc = jose.EncA128CBCHS256
+ }
+ return opt
+}
+
+var (
+ // Ensure ClientMetadata satisfies these interfaces.
+ _ json.Marshaler = &ClientMetadata{}
+ _ json.Unmarshaler = &ClientMetadata{}
+)
+
+// ClientMetadata holds metadata that the authorization server associates
+// with a client identifier. The fields range from human-facing display
+// strings such as client name, to items that impact the security of the
+// protocol, such as the list of valid redirect URIs.
+//
+// See http://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
+//
+// TODO: support language specific claim representations
+// http://openid.net/specs/openid-connect-registration-1_0.html#LanguagesAndScripts
+type ClientMetadata struct {
+ RedirectURIs []url.URL // Required
+
+ // A list of OAuth 2.0 "response_type" values that the client wishes to restrict
+ // itself to. Either "code", "token", or another registered extension.
+ //
+ // If omitted, only "code" will be used.
+ ResponseTypes []string
+ // A list of OAuth 2.0 grant types the client wishes to restrict itself to.
+ // The grant type values used by OIDC are "authorization_code", "implicit",
+ // and "refresh_token".
+ //
+ // If ommitted, only "authorization_code" will be used.
+ GrantTypes []string
+ // "native" or "web". If omitted, "web".
+ ApplicationType string
+
+ // List of email addresses.
+ Contacts []mail.Address
+ // Name of client to be presented to the end-user.
+ ClientName string
+ // URL that references a logo for the Client application.
+ LogoURI *url.URL
+ // URL of the home page of the Client.
+ ClientURI *url.URL
+ // Profile data policies and terms of use to be provided to the end user.
+ PolicyURI *url.URL
+ TermsOfServiceURI *url.URL
+
+ // URL to or the value of the client's JSON Web Key Set document.
+ JWKSURI *url.URL
+ JWKS *jose.JWKSet
+
+ // URL referencing a flie with a single JSON array of redirect URIs.
+ SectorIdentifierURI *url.URL
+
+ SubjectType string
+
+ // Options to restrict the JWS alg and enc values used for server responses and requests.
+ IDTokenResponseOptions JWAOptions
+ UserInfoResponseOptions JWAOptions
+ RequestObjectOptions JWAOptions
+
+ // Client requested authorization method and signing options for the token endpoint.
+ //
+ // Defaults to "client_secret_basic"
+ TokenEndpointAuthMethod string
+ TokenEndpointAuthSigningAlg string
+
+ // DefaultMaxAge specifies the maximum amount of time in seconds before an authorized
+ // user must reauthroize.
+ //
+ // If 0, no limitation is placed on the maximum.
+ DefaultMaxAge int64
+ // RequireAuthTime specifies if the auth_time claim in the ID token is required.
+ RequireAuthTime bool
+
+ // Default Authentication Context Class Reference values for authentication requests.
+ DefaultACRValues []string
+
+ // URI that a third party can use to initiate a login by the relaying party.
+ //
+ // See: http://openid.net/specs/openid-connect-core-1_0.html#ThirdPartyInitiatedLogin
+ InitiateLoginURI *url.URL
+ // Pre-registered request_uri values that may be cached by the server.
+ RequestURIs []url.URL
+}
+
+// Defaults returns a shallow copy of ClientMetadata with default
+// values replacing omitted fields.
+func (m ClientMetadata) Defaults() ClientMetadata {
+ if len(m.ResponseTypes) == 0 {
+ m.ResponseTypes = []string{oauth2.ResponseTypeCode}
+ }
+ if len(m.GrantTypes) == 0 {
+ m.GrantTypes = []string{oauth2.GrantTypeAuthCode}
+ }
+ if m.ApplicationType == "" {
+ m.ApplicationType = "web"
+ }
+ if m.TokenEndpointAuthMethod == "" {
+ m.TokenEndpointAuthMethod = oauth2.AuthMethodClientSecretBasic
+ }
+ m.IDTokenResponseOptions = m.IDTokenResponseOptions.defaults()
+ m.UserInfoResponseOptions = m.UserInfoResponseOptions.defaults()
+ m.RequestObjectOptions = m.RequestObjectOptions.defaults()
+ return m
+}
+
+func (m *ClientMetadata) MarshalJSON() ([]byte, error) {
+ e := m.toEncodableStruct()
+ return json.Marshal(&e)
+}
+
+func (m *ClientMetadata) UnmarshalJSON(data []byte) error {
+ var e encodableClientMetadata
+ if err := json.Unmarshal(data, &e); err != nil {
+ return err
+ }
+ meta, err := e.toStruct()
+ if err != nil {
+ return err
+ }
+ if err := meta.Valid(); err != nil {
+ return err
+ }
+ *m = meta
+ return nil
+}
+
+type encodableClientMetadata struct {
+ RedirectURIs []string `json:"redirect_uris"` // Required
+ ResponseTypes []string `json:"response_types,omitempty"`
+ GrantTypes []string `json:"grant_types,omitempty"`
+ ApplicationType string `json:"application_type,omitempty"`
+ Contacts []string `json:"contacts,omitempty"`
+ ClientName string `json:"client_name,omitempty"`
+ LogoURI string `json:"logo_uri,omitempty"`
+ ClientURI string `json:"client_uri,omitempty"`
+ PolicyURI string `json:"policy_uri,omitempty"`
+ TermsOfServiceURI string `json:"tos_uri,omitempty"`
+ JWKSURI string `json:"jwks_uri,omitempty"`
+ JWKS *jose.JWKSet `json:"jwks,omitempty"`
+ SectorIdentifierURI string `json:"sector_identifier_uri,omitempty"`
+ SubjectType string `json:"subject_type,omitempty"`
+ IDTokenSignedResponseAlg string `json:"id_token_signed_response_alg,omitempty"`
+ IDTokenEncryptedResponseAlg string `json:"id_token_encrypted_response_alg,omitempty"`
+ IDTokenEncryptedResponseEnc string `json:"id_token_encrypted_response_enc,omitempty"`
+ UserInfoSignedResponseAlg string `json:"userinfo_signed_response_alg,omitempty"`
+ UserInfoEncryptedResponseAlg string `json:"userinfo_encrypted_response_alg,omitempty"`
+ UserInfoEncryptedResponseEnc string `json:"userinfo_encrypted_response_enc,omitempty"`
+ RequestObjectSigningAlg string `json:"request_object_signing_alg,omitempty"`
+ RequestObjectEncryptionAlg string `json:"request_object_encryption_alg,omitempty"`
+ RequestObjectEncryptionEnc string `json:"request_object_encryption_enc,omitempty"`
+ TokenEndpointAuthMethod string `json:"token_endpoint_auth_method,omitempty"`
+ TokenEndpointAuthSigningAlg string `json:"token_endpoint_auth_signing_alg,omitempty"`
+ DefaultMaxAge int64 `json:"default_max_age,omitempty"`
+ RequireAuthTime bool `json:"require_auth_time,omitempty"`
+ DefaultACRValues []string `json:"default_acr_values,omitempty"`
+ InitiateLoginURI string `json:"initiate_login_uri,omitempty"`
+ RequestURIs []string `json:"request_uris,omitempty"`
+}
+
+func (c *encodableClientMetadata) toStruct() (ClientMetadata, error) {
+ p := stickyErrParser{}
+ m := ClientMetadata{
+ RedirectURIs: p.parseURIs(c.RedirectURIs, "redirect_uris"),
+ ResponseTypes: c.ResponseTypes,
+ GrantTypes: c.GrantTypes,
+ ApplicationType: c.ApplicationType,
+ Contacts: p.parseEmails(c.Contacts, "contacts"),
+ ClientName: c.ClientName,
+ LogoURI: p.parseURI(c.LogoURI, "logo_uri"),
+ ClientURI: p.parseURI(c.ClientURI, "client_uri"),
+ PolicyURI: p.parseURI(c.PolicyURI, "policy_uri"),
+ TermsOfServiceURI: p.parseURI(c.TermsOfServiceURI, "tos_uri"),
+ JWKSURI: p.parseURI(c.JWKSURI, "jwks_uri"),
+ JWKS: c.JWKS,
+ SectorIdentifierURI: p.parseURI(c.SectorIdentifierURI, "sector_identifier_uri"),
+ SubjectType: c.SubjectType,
+ TokenEndpointAuthMethod: c.TokenEndpointAuthMethod,
+ TokenEndpointAuthSigningAlg: c.TokenEndpointAuthSigningAlg,
+ DefaultMaxAge: c.DefaultMaxAge,
+ RequireAuthTime: c.RequireAuthTime,
+ DefaultACRValues: c.DefaultACRValues,
+ InitiateLoginURI: p.parseURI(c.InitiateLoginURI, "initiate_login_uri"),
+ RequestURIs: p.parseURIs(c.RequestURIs, "request_uris"),
+ IDTokenResponseOptions: JWAOptions{
+ c.IDTokenSignedResponseAlg,
+ c.IDTokenEncryptedResponseAlg,
+ c.IDTokenEncryptedResponseEnc,
+ },
+ UserInfoResponseOptions: JWAOptions{
+ c.UserInfoSignedResponseAlg,
+ c.UserInfoEncryptedResponseAlg,
+ c.UserInfoEncryptedResponseEnc,
+ },
+ RequestObjectOptions: JWAOptions{
+ c.RequestObjectSigningAlg,
+ c.RequestObjectEncryptionAlg,
+ c.RequestObjectEncryptionEnc,
+ },
+ }
+ if p.firstErr != nil {
+ return ClientMetadata{}, p.firstErr
+ }
+ return m, nil
+}
+
+// stickyErrParser parses URIs and email addresses. Once it encounters
+// a parse error, subsequent calls become no-op.
+type stickyErrParser struct {
+ firstErr error
+}
+
+func (p *stickyErrParser) parseURI(s, field string) *url.URL {
+ if p.firstErr != nil || s == "" {
+ return nil
+ }
+ u, err := url.Parse(s)
+ if err == nil {
+ if u.Host == "" {
+ err = errors.New("no host in URI")
+ } else if u.Scheme != "http" && u.Scheme != "https" {
+ err = errors.New("invalid URI scheme")
+ }
+ }
+ if err != nil {
+ p.firstErr = fmt.Errorf("failed to parse %s: %v", field, err)
+ return nil
+ }
+ return u
+}
+
+func (p *stickyErrParser) parseURIs(s []string, field string) []url.URL {
+ if p.firstErr != nil || len(s) == 0 {
+ return nil
+ }
+ uris := make([]url.URL, len(s))
+ for i, val := range s {
+ if val == "" {
+ p.firstErr = fmt.Errorf("invalid URI in field %s", field)
+ return nil
+ }
+ if u := p.parseURI(val, field); u != nil {
+ uris[i] = *u
+ }
+ }
+ return uris
+}
+
+func (p *stickyErrParser) parseEmails(s []string, field string) []mail.Address {
+ if p.firstErr != nil || len(s) == 0 {
+ return nil
+ }
+ addrs := make([]mail.Address, len(s))
+ for i, addr := range s {
+ if addr == "" {
+ p.firstErr = fmt.Errorf("invalid email in field %s", field)
+ return nil
+ }
+ a, err := mail.ParseAddress(addr)
+ if err != nil {
+ p.firstErr = fmt.Errorf("invalid email in field %s: %v", field, err)
+ return nil
+ }
+ addrs[i] = *a
+ }
+ return addrs
+}
+
+func (m *ClientMetadata) toEncodableStruct() encodableClientMetadata {
+ return encodableClientMetadata{
+ RedirectURIs: urisToStrings(m.RedirectURIs),
+ ResponseTypes: m.ResponseTypes,
+ GrantTypes: m.GrantTypes,
+ ApplicationType: m.ApplicationType,
+ Contacts: emailsToStrings(m.Contacts),
+ ClientName: m.ClientName,
+ LogoURI: uriToString(m.LogoURI),
+ ClientURI: uriToString(m.ClientURI),
+ PolicyURI: uriToString(m.PolicyURI),
+ TermsOfServiceURI: uriToString(m.TermsOfServiceURI),
+ JWKSURI: uriToString(m.JWKSURI),
+ JWKS: m.JWKS,
+ SectorIdentifierURI: uriToString(m.SectorIdentifierURI),
+ SubjectType: m.SubjectType,
+ IDTokenSignedResponseAlg: m.IDTokenResponseOptions.SigningAlg,
+ IDTokenEncryptedResponseAlg: m.IDTokenResponseOptions.EncryptionAlg,
+ IDTokenEncryptedResponseEnc: m.IDTokenResponseOptions.EncryptionEnc,
+ UserInfoSignedResponseAlg: m.UserInfoResponseOptions.SigningAlg,
+ UserInfoEncryptedResponseAlg: m.UserInfoResponseOptions.EncryptionAlg,
+ UserInfoEncryptedResponseEnc: m.UserInfoResponseOptions.EncryptionEnc,
+ RequestObjectSigningAlg: m.RequestObjectOptions.SigningAlg,
+ RequestObjectEncryptionAlg: m.RequestObjectOptions.EncryptionAlg,
+ RequestObjectEncryptionEnc: m.RequestObjectOptions.EncryptionEnc,
+ TokenEndpointAuthMethod: m.TokenEndpointAuthMethod,
+ TokenEndpointAuthSigningAlg: m.TokenEndpointAuthSigningAlg,
+ DefaultMaxAge: m.DefaultMaxAge,
+ RequireAuthTime: m.RequireAuthTime,
+ DefaultACRValues: m.DefaultACRValues,
+ InitiateLoginURI: uriToString(m.InitiateLoginURI),
+ RequestURIs: urisToStrings(m.RequestURIs),
+ }
+}
+
+func uriToString(u *url.URL) string {
+ if u == nil {
+ return ""
+ }
+ return u.String()
+}
+
+func urisToStrings(urls []url.URL) []string {
+ if len(urls) == 0 {
+ return nil
+ }
+ sli := make([]string, len(urls))
+ for i, u := range urls {
+ sli[i] = u.String()
+ }
+ return sli
+}
+
+func emailsToStrings(addrs []mail.Address) []string {
+ if len(addrs) == 0 {
+ return nil
+ }
+ sli := make([]string, len(addrs))
+ for i, addr := range addrs {
+ sli[i] = addr.String()
+ }
+ return sli
+}
+
+// Valid determines if a ClientMetadata conforms with the OIDC specification.
+//
+// Valid is called by UnmarshalJSON.
+//
+// NOTE(ericchiang): For development purposes Valid does not mandate 'https' for
+// URLs fields where the OIDC spec requires it. This may change in future releases
+// of this package. See: https://github.com/coreos/go-oidc/issues/34
+func (m *ClientMetadata) Valid() error {
+ if len(m.RedirectURIs) == 0 {
+ return errors.New("zero redirect URLs")
+ }
+
+ validURI := func(u *url.URL, fieldName string) error {
+ if u.Host == "" {
+ return fmt.Errorf("no host for uri field %s", fieldName)
+ }
+ if u.Scheme != "http" && u.Scheme != "https" {
+ return fmt.Errorf("uri field %s scheme is not http or https", fieldName)
+ }
+ return nil
+ }
+
+ uris := []struct {
+ val *url.URL
+ name string
+ }{
+ {m.LogoURI, "logo_uri"},
+ {m.ClientURI, "client_uri"},
+ {m.PolicyURI, "policy_uri"},
+ {m.TermsOfServiceURI, "tos_uri"},
+ {m.JWKSURI, "jwks_uri"},
+ {m.SectorIdentifierURI, "sector_identifier_uri"},
+ {m.InitiateLoginURI, "initiate_login_uri"},
+ }
+
+ for _, uri := range uris {
+ if uri.val == nil {
+ continue
+ }
+ if err := validURI(uri.val, uri.name); err != nil {
+ return err
+ }
+ }
+
+ uriLists := []struct {
+ vals []url.URL
+ name string
+ }{
+ {m.RedirectURIs, "redirect_uris"},
+ {m.RequestURIs, "request_uris"},
+ }
+ for _, list := range uriLists {
+ for _, uri := range list.vals {
+ if err := validURI(&uri, list.name); err != nil {
+ return err
+ }
+ }
+ }
+
+ options := []struct {
+ option JWAOptions
+ name string
+ }{
+ {m.IDTokenResponseOptions, "id_token response"},
+ {m.UserInfoResponseOptions, "userinfo response"},
+ {m.RequestObjectOptions, "request_object"},
+ }
+ for _, option := range options {
+ if err := option.option.valid(); err != nil {
+ return fmt.Errorf("invalid JWA values for %s: %v", option.name, err)
+ }
+ }
+ return nil
+}
+
+type ClientRegistrationResponse struct {
+ ClientID string // Required
+ ClientSecret string
+ RegistrationAccessToken string
+ RegistrationClientURI string
+ // If IsZero is true, unspecified.
+ ClientIDIssuedAt time.Time
+ // Time at which the client_secret will expire.
+ // If IsZero is true, it will not expire.
+ ClientSecretExpiresAt time.Time
+
+ ClientMetadata
+}
+
+type encodableClientRegistrationResponse struct {
+ ClientID string `json:"client_id"` // Required
+ ClientSecret string `json:"client_secret,omitempty"`
+ RegistrationAccessToken string `json:"registration_access_token,omitempty"`
+ RegistrationClientURI string `json:"registration_client_uri,omitempty"`
+ ClientIDIssuedAt int64 `json:"client_id_issued_at,omitempty"`
+ // Time at which the client_secret will expire, in seconds since the epoch.
+ // If 0 it will not expire.
+ ClientSecretExpiresAt int64 `json:"client_secret_expires_at"` // Required
+
+ encodableClientMetadata
+}
+
+func unixToSec(t time.Time) int64 {
+ if t.IsZero() {
+ return 0
+ }
+ return t.Unix()
+}
+
+func (c *ClientRegistrationResponse) MarshalJSON() ([]byte, error) {
+ e := encodableClientRegistrationResponse{
+ ClientID: c.ClientID,
+ ClientSecret: c.ClientSecret,
+ RegistrationAccessToken: c.RegistrationAccessToken,
+ RegistrationClientURI: c.RegistrationClientURI,
+ ClientIDIssuedAt: unixToSec(c.ClientIDIssuedAt),
+ ClientSecretExpiresAt: unixToSec(c.ClientSecretExpiresAt),
+ encodableClientMetadata: c.ClientMetadata.toEncodableStruct(),
+ }
+ return json.Marshal(&e)
+}
+
+func secToUnix(sec int64) time.Time {
+ if sec == 0 {
+ return time.Time{}
+ }
+ return time.Unix(sec, 0)
+}
+
+func (c *ClientRegistrationResponse) UnmarshalJSON(data []byte) error {
+ var e encodableClientRegistrationResponse
+ if err := json.Unmarshal(data, &e); err != nil {
+ return err
+ }
+ if e.ClientID == "" {
+ return errors.New("no client_id in client registration response")
+ }
+ metadata, err := e.encodableClientMetadata.toStruct()
+ if err != nil {
+ return err
+ }
+ *c = ClientRegistrationResponse{
+ ClientID: e.ClientID,
+ ClientSecret: e.ClientSecret,
+ RegistrationAccessToken: e.RegistrationAccessToken,
+ RegistrationClientURI: e.RegistrationClientURI,
+ ClientIDIssuedAt: secToUnix(e.ClientIDIssuedAt),
+ ClientSecretExpiresAt: secToUnix(e.ClientSecretExpiresAt),
+ ClientMetadata: metadata,
+ }
+ return nil
+}
+
+type ClientConfig struct {
+ HTTPClient phttp.Client
+ Credentials ClientCredentials
+ Scope []string
+ RedirectURL string
+ ProviderConfig ProviderConfig
+ KeySet key.PublicKeySet
+}
+
+func NewClient(cfg ClientConfig) (*Client, error) {
+ // Allow empty redirect URL in the case where the client
+ // only needs to verify a given token.
+ ru, err := url.Parse(cfg.RedirectURL)
+ if err != nil {
+ return nil, fmt.Errorf("invalid redirect URL: %v", err)
+ }
+
+ c := Client{
+ credentials: cfg.Credentials,
+ httpClient: cfg.HTTPClient,
+ scope: cfg.Scope,
+ redirectURL: ru.String(),
+ providerConfig: newProviderConfigRepo(cfg.ProviderConfig),
+ keySet: cfg.KeySet,
+ }
+
+ if c.httpClient == nil {
+ c.httpClient = http.DefaultClient
+ }
+
+ if c.scope == nil {
+ c.scope = make([]string, len(DefaultScope))
+ copy(c.scope, DefaultScope)
+ }
+
+ return &c, nil
+}
+
+type Client struct {
+ httpClient phttp.Client
+ providerConfig *providerConfigRepo
+ credentials ClientCredentials
+ redirectURL string
+ scope []string
+ keySet key.PublicKeySet
+ providerSyncer *ProviderConfigSyncer
+
+ keySetSyncMutex sync.RWMutex
+ lastKeySetSync time.Time
+}
+
+func (c *Client) Healthy() error {
+ now := time.Now().UTC()
+
+ cfg := c.providerConfig.Get()
+
+ if cfg.Empty() {
+ return errors.New("oidc client provider config empty")
+ }
+
+ if !cfg.ExpiresAt.IsZero() && cfg.ExpiresAt.Before(now) {
+ return errors.New("oidc client provider config expired")
+ }
+
+ return nil
+}
+
+func (c *Client) OAuthClient() (*oauth2.Client, error) {
+ cfg := c.providerConfig.Get()
+ authMethod, err := chooseAuthMethod(cfg)
+ if err != nil {
+ return nil, err
+ }
+
+ ocfg := oauth2.Config{
+ Credentials: oauth2.ClientCredentials(c.credentials),
+ RedirectURL: c.redirectURL,
+ AuthURL: cfg.AuthEndpoint.String(),
+ TokenURL: cfg.TokenEndpoint.String(),
+ Scope: c.scope,
+ AuthMethod: authMethod,
+ }
+
+ return oauth2.NewClient(c.httpClient, ocfg)
+}
+
+func chooseAuthMethod(cfg ProviderConfig) (string, error) {
+ if len(cfg.TokenEndpointAuthMethodsSupported) == 0 {
+ return oauth2.AuthMethodClientSecretBasic, nil
+ }
+
+ for _, authMethod := range cfg.TokenEndpointAuthMethodsSupported {
+ if _, ok := supportedAuthMethods[authMethod]; ok {
+ return authMethod, nil
+ }
+ }
+
+ return "", errors.New("no supported auth methods")
+}
+
+// SyncProviderConfig starts the provider config syncer
+func (c *Client) SyncProviderConfig(discoveryURL string) chan struct{} {
+ r := NewHTTPProviderConfigGetter(c.httpClient, discoveryURL)
+ s := NewProviderConfigSyncer(r, c.providerConfig)
+ stop := s.Run()
+ s.WaitUntilInitialSync()
+ return stop
+}
+
+func (c *Client) maybeSyncKeys() error {
+ tooSoon := func() bool {
+ return time.Now().UTC().Before(c.lastKeySetSync.Add(keySyncWindow))
+ }
+
+ // ignore request to sync keys if a sync operation has been
+ // attempted too recently
+ if tooSoon() {
+ return nil
+ }
+
+ c.keySetSyncMutex.Lock()
+ defer c.keySetSyncMutex.Unlock()
+
+ // check again, as another goroutine may have been holding
+ // the lock while updating the keys
+ if tooSoon() {
+ return nil
+ }
+
+ cfg := c.providerConfig.Get()
+ r := NewRemotePublicKeyRepo(c.httpClient, cfg.KeysEndpoint.String())
+ w := &clientKeyRepo{client: c}
+ _, err := key.Sync(r, w)
+ c.lastKeySetSync = time.Now().UTC()
+
+ return err
+}
+
+type clientKeyRepo struct {
+ client *Client
+}
+
+func (r *clientKeyRepo) Set(ks key.KeySet) error {
+ pks, ok := ks.(*key.PublicKeySet)
+ if !ok {
+ return errors.New("unable to cast to PublicKey")
+ }
+ r.client.keySet = *pks
+ return nil
+}
+
+func (c *Client) ClientCredsToken(scope []string) (jose.JWT, error) {
+ cfg := c.providerConfig.Get()
+
+ if !cfg.SupportsGrantType(oauth2.GrantTypeClientCreds) {
+ return jose.JWT{}, fmt.Errorf("%v grant type is not supported", oauth2.GrantTypeClientCreds)
+ }
+
+ oac, err := c.OAuthClient()
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ t, err := oac.ClientCredsToken(scope)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ jwt, err := jose.ParseJWT(t.IDToken)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ return jwt, c.VerifyJWT(jwt)
+}
+
+// ExchangeAuthCode exchanges an OAuth2 auth code for an OIDC JWT ID token.
+func (c *Client) ExchangeAuthCode(code string) (jose.JWT, error) {
+ oac, err := c.OAuthClient()
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ t, err := oac.RequestToken(oauth2.GrantTypeAuthCode, code)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ jwt, err := jose.ParseJWT(t.IDToken)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ return jwt, c.VerifyJWT(jwt)
+}
+
+// RefreshToken uses a refresh token to exchange for a new OIDC JWT ID Token.
+func (c *Client) RefreshToken(refreshToken string) (jose.JWT, error) {
+ oac, err := c.OAuthClient()
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ t, err := oac.RequestToken(oauth2.GrantTypeRefreshToken, refreshToken)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ jwt, err := jose.ParseJWT(t.IDToken)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ return jwt, c.VerifyJWT(jwt)
+}
+
+func (c *Client) VerifyJWT(jwt jose.JWT) error {
+ var keysFunc func() []key.PublicKey
+ if kID, ok := jwt.KeyID(); ok {
+ keysFunc = c.keysFuncWithID(kID)
+ } else {
+ keysFunc = c.keysFuncAll()
+ }
+
+ v := NewJWTVerifier(
+ c.providerConfig.Get().Issuer.String(),
+ c.credentials.ID,
+ c.maybeSyncKeys, keysFunc)
+
+ return v.Verify(jwt)
+}
+
+// keysFuncWithID returns a function that retrieves at most unexpired
+// public key from the Client that matches the provided ID
+func (c *Client) keysFuncWithID(kID string) func() []key.PublicKey {
+ return func() []key.PublicKey {
+ c.keySetSyncMutex.RLock()
+ defer c.keySetSyncMutex.RUnlock()
+
+ if c.keySet.ExpiresAt().Before(time.Now()) {
+ return []key.PublicKey{}
+ }
+
+ k := c.keySet.Key(kID)
+ if k == nil {
+ return []key.PublicKey{}
+ }
+
+ return []key.PublicKey{*k}
+ }
+}
+
+// keysFuncAll returns a function that retrieves all unexpired public
+// keys from the Client
+func (c *Client) keysFuncAll() func() []key.PublicKey {
+ return func() []key.PublicKey {
+ c.keySetSyncMutex.RLock()
+ defer c.keySetSyncMutex.RUnlock()
+
+ if c.keySet.ExpiresAt().Before(time.Now()) {
+ return []key.PublicKey{}
+ }
+
+ return c.keySet.Keys()
+ }
+}
+
+type providerConfigRepo struct {
+ mu sync.RWMutex
+ config ProviderConfig // do not access directly, use Get()
+}
+
+func newProviderConfigRepo(pc ProviderConfig) *providerConfigRepo {
+ return &providerConfigRepo{sync.RWMutex{}, pc}
+}
+
+// returns an error to implement ProviderConfigSetter
+func (r *providerConfigRepo) Set(cfg ProviderConfig) error {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ r.config = cfg
+ return nil
+}
+
+func (r *providerConfigRepo) Get() ProviderConfig {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ return r.config
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/identity.go b/vendor/github.com/coreos/go-oidc/oidc/identity.go
new file mode 100644
index 0000000000000000000000000000000000000000..9bfa8e34399497a5fe144b153909af2b1a12005f
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/identity.go
@@ -0,0 +1,44 @@
+package oidc
+
+import (
+ "errors"
+ "time"
+
+ "github.com/coreos/go-oidc/jose"
+)
+
+type Identity struct {
+ ID string
+ Name string
+ Email string
+ ExpiresAt time.Time
+}
+
+func IdentityFromClaims(claims jose.Claims) (*Identity, error) {
+ if claims == nil {
+ return nil, errors.New("nil claim set")
+ }
+
+ var ident Identity
+ var err error
+ var ok bool
+
+ if ident.ID, ok, err = claims.StringClaim("sub"); err != nil {
+ return nil, err
+ } else if !ok {
+ return nil, errors.New("missing required claim: sub")
+ }
+
+ if ident.Email, _, err = claims.StringClaim("email"); err != nil {
+ return nil, err
+ }
+
+ exp, ok, err := claims.TimeClaim("exp")
+ if err != nil {
+ return nil, err
+ } else if ok {
+ ident.ExpiresAt = exp
+ }
+
+ return &ident, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/interface.go b/vendor/github.com/coreos/go-oidc/oidc/interface.go
new file mode 100644
index 0000000000000000000000000000000000000000..248cac0b4dffade360f03e63071dbb008950bc0b
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/interface.go
@@ -0,0 +1,3 @@
+package oidc
+
+type LoginFunc func(ident Identity, sessionKey string) (redirectURL string, err error)
diff --git a/vendor/github.com/coreos/go-oidc/oidc/key.go b/vendor/github.com/coreos/go-oidc/oidc/key.go
new file mode 100755
index 0000000000000000000000000000000000000000..82a0f567d5777bb74528984c6e6d3d9915d2a15d
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/key.go
@@ -0,0 +1,67 @@
+package oidc
+
+import (
+ "encoding/json"
+ "errors"
+ "net/http"
+ "time"
+
+ phttp "github.com/coreos/go-oidc/http"
+ "github.com/coreos/go-oidc/jose"
+ "github.com/coreos/go-oidc/key"
+)
+
+// DefaultPublicKeySetTTL is the default TTL set on the PublicKeySet if no
+// Cache-Control header is provided by the JWK Set document endpoint.
+const DefaultPublicKeySetTTL = 24 * time.Hour
+
+// NewRemotePublicKeyRepo is responsible for fetching the JWK Set document.
+func NewRemotePublicKeyRepo(hc phttp.Client, ep string) *remotePublicKeyRepo {
+ return &remotePublicKeyRepo{hc: hc, ep: ep}
+}
+
+type remotePublicKeyRepo struct {
+ hc phttp.Client
+ ep string
+}
+
+// Get returns a PublicKeySet fetched from the JWK Set document endpoint. A TTL
+// is set on the Key Set to avoid it having to be re-retrieved for every
+// encryption event. This TTL is typically controlled by the endpoint returning
+// a Cache-Control header, but defaults to 24 hours if no Cache-Control header
+// is found.
+func (r *remotePublicKeyRepo) Get() (key.KeySet, error) {
+ req, err := http.NewRequest("GET", r.ep, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ resp, err := r.hc.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ var d struct {
+ Keys []jose.JWK `json:"keys"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
+ return nil, err
+ }
+
+ if len(d.Keys) == 0 {
+ return nil, errors.New("zero keys in response")
+ }
+
+ ttl, ok, err := phttp.Cacheable(resp.Header)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ ttl = DefaultPublicKeySetTTL
+ }
+
+ exp := time.Now().UTC().Add(ttl)
+ ks := key.NewPublicKeySet(d.Keys, exp)
+ return ks, nil
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/provider.go b/vendor/github.com/coreos/go-oidc/oidc/provider.go
new file mode 100644
index 0000000000000000000000000000000000000000..ca2838440b3e9123b8edbd1e175ece62139a4428
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/provider.go
@@ -0,0 +1,690 @@
+package oidc
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "log"
+ "net/http"
+ "net/url"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/coreos/pkg/timeutil"
+ "github.com/jonboulle/clockwork"
+
+ phttp "github.com/coreos/go-oidc/http"
+ "github.com/coreos/go-oidc/oauth2"
+)
+
+const (
+ // Subject Identifier types defined by the OIDC spec. Specifies if the provider
+ // should provide the same sub claim value to all clients (public) or a unique
+ // value for each client (pairwise).
+ //
+ // See: http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes
+ SubjectTypePublic = "public"
+ SubjectTypePairwise = "pairwise"
+)
+
+var (
+ // Default values for omitted provider config fields.
+ //
+ // Use ProviderConfig's Defaults method to fill a provider config with these values.
+ DefaultGrantTypesSupported = []string{oauth2.GrantTypeAuthCode, oauth2.GrantTypeImplicit}
+ DefaultResponseModesSupported = []string{"query", "fragment"}
+ DefaultTokenEndpointAuthMethodsSupported = []string{oauth2.AuthMethodClientSecretBasic}
+ DefaultClaimTypesSupported = []string{"normal"}
+)
+
+const (
+ MaximumProviderConfigSyncInterval = 24 * time.Hour
+ MinimumProviderConfigSyncInterval = time.Minute
+
+ discoveryConfigPath = "/.well-known/openid-configuration"
+)
+
+// internally configurable for tests
+var minimumProviderConfigSyncInterval = MinimumProviderConfigSyncInterval
+
+var (
+ // Ensure ProviderConfig satisfies these interfaces.
+ _ json.Marshaler = &ProviderConfig{}
+ _ json.Unmarshaler = &ProviderConfig{}
+)
+
+// ProviderConfig represents the OpenID Provider Metadata specifying what
+// configurations a provider supports.
+//
+// See: http://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata
+type ProviderConfig struct {
+ Issuer *url.URL // Required
+ AuthEndpoint *url.URL // Required
+ TokenEndpoint *url.URL // Required if grant types other than "implicit" are supported
+ UserInfoEndpoint *url.URL
+ KeysEndpoint *url.URL // Required
+ RegistrationEndpoint *url.URL
+ EndSessionEndpoint *url.URL
+ CheckSessionIFrame *url.URL
+
+ // Servers MAY choose not to advertise some supported scope values even when this
+ // parameter is used, although those defined in OpenID Core SHOULD be listed, if supported.
+ ScopesSupported []string
+ // OAuth2.0 response types supported.
+ ResponseTypesSupported []string // Required
+ // OAuth2.0 response modes supported.
+ //
+ // If omitted, defaults to DefaultResponseModesSupported.
+ ResponseModesSupported []string
+ // OAuth2.0 grant types supported.
+ //
+ // If omitted, defaults to DefaultGrantTypesSupported.
+ GrantTypesSupported []string
+ ACRValuesSupported []string
+ // SubjectTypesSupported specifies strategies for providing values for the sub claim.
+ SubjectTypesSupported []string // Required
+
+ // JWA signing and encryption algorith values supported for ID tokens.
+ IDTokenSigningAlgValues []string // Required
+ IDTokenEncryptionAlgValues []string
+ IDTokenEncryptionEncValues []string
+
+ // JWA signing and encryption algorith values supported for user info responses.
+ UserInfoSigningAlgValues []string
+ UserInfoEncryptionAlgValues []string
+ UserInfoEncryptionEncValues []string
+
+ // JWA signing and encryption algorith values supported for request objects.
+ ReqObjSigningAlgValues []string
+ ReqObjEncryptionAlgValues []string
+ ReqObjEncryptionEncValues []string
+
+ TokenEndpointAuthMethodsSupported []string
+ TokenEndpointAuthSigningAlgValuesSupported []string
+ DisplayValuesSupported []string
+ ClaimTypesSupported []string
+ ClaimsSupported []string
+ ServiceDocs *url.URL
+ ClaimsLocalsSupported []string
+ UILocalsSupported []string
+ ClaimsParameterSupported bool
+ RequestParameterSupported bool
+ RequestURIParamaterSupported bool
+ RequireRequestURIRegistration bool
+
+ Policy *url.URL
+ TermsOfService *url.URL
+
+ // Not part of the OpenID Provider Metadata
+ ExpiresAt time.Time
+}
+
+// Defaults returns a shallow copy of ProviderConfig with default
+// values replacing omitted fields.
+//
+// var cfg oidc.ProviderConfig
+// // Fill provider config with default values for omitted fields.
+// cfg = cfg.Defaults()
+//
+func (p ProviderConfig) Defaults() ProviderConfig {
+ setDefault := func(val *[]string, defaultVal []string) {
+ if len(*val) == 0 {
+ *val = defaultVal
+ }
+ }
+ setDefault(&p.GrantTypesSupported, DefaultGrantTypesSupported)
+ setDefault(&p.ResponseModesSupported, DefaultResponseModesSupported)
+ setDefault(&p.TokenEndpointAuthMethodsSupported, DefaultTokenEndpointAuthMethodsSupported)
+ setDefault(&p.ClaimTypesSupported, DefaultClaimTypesSupported)
+ return p
+}
+
+func (p *ProviderConfig) MarshalJSON() ([]byte, error) {
+ e := p.toEncodableStruct()
+ return json.Marshal(&e)
+}
+
+func (p *ProviderConfig) UnmarshalJSON(data []byte) error {
+ var e encodableProviderConfig
+ if err := json.Unmarshal(data, &e); err != nil {
+ return err
+ }
+ conf, err := e.toStruct()
+ if err != nil {
+ return err
+ }
+ if err := conf.Valid(); err != nil {
+ return err
+ }
+ *p = conf
+ return nil
+}
+
+type encodableProviderConfig struct {
+ Issuer string `json:"issuer"`
+ AuthEndpoint string `json:"authorization_endpoint"`
+ TokenEndpoint string `json:"token_endpoint"`
+ UserInfoEndpoint string `json:"userinfo_endpoint,omitempty"`
+ KeysEndpoint string `json:"jwks_uri"`
+ RegistrationEndpoint string `json:"registration_endpoint,omitempty"`
+ EndSessionEndpoint string `json:"end_session_endpoint,omitempty"`
+ CheckSessionIFrame string `json:"check_session_iframe,omitempty"`
+
+ // Use 'omitempty' for all slices as per OIDC spec:
+ // "Claims that return multiple values are represented as JSON arrays.
+ // Claims with zero elements MUST be omitted from the response."
+ // http://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationResponse
+
+ ScopesSupported []string `json:"scopes_supported,omitempty"`
+ ResponseTypesSupported []string `json:"response_types_supported,omitempty"`
+ ResponseModesSupported []string `json:"response_modes_supported,omitempty"`
+ GrantTypesSupported []string `json:"grant_types_supported,omitempty"`
+ ACRValuesSupported []string `json:"acr_values_supported,omitempty"`
+ SubjectTypesSupported []string `json:"subject_types_supported,omitempty"`
+
+ IDTokenSigningAlgValues []string `json:"id_token_signing_alg_values_supported,omitempty"`
+ IDTokenEncryptionAlgValues []string `json:"id_token_encryption_alg_values_supported,omitempty"`
+ IDTokenEncryptionEncValues []string `json:"id_token_encryption_enc_values_supported,omitempty"`
+ UserInfoSigningAlgValues []string `json:"userinfo_signing_alg_values_supported,omitempty"`
+ UserInfoEncryptionAlgValues []string `json:"userinfo_encryption_alg_values_supported,omitempty"`
+ UserInfoEncryptionEncValues []string `json:"userinfo_encryption_enc_values_supported,omitempty"`
+ ReqObjSigningAlgValues []string `json:"request_object_signing_alg_values_supported,omitempty"`
+ ReqObjEncryptionAlgValues []string `json:"request_object_encryption_alg_values_supported,omitempty"`
+ ReqObjEncryptionEncValues []string `json:"request_object_encryption_enc_values_supported,omitempty"`
+
+ TokenEndpointAuthMethodsSupported []string `json:"token_endpoint_auth_methods_supported,omitempty"`
+ TokenEndpointAuthSigningAlgValuesSupported []string `json:"token_endpoint_auth_signing_alg_values_supported,omitempty"`
+
+ DisplayValuesSupported []string `json:"display_values_supported,omitempty"`
+ ClaimTypesSupported []string `json:"claim_types_supported,omitempty"`
+ ClaimsSupported []string `json:"claims_supported,omitempty"`
+ ServiceDocs string `json:"service_documentation,omitempty"`
+ ClaimsLocalsSupported []string `json:"claims_locales_supported,omitempty"`
+ UILocalsSupported []string `json:"ui_locales_supported,omitempty"`
+ ClaimsParameterSupported bool `json:"claims_parameter_supported,omitempty"`
+ RequestParameterSupported bool `json:"request_parameter_supported,omitempty"`
+ RequestURIParamaterSupported bool `json:"request_uri_parameter_supported,omitempty"`
+ RequireRequestURIRegistration bool `json:"require_request_uri_registration,omitempty"`
+
+ Policy string `json:"op_policy_uri,omitempty"`
+ TermsOfService string `json:"op_tos_uri,omitempty"`
+}
+
+func (cfg ProviderConfig) toEncodableStruct() encodableProviderConfig {
+ return encodableProviderConfig{
+ Issuer: uriToString(cfg.Issuer),
+ AuthEndpoint: uriToString(cfg.AuthEndpoint),
+ TokenEndpoint: uriToString(cfg.TokenEndpoint),
+ UserInfoEndpoint: uriToString(cfg.UserInfoEndpoint),
+ KeysEndpoint: uriToString(cfg.KeysEndpoint),
+ RegistrationEndpoint: uriToString(cfg.RegistrationEndpoint),
+ EndSessionEndpoint: uriToString(cfg.EndSessionEndpoint),
+ CheckSessionIFrame: uriToString(cfg.CheckSessionIFrame),
+ ScopesSupported: cfg.ScopesSupported,
+ ResponseTypesSupported: cfg.ResponseTypesSupported,
+ ResponseModesSupported: cfg.ResponseModesSupported,
+ GrantTypesSupported: cfg.GrantTypesSupported,
+ ACRValuesSupported: cfg.ACRValuesSupported,
+ SubjectTypesSupported: cfg.SubjectTypesSupported,
+ IDTokenSigningAlgValues: cfg.IDTokenSigningAlgValues,
+ IDTokenEncryptionAlgValues: cfg.IDTokenEncryptionAlgValues,
+ IDTokenEncryptionEncValues: cfg.IDTokenEncryptionEncValues,
+ UserInfoSigningAlgValues: cfg.UserInfoSigningAlgValues,
+ UserInfoEncryptionAlgValues: cfg.UserInfoEncryptionAlgValues,
+ UserInfoEncryptionEncValues: cfg.UserInfoEncryptionEncValues,
+ ReqObjSigningAlgValues: cfg.ReqObjSigningAlgValues,
+ ReqObjEncryptionAlgValues: cfg.ReqObjEncryptionAlgValues,
+ ReqObjEncryptionEncValues: cfg.ReqObjEncryptionEncValues,
+ TokenEndpointAuthMethodsSupported: cfg.TokenEndpointAuthMethodsSupported,
+ TokenEndpointAuthSigningAlgValuesSupported: cfg.TokenEndpointAuthSigningAlgValuesSupported,
+ DisplayValuesSupported: cfg.DisplayValuesSupported,
+ ClaimTypesSupported: cfg.ClaimTypesSupported,
+ ClaimsSupported: cfg.ClaimsSupported,
+ ServiceDocs: uriToString(cfg.ServiceDocs),
+ ClaimsLocalsSupported: cfg.ClaimsLocalsSupported,
+ UILocalsSupported: cfg.UILocalsSupported,
+ ClaimsParameterSupported: cfg.ClaimsParameterSupported,
+ RequestParameterSupported: cfg.RequestParameterSupported,
+ RequestURIParamaterSupported: cfg.RequestURIParamaterSupported,
+ RequireRequestURIRegistration: cfg.RequireRequestURIRegistration,
+ Policy: uriToString(cfg.Policy),
+ TermsOfService: uriToString(cfg.TermsOfService),
+ }
+}
+
+func (e encodableProviderConfig) toStruct() (ProviderConfig, error) {
+ p := stickyErrParser{}
+ conf := ProviderConfig{
+ Issuer: p.parseURI(e.Issuer, "issuer"),
+ AuthEndpoint: p.parseURI(e.AuthEndpoint, "authorization_endpoint"),
+ TokenEndpoint: p.parseURI(e.TokenEndpoint, "token_endpoint"),
+ UserInfoEndpoint: p.parseURI(e.UserInfoEndpoint, "userinfo_endpoint"),
+ KeysEndpoint: p.parseURI(e.KeysEndpoint, "jwks_uri"),
+ RegistrationEndpoint: p.parseURI(e.RegistrationEndpoint, "registration_endpoint"),
+ EndSessionEndpoint: p.parseURI(e.EndSessionEndpoint, "end_session_endpoint"),
+ CheckSessionIFrame: p.parseURI(e.CheckSessionIFrame, "check_session_iframe"),
+ ScopesSupported: e.ScopesSupported,
+ ResponseTypesSupported: e.ResponseTypesSupported,
+ ResponseModesSupported: e.ResponseModesSupported,
+ GrantTypesSupported: e.GrantTypesSupported,
+ ACRValuesSupported: e.ACRValuesSupported,
+ SubjectTypesSupported: e.SubjectTypesSupported,
+ IDTokenSigningAlgValues: e.IDTokenSigningAlgValues,
+ IDTokenEncryptionAlgValues: e.IDTokenEncryptionAlgValues,
+ IDTokenEncryptionEncValues: e.IDTokenEncryptionEncValues,
+ UserInfoSigningAlgValues: e.UserInfoSigningAlgValues,
+ UserInfoEncryptionAlgValues: e.UserInfoEncryptionAlgValues,
+ UserInfoEncryptionEncValues: e.UserInfoEncryptionEncValues,
+ ReqObjSigningAlgValues: e.ReqObjSigningAlgValues,
+ ReqObjEncryptionAlgValues: e.ReqObjEncryptionAlgValues,
+ ReqObjEncryptionEncValues: e.ReqObjEncryptionEncValues,
+ TokenEndpointAuthMethodsSupported: e.TokenEndpointAuthMethodsSupported,
+ TokenEndpointAuthSigningAlgValuesSupported: e.TokenEndpointAuthSigningAlgValuesSupported,
+ DisplayValuesSupported: e.DisplayValuesSupported,
+ ClaimTypesSupported: e.ClaimTypesSupported,
+ ClaimsSupported: e.ClaimsSupported,
+ ServiceDocs: p.parseURI(e.ServiceDocs, "service_documentation"),
+ ClaimsLocalsSupported: e.ClaimsLocalsSupported,
+ UILocalsSupported: e.UILocalsSupported,
+ ClaimsParameterSupported: e.ClaimsParameterSupported,
+ RequestParameterSupported: e.RequestParameterSupported,
+ RequestURIParamaterSupported: e.RequestURIParamaterSupported,
+ RequireRequestURIRegistration: e.RequireRequestURIRegistration,
+ Policy: p.parseURI(e.Policy, "op_policy-uri"),
+ TermsOfService: p.parseURI(e.TermsOfService, "op_tos_uri"),
+ }
+ if p.firstErr != nil {
+ return ProviderConfig{}, p.firstErr
+ }
+ return conf, nil
+}
+
+// Empty returns if a ProviderConfig holds no information.
+//
+// This case generally indicates a ProviderConfigGetter has experienced an error
+// and has nothing to report.
+func (p ProviderConfig) Empty() bool {
+ return p.Issuer == nil
+}
+
+func contains(sli []string, ele string) bool {
+ for _, s := range sli {
+ if s == ele {
+ return true
+ }
+ }
+ return false
+}
+
+// Valid determines if a ProviderConfig conforms with the OIDC specification.
+// If Valid returns successfully it guarantees required field are non-nil and
+// URLs are well formed.
+//
+// Valid is called by UnmarshalJSON.
+//
+// NOTE(ericchiang): For development purposes Valid does not mandate 'https' for
+// URLs fields where the OIDC spec requires it. This may change in future releases
+// of this package. See: https://github.com/coreos/go-oidc/issues/34
+func (p ProviderConfig) Valid() error {
+ grantTypes := p.GrantTypesSupported
+ if len(grantTypes) == 0 {
+ grantTypes = DefaultGrantTypesSupported
+ }
+ implicitOnly := true
+ for _, grantType := range grantTypes {
+ if grantType != oauth2.GrantTypeImplicit {
+ implicitOnly = false
+ break
+ }
+ }
+
+ if len(p.SubjectTypesSupported) == 0 {
+ return errors.New("missing required field subject_types_supported")
+ }
+ if len(p.IDTokenSigningAlgValues) == 0 {
+ return errors.New("missing required field id_token_signing_alg_values_supported")
+ }
+
+ if len(p.ScopesSupported) != 0 && !contains(p.ScopesSupported, "openid") {
+ return errors.New("scoped_supported must be unspecified or include 'openid'")
+ }
+
+ if !contains(p.IDTokenSigningAlgValues, "RS256") {
+ return errors.New("id_token_signing_alg_values_supported must include 'RS256'")
+ }
+ if contains(p.TokenEndpointAuthMethodsSupported, "none") {
+ return errors.New("token_endpoint_auth_signing_alg_values_supported cannot include 'none'")
+ }
+
+ uris := []struct {
+ val *url.URL
+ name string
+ required bool
+ }{
+ {p.Issuer, "issuer", true},
+ {p.AuthEndpoint, "authorization_endpoint", true},
+ {p.TokenEndpoint, "token_endpoint", !implicitOnly},
+ {p.UserInfoEndpoint, "userinfo_endpoint", false},
+ {p.KeysEndpoint, "jwks_uri", true},
+ {p.RegistrationEndpoint, "registration_endpoint", false},
+ {p.EndSessionEndpoint, "end_session_endpoint", false},
+ {p.CheckSessionIFrame, "check_session_iframe", false},
+ {p.ServiceDocs, "service_documentation", false},
+ {p.Policy, "op_policy_uri", false},
+ {p.TermsOfService, "op_tos_uri", false},
+ }
+
+ for _, uri := range uris {
+ if uri.val == nil {
+ if !uri.required {
+ continue
+ }
+ return fmt.Errorf("empty value for required uri field %s", uri.name)
+ }
+ if uri.val.Host == "" {
+ return fmt.Errorf("no host for uri field %s", uri.name)
+ }
+ if uri.val.Scheme != "http" && uri.val.Scheme != "https" {
+ return fmt.Errorf("uri field %s schemeis not http or https", uri.name)
+ }
+ }
+ return nil
+}
+
+// Supports determines if provider supports a client given their respective metadata.
+func (p ProviderConfig) Supports(c ClientMetadata) error {
+ if err := p.Valid(); err != nil {
+ return fmt.Errorf("invalid provider config: %v", err)
+ }
+ if err := c.Valid(); err != nil {
+ return fmt.Errorf("invalid client config: %v", err)
+ }
+
+ // Fill default values for omitted fields
+ c = c.Defaults()
+ p = p.Defaults()
+
+ // Do the supported values list the requested one?
+ supports := []struct {
+ supported []string
+ requested string
+ name string
+ }{
+ {p.IDTokenSigningAlgValues, c.IDTokenResponseOptions.SigningAlg, "id_token_signed_response_alg"},
+ {p.IDTokenEncryptionAlgValues, c.IDTokenResponseOptions.EncryptionAlg, "id_token_encryption_response_alg"},
+ {p.IDTokenEncryptionEncValues, c.IDTokenResponseOptions.EncryptionEnc, "id_token_encryption_response_enc"},
+ {p.UserInfoSigningAlgValues, c.UserInfoResponseOptions.SigningAlg, "userinfo_signed_response_alg"},
+ {p.UserInfoEncryptionAlgValues, c.UserInfoResponseOptions.EncryptionAlg, "userinfo_encryption_response_alg"},
+ {p.UserInfoEncryptionEncValues, c.UserInfoResponseOptions.EncryptionEnc, "userinfo_encryption_response_enc"},
+ {p.ReqObjSigningAlgValues, c.RequestObjectOptions.SigningAlg, "request_object_signing_alg"},
+ {p.ReqObjEncryptionAlgValues, c.RequestObjectOptions.EncryptionAlg, "request_object_encryption_alg"},
+ {p.ReqObjEncryptionEncValues, c.RequestObjectOptions.EncryptionEnc, "request_object_encryption_enc"},
+ }
+ for _, field := range supports {
+ if field.requested == "" {
+ continue
+ }
+ if !contains(field.supported, field.requested) {
+ return fmt.Errorf("provider does not support requested value for field %s", field.name)
+ }
+ }
+
+ stringsEqual := func(s1, s2 string) bool { return s1 == s2 }
+
+ // For lists, are the list of requested values a subset of the supported ones?
+ supportsAll := []struct {
+ supported []string
+ requested []string
+ name string
+ // OAuth2.0 response_type can be space separated lists where order doesn't matter.
+ // For example "id_token token" is the same as "token id_token"
+ // Support a custom compare method.
+ comp func(s1, s2 string) bool
+ }{
+ {p.GrantTypesSupported, c.GrantTypes, "grant_types", stringsEqual},
+ {p.ResponseTypesSupported, c.ResponseTypes, "response_type", oauth2.ResponseTypesEqual},
+ }
+ for _, field := range supportsAll {
+ requestLoop:
+ for _, req := range field.requested {
+ for _, sup := range field.supported {
+ if field.comp(req, sup) {
+ continue requestLoop
+ }
+ }
+ return fmt.Errorf("provider does not support requested value for field %s", field.name)
+ }
+ }
+
+ // TODO(ericchiang): Are there more checks we feel comfortable with begin strict about?
+
+ return nil
+}
+
+func (p ProviderConfig) SupportsGrantType(grantType string) bool {
+ var supported []string
+ if len(p.GrantTypesSupported) == 0 {
+ supported = DefaultGrantTypesSupported
+ } else {
+ supported = p.GrantTypesSupported
+ }
+
+ for _, t := range supported {
+ if t == grantType {
+ return true
+ }
+ }
+ return false
+}
+
+type ProviderConfigGetter interface {
+ Get() (ProviderConfig, error)
+}
+
+type ProviderConfigSetter interface {
+ Set(ProviderConfig) error
+}
+
+type ProviderConfigSyncer struct {
+ from ProviderConfigGetter
+ to ProviderConfigSetter
+ clock clockwork.Clock
+
+ initialSyncDone bool
+ initialSyncWait sync.WaitGroup
+}
+
+func NewProviderConfigSyncer(from ProviderConfigGetter, to ProviderConfigSetter) *ProviderConfigSyncer {
+ return &ProviderConfigSyncer{
+ from: from,
+ to: to,
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+func (s *ProviderConfigSyncer) Run() chan struct{} {
+ stop := make(chan struct{})
+
+ var next pcsStepper
+ next = &pcsStepNext{aft: time.Duration(0)}
+
+ s.initialSyncWait.Add(1)
+ go func() {
+ for {
+ select {
+ case <-s.clock.After(next.after()):
+ next = next.step(s.sync)
+ case <-stop:
+ return
+ }
+ }
+ }()
+
+ return stop
+}
+
+func (s *ProviderConfigSyncer) WaitUntilInitialSync() {
+ s.initialSyncWait.Wait()
+}
+
+func (s *ProviderConfigSyncer) sync() (time.Duration, error) {
+ cfg, err := s.from.Get()
+ if err != nil {
+ return 0, err
+ }
+
+ if err = s.to.Set(cfg); err != nil {
+ return 0, fmt.Errorf("error setting provider config: %v", err)
+ }
+
+ if !s.initialSyncDone {
+ s.initialSyncWait.Done()
+ s.initialSyncDone = true
+ }
+
+ return nextSyncAfter(cfg.ExpiresAt, s.clock), nil
+}
+
+type pcsStepFunc func() (time.Duration, error)
+
+type pcsStepper interface {
+ after() time.Duration
+ step(pcsStepFunc) pcsStepper
+}
+
+type pcsStepNext struct {
+ aft time.Duration
+}
+
+func (n *pcsStepNext) after() time.Duration {
+ return n.aft
+}
+
+func (n *pcsStepNext) step(fn pcsStepFunc) (next pcsStepper) {
+ ttl, err := fn()
+ if err == nil {
+ next = &pcsStepNext{aft: ttl}
+ } else {
+ next = &pcsStepRetry{aft: time.Second}
+ log.Printf("go-oidc: provider config sync falied, retyring in %v: %v", next.after(), err)
+ }
+ return
+}
+
+type pcsStepRetry struct {
+ aft time.Duration
+}
+
+func (r *pcsStepRetry) after() time.Duration {
+ return r.aft
+}
+
+func (r *pcsStepRetry) step(fn pcsStepFunc) (next pcsStepper) {
+ ttl, err := fn()
+ if err == nil {
+ next = &pcsStepNext{aft: ttl}
+ } else {
+ next = &pcsStepRetry{aft: timeutil.ExpBackoff(r.aft, time.Minute)}
+ log.Printf("go-oidc: provider config sync falied, retyring in %v: %v", next.after(), err)
+ }
+ return
+}
+
+func nextSyncAfter(exp time.Time, clock clockwork.Clock) time.Duration {
+ if exp.IsZero() {
+ return MaximumProviderConfigSyncInterval
+ }
+
+ t := exp.Sub(clock.Now()) / 2
+ if t > MaximumProviderConfigSyncInterval {
+ t = MaximumProviderConfigSyncInterval
+ } else if t < minimumProviderConfigSyncInterval {
+ t = minimumProviderConfigSyncInterval
+ }
+
+ return t
+}
+
+type httpProviderConfigGetter struct {
+ hc phttp.Client
+ issuerURL string
+ clock clockwork.Clock
+}
+
+func NewHTTPProviderConfigGetter(hc phttp.Client, issuerURL string) *httpProviderConfigGetter {
+ return &httpProviderConfigGetter{
+ hc: hc,
+ issuerURL: issuerURL,
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+func (r *httpProviderConfigGetter) Get() (cfg ProviderConfig, err error) {
+ // If the Issuer value contains a path component, any terminating / MUST be removed before
+ // appending /.well-known/openid-configuration.
+ // https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationRequest
+ discoveryURL := strings.TrimSuffix(r.issuerURL, "/") + discoveryConfigPath
+ req, err := http.NewRequest("GET", discoveryURL, nil)
+ if err != nil {
+ return
+ }
+
+ resp, err := r.hc.Do(req)
+ if err != nil {
+ return
+ }
+ defer resp.Body.Close()
+
+ if err = json.NewDecoder(resp.Body).Decode(&cfg); err != nil {
+ return
+ }
+
+ var ttl time.Duration
+ var ok bool
+ ttl, ok, err = phttp.Cacheable(resp.Header)
+ if err != nil {
+ return
+ } else if ok {
+ cfg.ExpiresAt = r.clock.Now().UTC().Add(ttl)
+ }
+
+ // The issuer value returned MUST be identical to the Issuer URL that was directly used to retrieve the configuration information.
+ // http://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationValidation
+ if !urlEqual(cfg.Issuer.String(), r.issuerURL) {
+ err = fmt.Errorf(`"issuer" in config (%v) does not match provided issuer URL (%v)`, cfg.Issuer, r.issuerURL)
+ return
+ }
+
+ return
+}
+
+func FetchProviderConfig(hc phttp.Client, issuerURL string) (ProviderConfig, error) {
+ if hc == nil {
+ hc = http.DefaultClient
+ }
+
+ g := NewHTTPProviderConfigGetter(hc, issuerURL)
+ return g.Get()
+}
+
+func WaitForProviderConfig(hc phttp.Client, issuerURL string) (pcfg ProviderConfig) {
+ return waitForProviderConfig(hc, issuerURL, clockwork.NewRealClock())
+}
+
+func waitForProviderConfig(hc phttp.Client, issuerURL string, clock clockwork.Clock) (pcfg ProviderConfig) {
+ var sleep time.Duration
+ var err error
+ for {
+ pcfg, err = FetchProviderConfig(hc, issuerURL)
+ if err == nil {
+ break
+ }
+
+ sleep = timeutil.ExpBackoff(sleep, time.Minute)
+ fmt.Printf("Failed fetching provider config, trying again in %v: %v\n", sleep, err)
+ time.Sleep(sleep)
+ }
+
+ return
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/transport.go b/vendor/github.com/coreos/go-oidc/oidc/transport.go
new file mode 100644
index 0000000000000000000000000000000000000000..61c926d7fe729daeb223a78559354811cfddb829
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/transport.go
@@ -0,0 +1,88 @@
+package oidc
+
+import (
+ "fmt"
+ "net/http"
+ "sync"
+
+ phttp "github.com/coreos/go-oidc/http"
+ "github.com/coreos/go-oidc/jose"
+)
+
+type TokenRefresher interface {
+ // Verify checks if the provided token is currently valid or not.
+ Verify(jose.JWT) error
+
+ // Refresh attempts to authenticate and retrieve a new token.
+ Refresh() (jose.JWT, error)
+}
+
+type ClientCredsTokenRefresher struct {
+ Issuer string
+ OIDCClient *Client
+}
+
+func (c *ClientCredsTokenRefresher) Verify(jwt jose.JWT) (err error) {
+ _, err = VerifyClientClaims(jwt, c.Issuer)
+ return
+}
+
+func (c *ClientCredsTokenRefresher) Refresh() (jwt jose.JWT, err error) {
+ if err = c.OIDCClient.Healthy(); err != nil {
+ err = fmt.Errorf("unable to authenticate, unhealthy OIDC client: %v", err)
+ return
+ }
+
+ jwt, err = c.OIDCClient.ClientCredsToken([]string{"openid"})
+ if err != nil {
+ err = fmt.Errorf("unable to verify auth code with issuer: %v", err)
+ return
+ }
+
+ return
+}
+
+type AuthenticatedTransport struct {
+ TokenRefresher
+ http.RoundTripper
+
+ mu sync.Mutex
+ jwt jose.JWT
+}
+
+func (t *AuthenticatedTransport) verifiedJWT() (jose.JWT, error) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+
+ if t.TokenRefresher.Verify(t.jwt) == nil {
+ return t.jwt, nil
+ }
+
+ jwt, err := t.TokenRefresher.Refresh()
+ if err != nil {
+ return jose.JWT{}, fmt.Errorf("unable to acquire valid JWT: %v", err)
+ }
+
+ t.jwt = jwt
+ return t.jwt, nil
+}
+
+// SetJWT sets the JWT held by the Transport.
+// This is useful for cases in which you want to set an initial JWT.
+func (t *AuthenticatedTransport) SetJWT(jwt jose.JWT) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+
+ t.jwt = jwt
+}
+
+func (t *AuthenticatedTransport) RoundTrip(r *http.Request) (*http.Response, error) {
+ jwt, err := t.verifiedJWT()
+ if err != nil {
+ return nil, err
+ }
+
+ req := phttp.CopyRequest(r)
+ req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", jwt.Encode()))
+ return t.RoundTripper.RoundTrip(req)
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/util.go b/vendor/github.com/coreos/go-oidc/oidc/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..f2a5a195e4a3a3f4f121014864e82924fd8bd8ba
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/util.go
@@ -0,0 +1,109 @@
+package oidc
+
+import (
+ "crypto/rand"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "net"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/coreos/go-oidc/jose"
+)
+
+// RequestTokenExtractor funcs extract a raw encoded token from a request.
+type RequestTokenExtractor func(r *http.Request) (string, error)
+
+// ExtractBearerToken is a RequestTokenExtractor which extracts a bearer token from a request's
+// Authorization header.
+func ExtractBearerToken(r *http.Request) (string, error) {
+ ah := r.Header.Get("Authorization")
+ if ah == "" {
+ return "", errors.New("missing Authorization header")
+ }
+
+ if len(ah) <= 6 || strings.ToUpper(ah[0:6]) != "BEARER" {
+ return "", errors.New("should be a bearer token")
+ }
+
+ val := ah[7:]
+ if len(val) == 0 {
+ return "", errors.New("bearer token is empty")
+ }
+
+ return val, nil
+}
+
+// CookieTokenExtractor returns a RequestTokenExtractor which extracts a token from the named cookie in a request.
+func CookieTokenExtractor(cookieName string) RequestTokenExtractor {
+ return func(r *http.Request) (string, error) {
+ ck, err := r.Cookie(cookieName)
+ if err != nil {
+ return "", fmt.Errorf("token cookie not found in request: %v", err)
+ }
+
+ if ck.Value == "" {
+ return "", errors.New("token cookie found but is empty")
+ }
+
+ return ck.Value, nil
+ }
+}
+
+func NewClaims(iss, sub string, aud interface{}, iat, exp time.Time) jose.Claims {
+ return jose.Claims{
+ // required
+ "iss": iss,
+ "sub": sub,
+ "aud": aud,
+ "iat": iat.Unix(),
+ "exp": exp.Unix(),
+ }
+}
+
+func GenClientID(hostport string) (string, error) {
+ b, err := randBytes(32)
+ if err != nil {
+ return "", err
+ }
+
+ var host string
+ if strings.Contains(hostport, ":") {
+ host, _, err = net.SplitHostPort(hostport)
+ if err != nil {
+ return "", err
+ }
+ } else {
+ host = hostport
+ }
+
+ return fmt.Sprintf("%s@%s", base64.URLEncoding.EncodeToString(b), host), nil
+}
+
+func randBytes(n int) ([]byte, error) {
+ b := make([]byte, n)
+ got, err := rand.Read(b)
+ if err != nil {
+ return nil, err
+ } else if n != got {
+ return nil, errors.New("unable to generate enough random data")
+ }
+ return b, nil
+}
+
+// urlEqual checks two urls for equality using only the host and path portions.
+func urlEqual(url1, url2 string) bool {
+ u1, err := url.Parse(url1)
+ if err != nil {
+ return false
+ }
+ u2, err := url.Parse(url2)
+ if err != nil {
+ return false
+ }
+
+ return strings.ToLower(u1.Host+u1.Path) == strings.ToLower(u2.Host+u2.Path)
+}
diff --git a/vendor/github.com/coreos/go-oidc/oidc/verification.go b/vendor/github.com/coreos/go-oidc/oidc/verification.go
new file mode 100644
index 0000000000000000000000000000000000000000..002413047949ee685e759a4f4cb5a4d047d49427
--- /dev/null
+++ b/vendor/github.com/coreos/go-oidc/oidc/verification.go
@@ -0,0 +1,188 @@
+package oidc
+
+import (
+ "errors"
+ "fmt"
+ "time"
+
+ "github.com/jonboulle/clockwork"
+
+ "github.com/coreos/go-oidc/jose"
+ "github.com/coreos/go-oidc/key"
+)
+
+func VerifySignature(jwt jose.JWT, keys []key.PublicKey) (bool, error) {
+ jwtBytes := []byte(jwt.Data())
+ for _, k := range keys {
+ v, err := k.Verifier()
+ if err != nil {
+ return false, err
+ }
+ if v.Verify(jwt.Signature, jwtBytes) == nil {
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+// containsString returns true if the given string(needle) is found
+// in the string array(haystack).
+func containsString(needle string, haystack []string) bool {
+ for _, v := range haystack {
+ if v == needle {
+ return true
+ }
+ }
+ return false
+}
+
+// Verify claims in accordance with OIDC spec
+// http://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation
+func VerifyClaims(jwt jose.JWT, issuer, clientID string) error {
+ now := time.Now().UTC()
+
+ claims, err := jwt.Claims()
+ if err != nil {
+ return err
+ }
+
+ ident, err := IdentityFromClaims(claims)
+ if err != nil {
+ return err
+ }
+
+ if ident.ExpiresAt.Before(now) {
+ return errors.New("token is expired")
+ }
+
+ // iss REQUIRED. Issuer Identifier for the Issuer of the response.
+ // The iss value is a case sensitive URL using the https scheme that contains scheme,
+ // host, and optionally, port number and path components and no query or fragment components.
+ if iss, exists := claims["iss"].(string); exists {
+ if !urlEqual(iss, issuer) {
+ return fmt.Errorf("invalid claim value: 'iss'. expected=%s, found=%s.", issuer, iss)
+ }
+ } else {
+ return errors.New("missing claim: 'iss'")
+ }
+
+ // iat REQUIRED. Time at which the JWT was issued.
+ // Its value is a JSON number representing the number of seconds from 1970-01-01T0:0:0Z
+ // as measured in UTC until the date/time.
+ if _, exists := claims["iat"].(float64); !exists {
+ return errors.New("missing claim: 'iat'")
+ }
+
+ // aud REQUIRED. Audience(s) that this ID Token is intended for.
+ // It MUST contain the OAuth 2.0 client_id of the Relying Party as an audience value.
+ // It MAY also contain identifiers for other audiences. In the general case, the aud
+ // value is an array of case sensitive strings. In the common special case when there
+ // is one audience, the aud value MAY be a single case sensitive string.
+ if aud, ok, err := claims.StringClaim("aud"); err == nil && ok {
+ if aud != clientID {
+ return fmt.Errorf("invalid claims, 'aud' claim and 'client_id' do not match, aud=%s, client_id=%s", aud, clientID)
+ }
+ } else if aud, ok, err := claims.StringsClaim("aud"); err == nil && ok {
+ if !containsString(clientID, aud) {
+ return fmt.Errorf("invalid claims, cannot find 'client_id' in 'aud' claim, aud=%v, client_id=%s", aud, clientID)
+ }
+ } else {
+ return errors.New("invalid claim value: 'aud' is required, and should be either string or string array")
+ }
+
+ return nil
+}
+
+// VerifyClientClaims verifies all the required claims are valid for a "client credentials" JWT.
+// Returns the client ID if valid, or an error if invalid.
+func VerifyClientClaims(jwt jose.JWT, issuer string) (string, error) {
+ claims, err := jwt.Claims()
+ if err != nil {
+ return "", fmt.Errorf("failed to parse JWT claims: %v", err)
+ }
+
+ iss, ok, err := claims.StringClaim("iss")
+ if err != nil {
+ return "", fmt.Errorf("failed to parse 'iss' claim: %v", err)
+ } else if !ok {
+ return "", errors.New("missing required 'iss' claim")
+ } else if !urlEqual(iss, issuer) {
+ return "", fmt.Errorf("'iss' claim does not match expected issuer, iss=%s", iss)
+ }
+
+ sub, ok, err := claims.StringClaim("sub")
+ if err != nil {
+ return "", fmt.Errorf("failed to parse 'sub' claim: %v", err)
+ } else if !ok {
+ return "", errors.New("missing required 'sub' claim")
+ }
+
+ if aud, ok, err := claims.StringClaim("aud"); err == nil && ok {
+ if aud != sub {
+ return "", fmt.Errorf("invalid claims, 'aud' claim and 'sub' claim do not match, aud=%s, sub=%s", aud, sub)
+ }
+ } else if aud, ok, err := claims.StringsClaim("aud"); err == nil && ok {
+ if !containsString(sub, aud) {
+ return "", fmt.Errorf("invalid claims, cannot find 'sud' in 'aud' claim, aud=%v, sub=%s", aud, sub)
+ }
+ } else {
+ return "", errors.New("invalid claim value: 'aud' is required, and should be either string or string array")
+ }
+
+ now := time.Now().UTC()
+ exp, ok, err := claims.TimeClaim("exp")
+ if err != nil {
+ return "", fmt.Errorf("failed to parse 'exp' claim: %v", err)
+ } else if !ok {
+ return "", errors.New("missing required 'exp' claim")
+ } else if exp.Before(now) {
+ return "", fmt.Errorf("token already expired at: %v", exp)
+ }
+
+ return sub, nil
+}
+
+type JWTVerifier struct {
+ issuer string
+ clientID string
+ syncFunc func() error
+ keysFunc func() []key.PublicKey
+ clock clockwork.Clock
+}
+
+func NewJWTVerifier(issuer, clientID string, syncFunc func() error, keysFunc func() []key.PublicKey) JWTVerifier {
+ return JWTVerifier{
+ issuer: issuer,
+ clientID: clientID,
+ syncFunc: syncFunc,
+ keysFunc: keysFunc,
+ clock: clockwork.NewRealClock(),
+ }
+}
+
+func (v *JWTVerifier) Verify(jwt jose.JWT) error {
+ ok, err := VerifySignature(jwt, v.keysFunc())
+ if ok {
+ goto SignatureVerified
+ } else if err != nil {
+ return fmt.Errorf("oidc: JWT signature verification failed: %v", err)
+ }
+
+ if err = v.syncFunc(); err != nil {
+ return fmt.Errorf("oidc: failed syncing KeySet: %v", err)
+ }
+
+ ok, err = VerifySignature(jwt, v.keysFunc())
+ if err != nil {
+ return fmt.Errorf("oidc: JWT signature verification failed: %v", err)
+ } else if !ok {
+ return errors.New("oidc: unable to verify JWT signature: no matching keys")
+ }
+
+SignatureVerified:
+ if err := VerifyClaims(jwt, v.issuer, v.clientID); err != nil {
+ return fmt.Errorf("oidc: JWT claims invalid: %v", err)
+ }
+
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/golang/glog/LICENSE b/vendor/github.com/coreos/go-systemd/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/glog/LICENSE
rename to vendor/github.com/coreos/go-systemd/LICENSE
diff --git a/vendor/github.com/coreos/go-systemd/journal/journal.go b/vendor/github.com/coreos/go-systemd/journal/journal.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f434990d25b4f2c656b6d761283d8fb55d7d411
--- /dev/null
+++ b/vendor/github.com/coreos/go-systemd/journal/journal.go
@@ -0,0 +1,179 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 journal provides write bindings to the local systemd journal.
+// It is implemented in pure Go and connects to the journal directly over its
+// unix socket.
+//
+// To read from the journal, see the "sdjournal" package, which wraps the
+// sd-journal a C API.
+//
+// http://www.freedesktop.org/software/systemd/man/systemd-journald.service.html
+package journal
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net"
+ "os"
+ "strconv"
+ "strings"
+ "syscall"
+)
+
+// Priority of a journal message
+type Priority int
+
+const (
+ PriEmerg Priority = iota
+ PriAlert
+ PriCrit
+ PriErr
+ PriWarning
+ PriNotice
+ PriInfo
+ PriDebug
+)
+
+var conn net.Conn
+
+func init() {
+ var err error
+ conn, err = net.Dial("unixgram", "/run/systemd/journal/socket")
+ if err != nil {
+ conn = nil
+ }
+}
+
+// Enabled returns true if the local systemd journal is available for logging
+func Enabled() bool {
+ return conn != nil
+}
+
+// Send a message to the local systemd journal. vars is a map of journald
+// fields to values. Fields must be composed of uppercase letters, numbers,
+// and underscores, but must not start with an underscore. Within these
+// restrictions, any arbitrary field name may be used. Some names have special
+// significance: see the journalctl documentation
+// (http://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
+// for more details. vars may be nil.
+func Send(message string, priority Priority, vars map[string]string) error {
+ if conn == nil {
+ return journalError("could not connect to journald socket")
+ }
+
+ data := new(bytes.Buffer)
+ appendVariable(data, "PRIORITY", strconv.Itoa(int(priority)))
+ appendVariable(data, "MESSAGE", message)
+ for k, v := range vars {
+ appendVariable(data, k, v)
+ }
+
+ _, err := io.Copy(conn, data)
+ if err != nil && isSocketSpaceError(err) {
+ file, err := tempFd()
+ if err != nil {
+ return journalError(err.Error())
+ }
+ defer file.Close()
+ _, err = io.Copy(file, data)
+ if err != nil {
+ return journalError(err.Error())
+ }
+
+ rights := syscall.UnixRights(int(file.Fd()))
+
+ /* this connection should always be a UnixConn, but better safe than sorry */
+ unixConn, ok := conn.(*net.UnixConn)
+ if !ok {
+ return journalError("can't send file through non-Unix connection")
+ }
+ unixConn.WriteMsgUnix([]byte{}, rights, nil)
+ } else if err != nil {
+ return journalError(err.Error())
+ }
+ return nil
+}
+
+// Print prints a message to the local systemd journal using Send().
+func Print(priority Priority, format string, a ...interface{}) error {
+ return Send(fmt.Sprintf(format, a...), priority, nil)
+}
+
+func appendVariable(w io.Writer, name, value string) {
+ if !validVarName(name) {
+ journalError("variable name contains invalid character, ignoring")
+ }
+ if strings.ContainsRune(value, '\n') {
+ /* When the value contains a newline, we write:
+ * - the variable name, followed by a newline
+ * - the size (in 64bit little endian format)
+ * - the data, followed by a newline
+ */
+ fmt.Fprintln(w, name)
+ binary.Write(w, binary.LittleEndian, uint64(len(value)))
+ fmt.Fprintln(w, value)
+ } else {
+ /* just write the variable and value all on one line */
+ fmt.Fprintf(w, "%s=%s\n", name, value)
+ }
+}
+
+func validVarName(name string) bool {
+ /* The variable name must be in uppercase and consist only of characters,
+ * numbers and underscores, and may not begin with an underscore. (from the docs)
+ */
+
+ valid := name[0] != '_'
+ for _, c := range name {
+ valid = valid && ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_'
+ }
+ return valid
+}
+
+func isSocketSpaceError(err error) bool {
+ opErr, ok := err.(*net.OpError)
+ if !ok {
+ return false
+ }
+
+ sysErr, ok := opErr.Err.(syscall.Errno)
+ if !ok {
+ return false
+ }
+
+ return sysErr == syscall.EMSGSIZE || sysErr == syscall.ENOBUFS
+}
+
+func tempFd() (*os.File, error) {
+ file, err := ioutil.TempFile("/dev/shm/", "journal.XXXXX")
+ if err != nil {
+ return nil, err
+ }
+ syscall.Unlink(file.Name())
+ if err != nil {
+ return nil, err
+ }
+ return file, nil
+}
+
+func journalError(s string) error {
+ s = "journal error: " + s
+ fmt.Fprintln(os.Stderr, s)
+ return errors.New(s)
+}
diff --git a/vendor/github.com/coreos/pkg/LICENSE b/vendor/github.com/coreos/pkg/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e06d2081865a766a8668acc12878f98b27fc9ea0
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/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 {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/vendor/github.com/coreos/pkg/NOTICE b/vendor/github.com/coreos/pkg/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..b39ddfa5cbdeaaf7cc8ff22ea50c972575b885c0
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/NOTICE
@@ -0,0 +1,5 @@
+CoreOS Project
+Copyright 2014 CoreOS, Inc
+
+This product includes software developed at CoreOS, Inc.
+(http://www.coreos.com/).
diff --git a/vendor/github.com/coreos/pkg/capnslog/README.md b/vendor/github.com/coreos/pkg/capnslog/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..81efb1fb6a7bd7850b5bb483dd686ce607853ddb
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/README.md
@@ -0,0 +1,39 @@
+# capnslog, the CoreOS logging package
+
+There are far too many logging packages out there, with varying degrees of licenses, far too many features (colorization, all sorts of log frameworks) or are just a pain to use (lack of `Fatalln()`?).
+capnslog provides a simple but consistent logging interface suitable for all kinds of projects.
+
+### Design Principles
+
+##### `package main` is the place where logging gets turned on and routed
+
+A library should not touch log options, only generate log entries. Libraries are silent until main lets them speak.
+
+##### All log options are runtime-configurable.
+
+Still the job of `main` to expose these configurations. `main` may delegate this to, say, a configuration webhook, but does so explicitly.
+
+##### There is one log object per package. It is registered under its repository and package name.
+
+`main` activates logging for its repository and any dependency repositories it would also like to have output in its logstream. `main` also dictates at which level each subpackage logs.
+
+##### There is *one* output stream, and it is an `io.Writer` composed with a formatter.
+
+Splitting streams is probably not the job of your program, but rather, your log aggregation framework. If you must split output streams, again, `main` configures this and you can write a very simple two-output struct that satisfies io.Writer.
+
+Fancy colorful formatting and JSON output are beyond the scope of a basic logging framework -- they're application/log-collector dependant. These are, at best, provided as options, but more likely, provided by your application.
+
+##### Log objects are an interface
+
+An object knows best how to print itself. Log objects can collect more interesting metadata if they wish, however, because text isn't going away anytime soon, they must all be marshalable to text. The simplest log object is a string, which returns itself. If you wish to do more fancy tricks for printing your log objects, see also JSON output -- introspect and write a formatter which can handle your advanced log interface. Making strings is the only thing guaranteed.
+
+##### Log levels have specific meanings:
+
+ * Critical: Unrecoverable. Must fail.
+ * Error: Data has been lost, a request has failed for a bad reason, or a required resource has been lost
+ * Warning: (Hopefully) Temporary conditions that may cause errors, but may work fine. A replica disappearing (that may reconnect) is a warning.
+ * Notice: Normal, but important (uncommon) log information.
+ * Info: Normal, working log information, everything is fine, but helpful notices for auditing or common operations.
+ * Debug: Everything is still fine, but even common operations may be logged, and less helpful but more quantity of notices.
+ * Trace: Anything goes, from logging every function call as part of a common operation, to tracing execution of a query.
+
diff --git a/vendor/github.com/coreos/pkg/capnslog/formatters.go b/vendor/github.com/coreos/pkg/capnslog/formatters.go
new file mode 100644
index 0000000000000000000000000000000000000000..b305a845fb2bf185eaadb101c0d443e1b49313ef
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/formatters.go
@@ -0,0 +1,157 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import (
+ "bufio"
+ "fmt"
+ "io"
+ "log"
+ "runtime"
+ "strings"
+ "time"
+)
+
+type Formatter interface {
+ Format(pkg string, level LogLevel, depth int, entries ...interface{})
+ Flush()
+}
+
+func NewStringFormatter(w io.Writer) Formatter {
+ return &StringFormatter{
+ w: bufio.NewWriter(w),
+ }
+}
+
+type StringFormatter struct {
+ w *bufio.Writer
+}
+
+func (s *StringFormatter) Format(pkg string, l LogLevel, i int, entries ...interface{}) {
+ now := time.Now().UTC()
+ s.w.WriteString(now.Format(time.RFC3339))
+ s.w.WriteByte(' ')
+ writeEntries(s.w, pkg, l, i, entries...)
+ s.Flush()
+}
+
+func writeEntries(w *bufio.Writer, pkg string, _ LogLevel, _ int, entries ...interface{}) {
+ if pkg != "" {
+ w.WriteString(pkg + ": ")
+ }
+ str := fmt.Sprint(entries...)
+ endsInNL := strings.HasSuffix(str, "\n")
+ w.WriteString(str)
+ if !endsInNL {
+ w.WriteString("\n")
+ }
+}
+
+func (s *StringFormatter) Flush() {
+ s.w.Flush()
+}
+
+func NewPrettyFormatter(w io.Writer, debug bool) Formatter {
+ return &PrettyFormatter{
+ w: bufio.NewWriter(w),
+ debug: debug,
+ }
+}
+
+type PrettyFormatter struct {
+ w *bufio.Writer
+ debug bool
+}
+
+func (c *PrettyFormatter) Format(pkg string, l LogLevel, depth int, entries ...interface{}) {
+ now := time.Now()
+ ts := now.Format("2006-01-02 15:04:05")
+ c.w.WriteString(ts)
+ ms := now.Nanosecond() / 1000
+ c.w.WriteString(fmt.Sprintf(".%06d", ms))
+ if c.debug {
+ _, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
+ if !ok {
+ file = "???"
+ line = 1
+ } else {
+ slash := strings.LastIndex(file, "/")
+ if slash >= 0 {
+ file = file[slash+1:]
+ }
+ }
+ if line < 0 {
+ line = 0 // not a real line number
+ }
+ c.w.WriteString(fmt.Sprintf(" [%s:%d]", file, line))
+ }
+ c.w.WriteString(fmt.Sprint(" ", l.Char(), " | "))
+ writeEntries(c.w, pkg, l, depth, entries...)
+ c.Flush()
+}
+
+func (c *PrettyFormatter) Flush() {
+ c.w.Flush()
+}
+
+// LogFormatter emulates the form of the traditional built-in logger.
+type LogFormatter struct {
+ logger *log.Logger
+ prefix string
+}
+
+// NewLogFormatter is a helper to produce a new LogFormatter struct. It uses the
+// golang log package to actually do the logging work so that logs look similar.
+func NewLogFormatter(w io.Writer, prefix string, flag int) Formatter {
+ return &LogFormatter{
+ logger: log.New(w, "", flag), // don't use prefix here
+ prefix: prefix, // save it instead
+ }
+}
+
+// Format builds a log message for the LogFormatter. The LogLevel is ignored.
+func (lf *LogFormatter) Format(pkg string, _ LogLevel, _ int, entries ...interface{}) {
+ str := fmt.Sprint(entries...)
+ prefix := lf.prefix
+ if pkg != "" {
+ prefix = fmt.Sprintf("%s%s: ", prefix, pkg)
+ }
+ lf.logger.Output(5, fmt.Sprintf("%s%v", prefix, str)) // call depth is 5
+}
+
+// Flush is included so that the interface is complete, but is a no-op.
+func (lf *LogFormatter) Flush() {
+ // noop
+}
+
+// NilFormatter is a no-op log formatter that does nothing.
+type NilFormatter struct {
+}
+
+// NewNilFormatter is a helper to produce a new LogFormatter struct. It logs no
+// messages so that you can cause part of your logging to be silent.
+func NewNilFormatter() Formatter {
+ return &NilFormatter{}
+}
+
+// Format does nothing.
+func (_ *NilFormatter) Format(_ string, _ LogLevel, _ int, _ ...interface{}) {
+ // noop
+}
+
+// Flush is included so that the interface is complete, but is a no-op.
+func (_ *NilFormatter) Flush() {
+ // noop
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go
new file mode 100644
index 0000000000000000000000000000000000000000..426603ef305c73d54d5d5077184ff2ba89d83fb8
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go
@@ -0,0 +1,96 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import (
+ "bufio"
+ "bytes"
+ "io"
+ "os"
+ "runtime"
+ "strconv"
+ "strings"
+ "time"
+)
+
+var pid = os.Getpid()
+
+type GlogFormatter struct {
+ StringFormatter
+}
+
+func NewGlogFormatter(w io.Writer) *GlogFormatter {
+ g := &GlogFormatter{}
+ g.w = bufio.NewWriter(w)
+ return g
+}
+
+func (g GlogFormatter) Format(pkg string, level LogLevel, depth int, entries ...interface{}) {
+ g.w.Write(GlogHeader(level, depth+1))
+ g.StringFormatter.Format(pkg, level, depth+1, entries...)
+}
+
+func GlogHeader(level LogLevel, depth int) []byte {
+ // Lmmdd hh:mm:ss.uuuuuu threadid file:line]
+ now := time.Now().UTC()
+ _, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
+ if !ok {
+ file = "???"
+ line = 1
+ } else {
+ slash := strings.LastIndex(file, "/")
+ if slash >= 0 {
+ file = file[slash+1:]
+ }
+ }
+ if line < 0 {
+ line = 0 // not a real line number
+ }
+ buf := &bytes.Buffer{}
+ buf.Grow(30)
+ _, month, day := now.Date()
+ hour, minute, second := now.Clock()
+ buf.WriteString(level.Char())
+ twoDigits(buf, int(month))
+ twoDigits(buf, day)
+ buf.WriteByte(' ')
+ twoDigits(buf, hour)
+ buf.WriteByte(':')
+ twoDigits(buf, minute)
+ buf.WriteByte(':')
+ twoDigits(buf, second)
+ buf.WriteByte('.')
+ buf.WriteString(strconv.Itoa(now.Nanosecond() / 1000))
+ buf.WriteByte('Z')
+ buf.WriteByte(' ')
+ buf.WriteString(strconv.Itoa(pid))
+ buf.WriteByte(' ')
+ buf.WriteString(file)
+ buf.WriteByte(':')
+ buf.WriteString(strconv.Itoa(line))
+ buf.WriteByte(']')
+ buf.WriteByte(' ')
+ return buf.Bytes()
+}
+
+const digits = "0123456789"
+
+func twoDigits(b *bytes.Buffer, d int) {
+ c2 := digits[d%10]
+ d /= 10
+ c1 := digits[d%10]
+ b.WriteByte(c1)
+ b.WriteByte(c2)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/init.go b/vendor/github.com/coreos/pkg/capnslog/init.go
new file mode 100644
index 0000000000000000000000000000000000000000..44b8cd361b0f70007618f4fb37a1bb4e4acc057f
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/init.go
@@ -0,0 +1,49 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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.
+//
+// +build !windows
+
+package capnslog
+
+import (
+ "io"
+ "os"
+ "syscall"
+)
+
+// Here's where the opinionation comes in. We need some sensible defaults,
+// especially after taking over the log package. Your project (whatever it may
+// be) may see things differently. That's okay; there should be no defaults in
+// the main package that cannot be controlled or overridden programatically,
+// otherwise it's a bug. Doing so is creating your own init_log.go file much
+// like this one.
+
+func init() {
+ initHijack()
+
+ // Go `log` pacakge uses os.Stderr.
+ SetFormatter(NewDefaultFormatter(os.Stderr))
+ SetGlobalLogLevel(INFO)
+}
+
+func NewDefaultFormatter(out io.Writer) Formatter {
+ if syscall.Getppid() == 1 {
+ // We're running under init, which may be systemd.
+ f, err := NewJournaldFormatter()
+ if err == nil {
+ return f
+ }
+ }
+ return NewPrettyFormatter(out, false)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/init_windows.go b/vendor/github.com/coreos/pkg/capnslog/init_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..45530506537fff0eaafb35e3bad411dc4e5a9c6a
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/init_windows.go
@@ -0,0 +1,25 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import "os"
+
+func init() {
+ initHijack()
+
+ // Go `log` package uses os.Stderr.
+ SetFormatter(NewPrettyFormatter(os.Stderr, false))
+ SetGlobalLogLevel(INFO)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go
new file mode 100644
index 0000000000000000000000000000000000000000..72e05207c52ce0d6055442004274565cc91b1a91
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go
@@ -0,0 +1,68 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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.
+//
+// +build !windows
+
+package capnslog
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ "path/filepath"
+
+ "github.com/coreos/go-systemd/journal"
+)
+
+func NewJournaldFormatter() (Formatter, error) {
+ if !journal.Enabled() {
+ return nil, errors.New("No systemd detected")
+ }
+ return &journaldFormatter{}, nil
+}
+
+type journaldFormatter struct{}
+
+func (j *journaldFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
+ var pri journal.Priority
+ switch l {
+ case CRITICAL:
+ pri = journal.PriCrit
+ case ERROR:
+ pri = journal.PriErr
+ case WARNING:
+ pri = journal.PriWarning
+ case NOTICE:
+ pri = journal.PriNotice
+ case INFO:
+ pri = journal.PriInfo
+ case DEBUG:
+ pri = journal.PriDebug
+ case TRACE:
+ pri = journal.PriDebug
+ default:
+ panic("Unhandled loglevel")
+ }
+ msg := fmt.Sprint(entries...)
+ tags := map[string]string{
+ "PACKAGE": pkg,
+ "SYSLOG_IDENTIFIER": filepath.Base(os.Args[0]),
+ }
+ err := journal.Send(msg, pri, tags)
+ if err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ }
+}
+
+func (j *journaldFormatter) Flush() {}
diff --git a/vendor/github.com/coreos/pkg/capnslog/log_hijack.go b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go
new file mode 100644
index 0000000000000000000000000000000000000000..970086b9f97304b995864bc4d6d29bc11a4959bb
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go
@@ -0,0 +1,39 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import (
+ "log"
+)
+
+func initHijack() {
+ pkg := NewPackageLogger("log", "")
+ w := packageWriter{pkg}
+ log.SetFlags(0)
+ log.SetPrefix("")
+ log.SetOutput(w)
+}
+
+type packageWriter struct {
+ pl *PackageLogger
+}
+
+func (p packageWriter) Write(b []byte) (int, error) {
+ if p.pl.level < INFO {
+ return 0, nil
+ }
+ p.pl.internalLog(calldepth+2, INFO, string(b))
+ return len(b), nil
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/logmap.go b/vendor/github.com/coreos/pkg/capnslog/logmap.go
new file mode 100644
index 0000000000000000000000000000000000000000..84954488308db61ce869c4b27ee929f3b6f435ef
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/logmap.go
@@ -0,0 +1,240 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import (
+ "errors"
+ "strings"
+ "sync"
+)
+
+// LogLevel is the set of all log levels.
+type LogLevel int8
+
+const (
+ // CRITICAL is the lowest log level; only errors which will end the program will be propagated.
+ CRITICAL LogLevel = iota - 1
+ // ERROR is for errors that are not fatal but lead to troubling behavior.
+ ERROR
+ // WARNING is for errors which are not fatal and not errors, but are unusual. Often sourced from misconfigurations.
+ WARNING
+ // NOTICE is for normal but significant conditions.
+ NOTICE
+ // INFO is a log level for common, everyday log updates.
+ INFO
+ // DEBUG is the default hidden level for more verbose updates about internal processes.
+ DEBUG
+ // TRACE is for (potentially) call by call tracing of programs.
+ TRACE
+)
+
+// Char returns a single-character representation of the log level.
+func (l LogLevel) Char() string {
+ switch l {
+ case CRITICAL:
+ return "C"
+ case ERROR:
+ return "E"
+ case WARNING:
+ return "W"
+ case NOTICE:
+ return "N"
+ case INFO:
+ return "I"
+ case DEBUG:
+ return "D"
+ case TRACE:
+ return "T"
+ default:
+ panic("Unhandled loglevel")
+ }
+}
+
+// String returns a multi-character representation of the log level.
+func (l LogLevel) String() string {
+ switch l {
+ case CRITICAL:
+ return "CRITICAL"
+ case ERROR:
+ return "ERROR"
+ case WARNING:
+ return "WARNING"
+ case NOTICE:
+ return "NOTICE"
+ case INFO:
+ return "INFO"
+ case DEBUG:
+ return "DEBUG"
+ case TRACE:
+ return "TRACE"
+ default:
+ panic("Unhandled loglevel")
+ }
+}
+
+// Update using the given string value. Fulfills the flag.Value interface.
+func (l *LogLevel) Set(s string) error {
+ value, err := ParseLevel(s)
+ if err != nil {
+ return err
+ }
+
+ *l = value
+ return nil
+}
+
+// ParseLevel translates some potential loglevel strings into their corresponding levels.
+func ParseLevel(s string) (LogLevel, error) {
+ switch s {
+ case "CRITICAL", "C":
+ return CRITICAL, nil
+ case "ERROR", "0", "E":
+ return ERROR, nil
+ case "WARNING", "1", "W":
+ return WARNING, nil
+ case "NOTICE", "2", "N":
+ return NOTICE, nil
+ case "INFO", "3", "I":
+ return INFO, nil
+ case "DEBUG", "4", "D":
+ return DEBUG, nil
+ case "TRACE", "5", "T":
+ return TRACE, nil
+ }
+ return CRITICAL, errors.New("couldn't parse log level " + s)
+}
+
+type RepoLogger map[string]*PackageLogger
+
+type loggerStruct struct {
+ sync.Mutex
+ repoMap map[string]RepoLogger
+ formatter Formatter
+}
+
+// logger is the global logger
+var logger = new(loggerStruct)
+
+// SetGlobalLogLevel sets the log level for all packages in all repositories
+// registered with capnslog.
+func SetGlobalLogLevel(l LogLevel) {
+ logger.Lock()
+ defer logger.Unlock()
+ for _, r := range logger.repoMap {
+ r.setRepoLogLevelInternal(l)
+ }
+}
+
+// GetRepoLogger may return the handle to the repository's set of packages' loggers.
+func GetRepoLogger(repo string) (RepoLogger, error) {
+ logger.Lock()
+ defer logger.Unlock()
+ r, ok := logger.repoMap[repo]
+ if !ok {
+ return nil, errors.New("no packages registered for repo " + repo)
+ }
+ return r, nil
+}
+
+// MustRepoLogger returns the handle to the repository's packages' loggers.
+func MustRepoLogger(repo string) RepoLogger {
+ r, err := GetRepoLogger(repo)
+ if err != nil {
+ panic(err)
+ }
+ return r
+}
+
+// SetRepoLogLevel sets the log level for all packages in the repository.
+func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
+ logger.Lock()
+ defer logger.Unlock()
+ r.setRepoLogLevelInternal(l)
+}
+
+func (r RepoLogger) setRepoLogLevelInternal(l LogLevel) {
+ for _, v := range r {
+ v.level = l
+ }
+}
+
+// ParseLogLevelConfig parses a comma-separated string of "package=loglevel", in
+// order, and returns a map of the results, for use in SetLogLevel.
+func (r RepoLogger) ParseLogLevelConfig(conf string) (map[string]LogLevel, error) {
+ setlist := strings.Split(conf, ",")
+ out := make(map[string]LogLevel)
+ for _, setstring := range setlist {
+ setting := strings.Split(setstring, "=")
+ if len(setting) != 2 {
+ return nil, errors.New("oddly structured `pkg=level` option: " + setstring)
+ }
+ l, err := ParseLevel(setting[1])
+ if err != nil {
+ return nil, err
+ }
+ out[setting[0]] = l
+ }
+ return out, nil
+}
+
+// SetLogLevel takes a map of package names within a repository to their desired
+// loglevel, and sets the levels appropriately. Unknown packages are ignored.
+// "*" is a special package name that corresponds to all packages, and will be
+// processed first.
+func (r RepoLogger) SetLogLevel(m map[string]LogLevel) {
+ logger.Lock()
+ defer logger.Unlock()
+ if l, ok := m["*"]; ok {
+ r.setRepoLogLevelInternal(l)
+ }
+ for k, v := range m {
+ l, ok := r[k]
+ if !ok {
+ continue
+ }
+ l.level = v
+ }
+}
+
+// SetFormatter sets the formatting function for all logs.
+func SetFormatter(f Formatter) {
+ logger.Lock()
+ defer logger.Unlock()
+ logger.formatter = f
+}
+
+// NewPackageLogger creates a package logger object.
+// This should be defined as a global var in your package, referencing your repo.
+func NewPackageLogger(repo string, pkg string) (p *PackageLogger) {
+ logger.Lock()
+ defer logger.Unlock()
+ if logger.repoMap == nil {
+ logger.repoMap = make(map[string]RepoLogger)
+ }
+ r, rok := logger.repoMap[repo]
+ if !rok {
+ logger.repoMap[repo] = make(RepoLogger)
+ r = logger.repoMap[repo]
+ }
+ p, pok := r[pkg]
+ if !pok {
+ r[pkg] = &PackageLogger{
+ pkg: pkg,
+ level: INFO,
+ }
+ p = r[pkg]
+ }
+ return
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go
new file mode 100644
index 0000000000000000000000000000000000000000..612d55c66c8022c2430a847599e74b8c3afeb736
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go
@@ -0,0 +1,177 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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 capnslog
+
+import (
+ "fmt"
+ "os"
+)
+
+type PackageLogger struct {
+ pkg string
+ level LogLevel
+}
+
+const calldepth = 2
+
+func (p *PackageLogger) internalLog(depth int, inLevel LogLevel, entries ...interface{}) {
+ logger.Lock()
+ defer logger.Unlock()
+ if inLevel != CRITICAL && p.level < inLevel {
+ return
+ }
+ if logger.formatter != nil {
+ logger.formatter.Format(p.pkg, inLevel, depth+1, entries...)
+ }
+}
+
+func (p *PackageLogger) LevelAt(l LogLevel) bool {
+ logger.Lock()
+ defer logger.Unlock()
+ return p.level >= l
+}
+
+// Log a formatted string at any level between ERROR and TRACE
+func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
+ p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
+}
+
+// Log a message at any level between ERROR and TRACE
+func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
+ p.internalLog(calldepth, l, fmt.Sprint(args...))
+}
+
+// log stdlib compatibility
+
+func (p *PackageLogger) Println(args ...interface{}) {
+ p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
+}
+
+func (p *PackageLogger) Printf(format string, args ...interface{}) {
+ p.Logf(INFO, format, args...)
+}
+
+func (p *PackageLogger) Print(args ...interface{}) {
+ p.internalLog(calldepth, INFO, fmt.Sprint(args...))
+}
+
+// Panic and fatal
+
+func (p *PackageLogger) Panicf(format string, args ...interface{}) {
+ s := fmt.Sprintf(format, args...)
+ p.internalLog(calldepth, CRITICAL, s)
+ panic(s)
+}
+
+func (p *PackageLogger) Panic(args ...interface{}) {
+ s := fmt.Sprint(args...)
+ p.internalLog(calldepth, CRITICAL, s)
+ panic(s)
+}
+
+func (p *PackageLogger) Fatalf(format string, args ...interface{}) {
+ p.Logf(CRITICAL, format, args...)
+ os.Exit(1)
+}
+
+func (p *PackageLogger) Fatal(args ...interface{}) {
+ s := fmt.Sprint(args...)
+ p.internalLog(calldepth, CRITICAL, s)
+ os.Exit(1)
+}
+
+func (p *PackageLogger) Fatalln(args ...interface{}) {
+ s := fmt.Sprintln(args...)
+ p.internalLog(calldepth, CRITICAL, s)
+ os.Exit(1)
+}
+
+// Error Functions
+
+func (p *PackageLogger) Errorf(format string, args ...interface{}) {
+ p.Logf(ERROR, format, args...)
+}
+
+func (p *PackageLogger) Error(entries ...interface{}) {
+ p.internalLog(calldepth, ERROR, entries...)
+}
+
+// Warning Functions
+
+func (p *PackageLogger) Warningf(format string, args ...interface{}) {
+ p.Logf(WARNING, format, args...)
+}
+
+func (p *PackageLogger) Warning(entries ...interface{}) {
+ p.internalLog(calldepth, WARNING, entries...)
+}
+
+// Notice Functions
+
+func (p *PackageLogger) Noticef(format string, args ...interface{}) {
+ p.Logf(NOTICE, format, args...)
+}
+
+func (p *PackageLogger) Notice(entries ...interface{}) {
+ p.internalLog(calldepth, NOTICE, entries...)
+}
+
+// Info Functions
+
+func (p *PackageLogger) Infof(format string, args ...interface{}) {
+ p.Logf(INFO, format, args...)
+}
+
+func (p *PackageLogger) Info(entries ...interface{}) {
+ p.internalLog(calldepth, INFO, entries...)
+}
+
+// Debug Functions
+
+func (p *PackageLogger) Debugf(format string, args ...interface{}) {
+ if p.level < DEBUG {
+ return
+ }
+ p.Logf(DEBUG, format, args...)
+}
+
+func (p *PackageLogger) Debug(entries ...interface{}) {
+ if p.level < DEBUG {
+ return
+ }
+ p.internalLog(calldepth, DEBUG, entries...)
+}
+
+// Trace Functions
+
+func (p *PackageLogger) Tracef(format string, args ...interface{}) {
+ if p.level < TRACE {
+ return
+ }
+ p.Logf(TRACE, format, args...)
+}
+
+func (p *PackageLogger) Trace(entries ...interface{}) {
+ if p.level < TRACE {
+ return
+ }
+ p.internalLog(calldepth, TRACE, entries...)
+}
+
+func (p *PackageLogger) Flush() {
+ logger.Lock()
+ defer logger.Unlock()
+ logger.formatter.Flush()
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go
new file mode 100644
index 0000000000000000000000000000000000000000..4be5a1f2de395648067d34283263b483f6ca1a59
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go
@@ -0,0 +1,65 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// 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.
+//
+// +build !windows
+
+package capnslog
+
+import (
+ "fmt"
+ "log/syslog"
+)
+
+func NewSyslogFormatter(w *syslog.Writer) Formatter {
+ return &syslogFormatter{w}
+}
+
+func NewDefaultSyslogFormatter(tag string) (Formatter, error) {
+ w, err := syslog.New(syslog.LOG_DEBUG, tag)
+ if err != nil {
+ return nil, err
+ }
+ return NewSyslogFormatter(w), nil
+}
+
+type syslogFormatter struct {
+ w *syslog.Writer
+}
+
+func (s *syslogFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
+ for _, entry := range entries {
+ str := fmt.Sprint(entry)
+ switch l {
+ case CRITICAL:
+ s.w.Crit(str)
+ case ERROR:
+ s.w.Err(str)
+ case WARNING:
+ s.w.Warning(str)
+ case NOTICE:
+ s.w.Notice(str)
+ case INFO:
+ s.w.Info(str)
+ case DEBUG:
+ s.w.Debug(str)
+ case TRACE:
+ s.w.Debug(str)
+ default:
+ panic("Unhandled loglevel")
+ }
+ }
+}
+
+func (s *syslogFormatter) Flush() {
+}
diff --git a/vendor/github.com/coreos/pkg/health/README.md b/vendor/github.com/coreos/pkg/health/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ec34c21e0fd80162c3dd5c557b69d5bd3cfc8d9
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/health/README.md
@@ -0,0 +1,11 @@
+health
+====
+
+A simple framework for implementing an HTTP health check endpoint on servers.
+
+Users implement their `health.Checkable` types, and create a `health.Checker`, from which they can get an `http.HandlerFunc` using `health.Checker.MakeHealthHandlerFunc`.
+
+### Documentation
+
+For more details, visit the docs on [gopkgdoc](http://godoc.org/github.com/coreos/pkg/health)
+
diff --git a/vendor/github.com/coreos/pkg/health/health.go b/vendor/github.com/coreos/pkg/health/health.go
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3610fa5c5c0071bd406c14ef83d81fa6ad577
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/health/health.go
@@ -0,0 +1,127 @@
+package health
+
+import (
+ "expvar"
+ "fmt"
+ "log"
+ "net/http"
+
+ "github.com/coreos/pkg/httputil"
+)
+
+// Checkables should return nil when the thing they are checking is healthy, and an error otherwise.
+type Checkable interface {
+ Healthy() error
+}
+
+// Checker provides a way to make an endpoint which can be probed for system health.
+type Checker struct {
+ // Checks are the Checkables to be checked when probing.
+ Checks []Checkable
+
+ // Unhealthyhandler is called when one or more of the checks are unhealthy.
+ // If not provided DefaultUnhealthyHandler is called.
+ UnhealthyHandler UnhealthyHandler
+
+ // HealthyHandler is called when all checks are healthy.
+ // If not provided, DefaultHealthyHandler is called.
+ HealthyHandler http.HandlerFunc
+}
+
+func (c Checker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ unhealthyHandler := c.UnhealthyHandler
+ if unhealthyHandler == nil {
+ unhealthyHandler = DefaultUnhealthyHandler
+ }
+
+ successHandler := c.HealthyHandler
+ if successHandler == nil {
+ successHandler = DefaultHealthyHandler
+ }
+
+ if r.Method != "GET" {
+ w.Header().Set("Allow", "GET")
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ return
+ }
+
+ if err := Check(c.Checks); err != nil {
+ unhealthyHandler(w, r, err)
+ return
+ }
+
+ successHandler(w, r)
+}
+
+type UnhealthyHandler func(w http.ResponseWriter, r *http.Request, err error)
+
+type StatusResponse struct {
+ Status string `json:"status"`
+ Details *StatusResponseDetails `json:"details,omitempty"`
+}
+
+type StatusResponseDetails struct {
+ Code int `json:"code,omitempty"`
+ Message string `json:"message,omitempty"`
+}
+
+func Check(checks []Checkable) (err error) {
+ errs := []error{}
+ for _, c := range checks {
+ if e := c.Healthy(); e != nil {
+ errs = append(errs, e)
+ }
+ }
+
+ switch len(errs) {
+ case 0:
+ err = nil
+ case 1:
+ err = errs[0]
+ default:
+ err = fmt.Errorf("multiple health check failure: %v", errs)
+ }
+
+ return
+}
+
+func DefaultHealthyHandler(w http.ResponseWriter, r *http.Request) {
+ err := httputil.WriteJSONResponse(w, http.StatusOK, StatusResponse{
+ Status: "ok",
+ })
+ if err != nil {
+ // TODO(bobbyrullo): replace with logging from new logging pkg,
+ // once it lands.
+ log.Printf("Failed to write JSON response: %v", err)
+ }
+}
+
+func DefaultUnhealthyHandler(w http.ResponseWriter, r *http.Request, err error) {
+ writeErr := httputil.WriteJSONResponse(w, http.StatusInternalServerError, StatusResponse{
+ Status: "error",
+ Details: &StatusResponseDetails{
+ Code: http.StatusInternalServerError,
+ Message: err.Error(),
+ },
+ })
+ if writeErr != nil {
+ // TODO(bobbyrullo): replace with logging from new logging pkg,
+ // once it lands.
+ log.Printf("Failed to write JSON response: %v", err)
+ }
+}
+
+// ExpvarHandler is copied from https://golang.org/src/expvar/expvar.go, where it's sadly unexported.
+func ExpvarHandler(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json; charset=utf-8")
+ fmt.Fprintf(w, "{\n")
+ first := true
+ expvar.Do(func(kv expvar.KeyValue) {
+ if !first {
+ fmt.Fprintf(w, ",\n")
+ }
+ first = false
+ fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
+ })
+ fmt.Fprintf(w, "\n}\n")
+}
diff --git a/vendor/github.com/coreos/pkg/httputil/README.md b/vendor/github.com/coreos/pkg/httputil/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..44fa751c4a0a84990c36929ce6916ab2a7fd0d5c
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/httputil/README.md
@@ -0,0 +1,13 @@
+httputil
+====
+
+Common code for dealing with HTTP.
+
+Includes:
+
+* Code for returning JSON responses.
+
+### Documentation
+
+Visit the docs on [gopkgdoc](http://godoc.org/github.com/coreos/pkg/httputil)
+
diff --git a/vendor/github.com/coreos/pkg/httputil/cookie.go b/vendor/github.com/coreos/pkg/httputil/cookie.go
new file mode 100644
index 0000000000000000000000000000000000000000..c37a37bb27c750c3d1b61305a127c3b5d853e856
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/httputil/cookie.go
@@ -0,0 +1,21 @@
+package httputil
+
+import (
+ "net/http"
+ "time"
+)
+
+// DeleteCookies effectively deletes all named cookies
+// by wiping all data and setting to expire immediately.
+func DeleteCookies(w http.ResponseWriter, cookieNames ...string) {
+ for _, n := range cookieNames {
+ c := &http.Cookie{
+ Name: n,
+ Value: "",
+ Path: "/",
+ MaxAge: -1,
+ Expires: time.Time{},
+ }
+ http.SetCookie(w, c)
+ }
+}
diff --git a/vendor/github.com/coreos/pkg/httputil/json.go b/vendor/github.com/coreos/pkg/httputil/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..0b09235033ff8cc87eca22f40e8c29fb3adbf8f6
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/httputil/json.go
@@ -0,0 +1,27 @@
+package httputil
+
+import (
+ "encoding/json"
+ "net/http"
+)
+
+const (
+ JSONContentType = "application/json"
+)
+
+func WriteJSONResponse(w http.ResponseWriter, code int, resp interface{}) error {
+ enc, err := json.Marshal(resp)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ return err
+ }
+
+ w.Header().Set("Content-Type", JSONContentType)
+ w.WriteHeader(code)
+
+ _, err = w.Write(enc)
+ if err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/github.com/coreos/pkg/timeutil/backoff.go b/vendor/github.com/coreos/pkg/timeutil/backoff.go
new file mode 100644
index 0000000000000000000000000000000000000000..b34fb49661b65c972969e81ff87f498b92571075
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/timeutil/backoff.go
@@ -0,0 +1,15 @@
+package timeutil
+
+import (
+ "time"
+)
+
+func ExpBackoff(prev, max time.Duration) time.Duration {
+ if prev == 0 {
+ return time.Second
+ }
+ if prev > max/2 {
+ return max
+ }
+ return 2 * prev
+}
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE
similarity index 98%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/LICENSE
rename to vendor/github.com/davecgh/go-spew/LICENSE
index 2a7cfd2bf6a7e8dabd7353e283362de042831eed..bb67332310b9709d35e92ebcd75f36d7e9c45684 100644
--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/LICENSE
+++ b/vendor/github.com/davecgh/go-spew/LICENSE
@@ -1,3 +1,5 @@
+ISC License
+
Copyright (c) 2012-2013 Dave Collins <dave@davec.name>
Permission to use, copy, modify, and distribute this software for any
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go
new file mode 100644
index 0000000000000000000000000000000000000000..565bf5899f27d89931b293b695fe9468f6209950
--- /dev/null
+++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go
@@ -0,0 +1,151 @@
+// Copyright (c) 2015 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine and "-tags disableunsafe"
+// is not added to the go build command line.
+// +build !appengine,!disableunsafe
+
+package spew
+
+import (
+ "reflect"
+ "unsafe"
+)
+
+const (
+ // UnsafeDisabled is a build-time constant which specifies whether or
+ // not access to the unsafe package is available.
+ UnsafeDisabled = false
+
+ // ptrSize is the size of a pointer on the current arch.
+ ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+var (
+ // offsetPtr, offsetScalar, and offsetFlag are the offsets for the
+ // internal reflect.Value fields. These values are valid before golang
+ // commit ecccf07e7f9d which changed the format. The are also valid
+ // after commit 82f48826c6c7 which changed the format again to mirror
+ // the original format. Code in the init function updates these offsets
+ // as necessary.
+ offsetPtr = uintptr(ptrSize)
+ offsetScalar = uintptr(0)
+ offsetFlag = uintptr(ptrSize * 2)
+
+ // flagKindWidth and flagKindShift indicate various bits that the
+ // reflect package uses internally to track kind information.
+ //
+ // flagRO indicates whether or not the value field of a reflect.Value is
+ // read-only.
+ //
+ // flagIndir indicates whether the value field of a reflect.Value is
+ // the actual data or a pointer to the data.
+ //
+ // These values are valid before golang commit 90a7c3c86944 which
+ // changed their positions. Code in the init function updates these
+ // flags as necessary.
+ flagKindWidth = uintptr(5)
+ flagKindShift = uintptr(flagKindWidth - 1)
+ flagRO = uintptr(1 << 0)
+ flagIndir = uintptr(1 << 1)
+)
+
+func init() {
+ // Older versions of reflect.Value stored small integers directly in the
+ // ptr field (which is named val in the older versions). Versions
+ // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
+ // scalar for this purpose which unfortunately came before the flag
+ // field, so the offset of the flag field is different for those
+ // versions.
+ //
+ // This code constructs a new reflect.Value from a known small integer
+ // and checks if the size of the reflect.Value struct indicates it has
+ // the scalar field. When it does, the offsets are updated accordingly.
+ vv := reflect.ValueOf(0xf00)
+ if unsafe.Sizeof(vv) == (ptrSize * 4) {
+ offsetScalar = ptrSize * 2
+ offsetFlag = ptrSize * 3
+ }
+
+ // Commit 90a7c3c86944 changed the flag positions such that the low
+ // order bits are the kind. This code extracts the kind from the flags
+ // field and ensures it's the correct type. When it's not, the flag
+ // order has been changed to the newer format, so the flags are updated
+ // accordingly.
+ upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
+ upfv := *(*uintptr)(upf)
+ flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
+ if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
+ flagKindShift = 0
+ flagRO = 1 << 5
+ flagIndir = 1 << 6
+
+ // Commit adf9b30e5594 modified the flags to separate the
+ // flagRO flag into two bits which specifies whether or not the
+ // field is embedded. This causes flagIndir to move over a bit
+ // and means that flagRO is the combination of either of the
+ // original flagRO bit and the new bit.
+ //
+ // This code detects the change by extracting what used to be
+ // the indirect bit to ensure it's set. When it's not, the flag
+ // order has been changed to the newer format, so the flags are
+ // updated accordingly.
+ if upfv&flagIndir == 0 {
+ flagRO = 3 << 5
+ flagIndir = 1 << 7
+ }
+ }
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data. It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
+ indirects := 1
+ vt := v.Type()
+ upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
+ rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
+ if rvf&flagIndir != 0 {
+ vt = reflect.PtrTo(v.Type())
+ indirects++
+ } else if offsetScalar != 0 {
+ // The value is in the scalar field when it's not one of the
+ // reference types.
+ switch vt.Kind() {
+ case reflect.Uintptr:
+ case reflect.Chan:
+ case reflect.Func:
+ case reflect.Map:
+ case reflect.Ptr:
+ case reflect.UnsafePointer:
+ default:
+ upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
+ offsetScalar)
+ }
+ }
+
+ pv := reflect.NewAt(vt, upv)
+ rv = pv
+ for i := 0; i < indirects; i++ {
+ rv = rv.Elem()
+ }
+ return rv
+}
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
new file mode 100644
index 0000000000000000000000000000000000000000..457e41235ed73a675b70d4c5ade6eadad1710e2b
--- /dev/null
+++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2015 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when either the code is running on Google App Engine or "-tags disableunsafe"
+// is added to the go build command line.
+// +build appengine disableunsafe
+
+package spew
+
+import "reflect"
+
+const (
+ // UnsafeDisabled is a build-time constant which specifies whether or
+ // not access to the unsafe package is available.
+ UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data. However, doing this relies on access to
+// the unsafe package. This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+ return v
+}
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go
similarity index 70%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go
rename to vendor/github.com/davecgh/go-spew/spew/common.go
index 8252cd3ee58e574c7cd3de450918a2388bc4e604..14f02dc15b7dd70886b25b055fe9db99bc0941ff 100644
--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go
+++ b/vendor/github.com/davecgh/go-spew/spew/common.go
@@ -23,116 +23,8 @@ import (
"reflect"
"sort"
"strconv"
- "unsafe"
)
-const (
- // ptrSize is the size of a pointer on the current arch.
- ptrSize = unsafe.Sizeof((*byte)(nil))
-)
-
-var (
- // offsetPtr, offsetScalar, and offsetFlag are the offsets for the
- // internal reflect.Value fields. These values are valid before golang
- // commit ecccf07e7f9d which changed the format. The are also valid
- // after commit 82f48826c6c7 which changed the format again to mirror
- // the original format. Code in the init function updates these offsets
- // as necessary.
- offsetPtr = uintptr(ptrSize)
- offsetScalar = uintptr(0)
- offsetFlag = uintptr(ptrSize * 2)
-
- // flagKindWidth and flagKindShift indicate various bits that the
- // reflect package uses internally to track kind information.
- //
- // flagRO indicates whether or not the value field of a reflect.Value is
- // read-only.
- //
- // flagIndir indicates whether the value field of a reflect.Value is
- // the actual data or a pointer to the data.
- //
- // These values are valid before golang commit 90a7c3c86944 which
- // changed their positions. Code in the init function updates these
- // flags as necessary.
- flagKindWidth = uintptr(5)
- flagKindShift = uintptr(flagKindWidth - 1)
- flagRO = uintptr(1 << 0)
- flagIndir = uintptr(1 << 1)
-)
-
-func init() {
- // Older versions of reflect.Value stored small integers directly in the
- // ptr field (which is named val in the older versions). Versions
- // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
- // scalar for this purpose which unfortunately came before the flag
- // field, so the offset of the flag field is different for those
- // versions.
- //
- // This code constructs a new reflect.Value from a known small integer
- // and checks if the size of the reflect.Value struct indicates it has
- // the scalar field. When it does, the offsets are updated accordingly.
- vv := reflect.ValueOf(0xf00)
- if unsafe.Sizeof(vv) == (ptrSize * 4) {
- offsetScalar = ptrSize * 2
- offsetFlag = ptrSize * 3
- }
-
- // Commit 90a7c3c86944 changed the flag positions such that the low
- // order bits are the kind. This code extracts the kind from the flags
- // field and ensures it's the correct type. When it's not, the flag
- // order has been changed to the newer format, so the flags are updated
- // accordingly.
- upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
- upfv := *(*uintptr)(upf)
- flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
- if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
- flagKindShift = 0
- flagRO = 1 << 5
- flagIndir = 1 << 6
- }
-}
-
-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
-// the typical safety restrictions preventing access to unaddressable and
-// unexported data. It works by digging the raw pointer to the underlying
-// value out of the protected value and generating a new unprotected (unsafe)
-// reflect.Value to it.
-//
-// This allows us to check for implementations of the Stringer and error
-// interfaces to be used for pretty printing ordinarily unaddressable and
-// inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
- indirects := 1
- vt := v.Type()
- upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
- rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
- if rvf&flagIndir != 0 {
- vt = reflect.PtrTo(v.Type())
- indirects++
- } else if offsetScalar != 0 {
- // The value is in the scalar field when it's not one of the
- // reference types.
- switch vt.Kind() {
- case reflect.Uintptr:
- case reflect.Chan:
- case reflect.Func:
- case reflect.Map:
- case reflect.Ptr:
- case reflect.UnsafePointer:
- default:
- upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
- offsetScalar)
- }
- }
-
- pv := reflect.NewAt(vt, upv)
- rv = pv
- for i := 0; i < indirects; i++ {
- rv = rv.Elem()
- }
- return rv
-}
-
// Some constants in the form of bytes to avoid string overhead. This mirrors
// the technique used in the fmt package.
var (
@@ -194,9 +86,14 @@ func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool)
// We need an interface to check if the type implements the error or
// Stringer interface. However, the reflect package won't give us an
// interface on certain things like unexported struct fields in order
- // to enforce visibility rules. We use unsafe to bypass these restrictions
- // since this package does not mutate the values.
+ // to enforce visibility rules. We use unsafe, when it's available,
+ // to bypass these restrictions since this package does not mutate the
+ // values.
if !v.CanInterface() {
+ if UnsafeDisabled {
+ return false
+ }
+
v = unsafeReflectValue(v)
}
@@ -206,21 +103,15 @@ func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool)
// mutate the value, however, types which choose to satisify an error or
// Stringer interface with a pointer receiver should not be mutating their
// state inside these interface methods.
- var viface interface{}
- if !cs.DisablePointerMethods {
- if !v.CanAddr() {
- v = unsafeReflectValue(v)
- }
- viface = v.Addr().Interface()
- } else {
- if v.CanAddr() {
- v = v.Addr()
- }
- viface = v.Interface()
+ if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+ v = unsafeReflectValue(v)
+ }
+ if v.CanAddr() {
+ v = v.Addr()
}
// Is it an error or Stringer?
- switch iface := viface.(type) {
+ switch iface := v.Interface().(type) {
case error:
defer catchPanic(w, v)
if cs.ContinueOnMethod {
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go
rename to vendor/github.com/davecgh/go-spew/spew/config.go
index 9e21b38ca25ed6690eb1439bef7eba7041870286..ee1ab07b3fdb1ed918c27783fdfaa34a0fcb9f0f 100644
--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go
+++ b/vendor/github.com/davecgh/go-spew/spew/config.go
@@ -61,7 +61,10 @@ type ConfigState struct {
// with a pointer receiver could technically mutate the value, however,
// in practice, types which choose to satisify an error or Stringer
// interface with a pointer receiver should not be mutating their state
- // inside these interface methods.
+ // inside these interface methods. As a result, this option relies on
+ // access to the unsafe package, so it will not have any effect when
+ // running in environments without access to the unsafe package such as
+ // Google App Engine or with the "disableunsafe" build tag specified.
DisablePointerMethods bool
// ContinueOnMethod specifies whether or not recursion should continue once
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go
rename to vendor/github.com/davecgh/go-spew/spew/doc.go
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go
rename to vendor/github.com/davecgh/go-spew/spew/dump.go
index 5783145b781a79340647610df431a6e650fb2322..a0ff95e27e524b488f1b5d9f51ecfef5d64b7981 100644
--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go
+++ b/vendor/github.com/davecgh/go-spew/spew/dump.go
@@ -181,25 +181,28 @@ func (d *dumpState) dumpSlice(v reflect.Value) {
// Try to use existing uint8 slices and fall back to converting
// and copying if that fails.
case vt.Kind() == reflect.Uint8:
- // We need an addressable interface to convert the type back
- // into a byte slice. However, the reflect package won't give
- // us an interface on certain things like unexported struct
- // fields in order to enforce visibility rules. We use unsafe
- // to bypass these restrictions since this package does not
+ // We need an addressable interface to convert the type
+ // to a byte slice. However, the reflect package won't
+ // give us an interface on certain things like
+ // unexported struct fields in order to enforce
+ // visibility rules. We use unsafe, when available, to
+ // bypass these restrictions since this package does not
// mutate the values.
vs := v
if !vs.CanInterface() || !vs.CanAddr() {
vs = unsafeReflectValue(vs)
}
- vs = vs.Slice(0, numEntries)
-
- // Use the existing uint8 slice if it can be type
- // asserted.
- iface := vs.Interface()
- if slice, ok := iface.([]uint8); ok {
- buf = slice
- doHexDump = true
- break
+ if !UnsafeDisabled {
+ vs = vs.Slice(0, numEntries)
+
+ // Use the existing uint8 slice if it can be
+ // type asserted.
+ iface := vs.Interface()
+ if slice, ok := iface.([]uint8); ok {
+ buf = slice
+ doHexDump = true
+ break
+ }
}
// The underlying data needs to be converted if it can't
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go
rename to vendor/github.com/davecgh/go-spew/spew/format.go
diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go
rename to vendor/github.com/davecgh/go-spew/spew/spew.go
diff --git a/vendor/github.com/docker/distribution/LICENSE b/vendor/github.com/docker/distribution/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e06d2081865a766a8668acc12878f98b27fc9ea0
--- /dev/null
+++ b/vendor/github.com/docker/distribution/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 {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/vendor/github.com/docker/distribution/digest/digest.go b/vendor/github.com/docker/distribution/digest/digest.go
new file mode 100644
index 0000000000000000000000000000000000000000..31d821bba72daa7516ba9fabb7031f7e5a769bdd
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digest/digest.go
@@ -0,0 +1,139 @@
+package digest
+
+import (
+ "fmt"
+ "hash"
+ "io"
+ "regexp"
+ "strings"
+)
+
+const (
+ // DigestSha256EmptyTar is the canonical sha256 digest of empty data
+ DigestSha256EmptyTar = "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+)
+
+// Digest allows simple protection of hex formatted digest strings, prefixed
+// by their algorithm. Strings of type Digest have some guarantee of being in
+// the correct format and it provides quick access to the components of a
+// digest string.
+//
+// The following is an example of the contents of Digest types:
+//
+// sha256:7173b809ca12ec5dee4506cd86be934c4596dd234ee82c0662eac04a8c2c71dc
+//
+// This allows to abstract the digest behind this type and work only in those
+// terms.
+type Digest string
+
+// NewDigest returns a Digest from alg and a hash.Hash object.
+func NewDigest(alg Algorithm, h hash.Hash) Digest {
+ return NewDigestFromBytes(alg, h.Sum(nil))
+}
+
+// NewDigestFromBytes returns a new digest from the byte contents of p.
+// Typically, this can come from hash.Hash.Sum(...) or xxx.SumXXX(...)
+// functions. This is also useful for rebuilding digests from binary
+// serializations.
+func NewDigestFromBytes(alg Algorithm, p []byte) Digest {
+ return Digest(fmt.Sprintf("%s:%x", alg, p))
+}
+
+// NewDigestFromHex returns a Digest from alg and a the hex encoded digest.
+func NewDigestFromHex(alg, hex string) Digest {
+ return Digest(fmt.Sprintf("%s:%s", alg, hex))
+}
+
+// DigestRegexp matches valid digest types.
+var DigestRegexp = regexp.MustCompile(`[a-zA-Z0-9-_+.]+:[a-fA-F0-9]+`)
+
+// DigestRegexpAnchored matches valid digest types, anchored to the start and end of the match.
+var DigestRegexpAnchored = regexp.MustCompile(`^` + DigestRegexp.String() + `$`)
+
+var (
+ // ErrDigestInvalidFormat returned when digest format invalid.
+ ErrDigestInvalidFormat = fmt.Errorf("invalid checksum digest format")
+
+ // ErrDigestInvalidLength returned when digest has invalid length.
+ ErrDigestInvalidLength = fmt.Errorf("invalid checksum digest length")
+
+ // ErrDigestUnsupported returned when the digest algorithm is unsupported.
+ ErrDigestUnsupported = fmt.Errorf("unsupported digest algorithm")
+)
+
+// ParseDigest parses s and returns the validated digest object. An error will
+// be returned if the format is invalid.
+func ParseDigest(s string) (Digest, error) {
+ d := Digest(s)
+
+ return d, d.Validate()
+}
+
+// FromReader returns the most valid digest for the underlying content using
+// the canonical digest algorithm.
+func FromReader(rd io.Reader) (Digest, error) {
+ return Canonical.FromReader(rd)
+}
+
+// FromBytes digests the input and returns a Digest.
+func FromBytes(p []byte) Digest {
+ return Canonical.FromBytes(p)
+}
+
+// Validate checks that the contents of d is a valid digest, returning an
+// error if not.
+func (d Digest) Validate() error {
+ s := string(d)
+
+ if !DigestRegexpAnchored.MatchString(s) {
+ return ErrDigestInvalidFormat
+ }
+
+ i := strings.Index(s, ":")
+ if i < 0 {
+ return ErrDigestInvalidFormat
+ }
+
+ // case: "sha256:" with no hex.
+ if i+1 == len(s) {
+ return ErrDigestInvalidFormat
+ }
+
+ switch algorithm := Algorithm(s[:i]); algorithm {
+ case SHA256, SHA384, SHA512:
+ if algorithm.Size()*2 != len(s[i+1:]) {
+ return ErrDigestInvalidLength
+ }
+ break
+ default:
+ return ErrDigestUnsupported
+ }
+
+ return nil
+}
+
+// Algorithm returns the algorithm portion of the digest. This will panic if
+// the underlying digest is not in a valid format.
+func (d Digest) Algorithm() Algorithm {
+ return Algorithm(d[:d.sepIndex()])
+}
+
+// Hex returns the hex digest portion of the digest. This will panic if the
+// underlying digest is not in a valid format.
+func (d Digest) Hex() string {
+ return string(d[d.sepIndex()+1:])
+}
+
+func (d Digest) String() string {
+ return string(d)
+}
+
+func (d Digest) sepIndex() int {
+ i := strings.Index(string(d), ":")
+
+ if i < 0 {
+ panic("could not find ':' in digest: " + d)
+ }
+
+ return i
+}
diff --git a/vendor/github.com/docker/distribution/digest/digester.go b/vendor/github.com/docker/distribution/digest/digester.go
new file mode 100644
index 0000000000000000000000000000000000000000..f3105a45b697790a50c5352e26a64adbc36db29b
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digest/digester.go
@@ -0,0 +1,155 @@
+package digest
+
+import (
+ "crypto"
+ "fmt"
+ "hash"
+ "io"
+)
+
+// Algorithm identifies and implementation of a digester by an identifier.
+// Note the that this defines both the hash algorithm used and the string
+// encoding.
+type Algorithm string
+
+// supported digest types
+const (
+ SHA256 Algorithm = "sha256" // sha256 with hex encoding
+ SHA384 Algorithm = "sha384" // sha384 with hex encoding
+ SHA512 Algorithm = "sha512" // sha512 with hex encoding
+
+ // Canonical is the primary digest algorithm used with the distribution
+ // project. Other digests may be used but this one is the primary storage
+ // digest.
+ Canonical = SHA256
+)
+
+var (
+ // TODO(stevvooe): Follow the pattern of the standard crypto package for
+ // registration of digests. Effectively, we are a registerable set and
+ // common symbol access.
+
+ // algorithms maps values to hash.Hash implementations. Other algorithms
+ // may be available but they cannot be calculated by the digest package.
+ algorithms = map[Algorithm]crypto.Hash{
+ SHA256: crypto.SHA256,
+ SHA384: crypto.SHA384,
+ SHA512: crypto.SHA512,
+ }
+)
+
+// Available returns true if the digest type is available for use. If this
+// returns false, New and Hash will return nil.
+func (a Algorithm) Available() bool {
+ h, ok := algorithms[a]
+ if !ok {
+ return false
+ }
+
+ // check availability of the hash, as well
+ return h.Available()
+}
+
+func (a Algorithm) String() string {
+ return string(a)
+}
+
+// Size returns number of bytes returned by the hash.
+func (a Algorithm) Size() int {
+ h, ok := algorithms[a]
+ if !ok {
+ return 0
+ }
+ return h.Size()
+}
+
+// Set implemented to allow use of Algorithm as a command line flag.
+func (a *Algorithm) Set(value string) error {
+ if value == "" {
+ *a = Canonical
+ } else {
+ // just do a type conversion, support is queried with Available.
+ *a = Algorithm(value)
+ }
+
+ return nil
+}
+
+// New returns a new digester for the specified algorithm. If the algorithm
+// does not have a digester implementation, nil will be returned. This can be
+// checked by calling Available before calling New.
+func (a Algorithm) New() Digester {
+ return &digester{
+ alg: a,
+ hash: a.Hash(),
+ }
+}
+
+// Hash returns a new hash as used by the algorithm. If not available, the
+// method will panic. Check Algorithm.Available() before calling.
+func (a Algorithm) Hash() hash.Hash {
+ if !a.Available() {
+ // NOTE(stevvooe): A missing hash is usually a programming error that
+ // must be resolved at compile time. We don't import in the digest
+ // package to allow users to choose their hash implementation (such as
+ // when using stevvooe/resumable or a hardware accelerated package).
+ //
+ // Applications that may want to resolve the hash at runtime should
+ // call Algorithm.Available before call Algorithm.Hash().
+ panic(fmt.Sprintf("%v not available (make sure it is imported)", a))
+ }
+
+ return algorithms[a].New()
+}
+
+// FromReader returns the digest of the reader using the algorithm.
+func (a Algorithm) FromReader(rd io.Reader) (Digest, error) {
+ digester := a.New()
+
+ if _, err := io.Copy(digester.Hash(), rd); err != nil {
+ return "", err
+ }
+
+ return digester.Digest(), nil
+}
+
+// FromBytes digests the input and returns a Digest.
+func (a Algorithm) FromBytes(p []byte) Digest {
+ digester := a.New()
+
+ if _, err := digester.Hash().Write(p); err != nil {
+ // Writes to a Hash should never fail. None of the existing
+ // hash implementations in the stdlib or hashes vendored
+ // here can return errors from Write. Having a panic in this
+ // condition instead of having FromBytes return an error value
+ // avoids unnecessary error handling paths in all callers.
+ panic("write to hash function returned error: " + err.Error())
+ }
+
+ return digester.Digest()
+}
+
+// TODO(stevvooe): Allow resolution of verifiers using the digest type and
+// this registration system.
+
+// Digester calculates the digest of written data. Writes should go directly
+// to the return value of Hash, while calling Digest will return the current
+// value of the digest.
+type Digester interface {
+ Hash() hash.Hash // provides direct access to underlying hash instance.
+ Digest() Digest
+}
+
+// digester provides a simple digester definition that embeds a hasher.
+type digester struct {
+ alg Algorithm
+ hash hash.Hash
+}
+
+func (d *digester) Hash() hash.Hash {
+ return d.hash
+}
+
+func (d *digester) Digest() Digest {
+ return NewDigest(d.alg, d.hash)
+}
diff --git a/vendor/github.com/docker/distribution/digest/doc.go b/vendor/github.com/docker/distribution/digest/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..f64b0db32b4cf007a3f5b277eb8ec18235b5b8d3
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digest/doc.go
@@ -0,0 +1,42 @@
+// Package digest provides a generalized type to opaquely represent message
+// digests and their operations within the registry. The Digest type is
+// designed to serve as a flexible identifier in a content-addressable system.
+// More importantly, it provides tools and wrappers to work with
+// hash.Hash-based digests with little effort.
+//
+// Basics
+//
+// The format of a digest is simply a string with two parts, dubbed the
+// "algorithm" and the "digest", separated by a colon:
+//
+// <algorithm>:<digest>
+//
+// An example of a sha256 digest representation follows:
+//
+// sha256:7173b809ca12ec5dee4506cd86be934c4596dd234ee82c0662eac04a8c2c71dc
+//
+// In this case, the string "sha256" is the algorithm and the hex bytes are
+// the "digest".
+//
+// Because the Digest type is simply a string, once a valid Digest is
+// obtained, comparisons are cheap, quick and simple to express with the
+// standard equality operator.
+//
+// Verification
+//
+// The main benefit of using the Digest type is simple verification against a
+// given digest. The Verifier interface, modeled after the stdlib hash.Hash
+// interface, provides a common write sink for digest verification. After
+// writing is complete, calling the Verifier.Verified method will indicate
+// whether or not the stream of bytes matches the target digest.
+//
+// Missing Features
+//
+// In addition to the above, we intend to add the following features to this
+// package:
+//
+// 1. A Digester type that supports write sink digest calculation.
+//
+// 2. Suspend and resume of ongoing digest calculations to support efficient digest verification in the registry.
+//
+package digest
diff --git a/vendor/github.com/docker/distribution/digest/set.go b/vendor/github.com/docker/distribution/digest/set.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b9313c1aeacf5a192d9619dd2d374417299e714
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digest/set.go
@@ -0,0 +1,245 @@
+package digest
+
+import (
+ "errors"
+ "sort"
+ "strings"
+ "sync"
+)
+
+var (
+ // ErrDigestNotFound is used when a matching digest
+ // could not be found in a set.
+ ErrDigestNotFound = errors.New("digest not found")
+
+ // ErrDigestAmbiguous is used when multiple digests
+ // are found in a set. None of the matching digests
+ // should be considered valid matches.
+ ErrDigestAmbiguous = errors.New("ambiguous digest string")
+)
+
+// Set is used to hold a unique set of digests which
+// may be easily referenced by easily referenced by a string
+// representation of the digest as well as short representation.
+// The uniqueness of the short representation is based on other
+// digests in the set. If digests are omitted from this set,
+// collisions in a larger set may not be detected, therefore it
+// is important to always do short representation lookups on
+// the complete set of digests. To mitigate collisions, an
+// appropriately long short code should be used.
+type Set struct {
+ mutex sync.RWMutex
+ entries digestEntries
+}
+
+// NewSet creates an empty set of digests
+// which may have digests added.
+func NewSet() *Set {
+ return &Set{
+ entries: digestEntries{},
+ }
+}
+
+// checkShortMatch checks whether two digests match as either whole
+// values or short values. This function does not test equality,
+// rather whether the second value could match against the first
+// value.
+func checkShortMatch(alg Algorithm, hex, shortAlg, shortHex string) bool {
+ if len(hex) == len(shortHex) {
+ if hex != shortHex {
+ return false
+ }
+ if len(shortAlg) > 0 && string(alg) != shortAlg {
+ return false
+ }
+ } else if !strings.HasPrefix(hex, shortHex) {
+ return false
+ } else if len(shortAlg) > 0 && string(alg) != shortAlg {
+ return false
+ }
+ return true
+}
+
+// Lookup looks for a digest matching the given string representation.
+// If no digests could be found ErrDigestNotFound will be returned
+// with an empty digest value. If multiple matches are found
+// ErrDigestAmbiguous will be returned with an empty digest value.
+func (dst *Set) Lookup(d string) (Digest, error) {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ if len(dst.entries) == 0 {
+ return "", ErrDigestNotFound
+ }
+ var (
+ searchFunc func(int) bool
+ alg Algorithm
+ hex string
+ )
+ dgst, err := ParseDigest(d)
+ if err == ErrDigestInvalidFormat {
+ hex = d
+ searchFunc = func(i int) bool {
+ return dst.entries[i].val >= d
+ }
+ } else {
+ hex = dgst.Hex()
+ alg = dgst.Algorithm()
+ searchFunc = func(i int) bool {
+ if dst.entries[i].val == hex {
+ return dst.entries[i].alg >= alg
+ }
+ return dst.entries[i].val >= hex
+ }
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ if idx == len(dst.entries) || !checkShortMatch(dst.entries[idx].alg, dst.entries[idx].val, string(alg), hex) {
+ return "", ErrDigestNotFound
+ }
+ if dst.entries[idx].alg == alg && dst.entries[idx].val == hex {
+ return dst.entries[idx].digest, nil
+ }
+ if idx+1 < len(dst.entries) && checkShortMatch(dst.entries[idx+1].alg, dst.entries[idx+1].val, string(alg), hex) {
+ return "", ErrDigestAmbiguous
+ }
+
+ return dst.entries[idx].digest, nil
+}
+
+// Add adds the given digest to the set. An error will be returned
+// if the given digest is invalid. If the digest already exists in the
+// set, this operation will be a no-op.
+func (dst *Set) Add(d Digest) error {
+ if err := d.Validate(); err != nil {
+ return err
+ }
+ dst.mutex.Lock()
+ defer dst.mutex.Unlock()
+ entry := &digestEntry{alg: d.Algorithm(), val: d.Hex(), digest: d}
+ searchFunc := func(i int) bool {
+ if dst.entries[i].val == entry.val {
+ return dst.entries[i].alg >= entry.alg
+ }
+ return dst.entries[i].val >= entry.val
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ if idx == len(dst.entries) {
+ dst.entries = append(dst.entries, entry)
+ return nil
+ } else if dst.entries[idx].digest == d {
+ return nil
+ }
+
+ entries := append(dst.entries, nil)
+ copy(entries[idx+1:], entries[idx:len(entries)-1])
+ entries[idx] = entry
+ dst.entries = entries
+ return nil
+}
+
+// Remove removes the given digest from the set. An err will be
+// returned if the given digest is invalid. If the digest does
+// not exist in the set, this operation will be a no-op.
+func (dst *Set) Remove(d Digest) error {
+ if err := d.Validate(); err != nil {
+ return err
+ }
+ dst.mutex.Lock()
+ defer dst.mutex.Unlock()
+ entry := &digestEntry{alg: d.Algorithm(), val: d.Hex(), digest: d}
+ searchFunc := func(i int) bool {
+ if dst.entries[i].val == entry.val {
+ return dst.entries[i].alg >= entry.alg
+ }
+ return dst.entries[i].val >= entry.val
+ }
+ idx := sort.Search(len(dst.entries), searchFunc)
+ // Not found if idx is after or value at idx is not digest
+ if idx == len(dst.entries) || dst.entries[idx].digest != d {
+ return nil
+ }
+
+ entries := dst.entries
+ copy(entries[idx:], entries[idx+1:])
+ entries = entries[:len(entries)-1]
+ dst.entries = entries
+
+ return nil
+}
+
+// All returns all the digests in the set
+func (dst *Set) All() []Digest {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ retValues := make([]Digest, len(dst.entries))
+ for i := range dst.entries {
+ retValues[i] = dst.entries[i].digest
+ }
+
+ return retValues
+}
+
+// ShortCodeTable returns a map of Digest to unique short codes. The
+// length represents the minimum value, the maximum length may be the
+// entire value of digest if uniqueness cannot be achieved without the
+// full value. This function will attempt to make short codes as short
+// as possible to be unique.
+func ShortCodeTable(dst *Set, length int) map[Digest]string {
+ dst.mutex.RLock()
+ defer dst.mutex.RUnlock()
+ m := make(map[Digest]string, len(dst.entries))
+ l := length
+ resetIdx := 0
+ for i := 0; i < len(dst.entries); i++ {
+ var short string
+ extended := true
+ for extended {
+ extended = false
+ if len(dst.entries[i].val) <= l {
+ short = dst.entries[i].digest.String()
+ } else {
+ short = dst.entries[i].val[:l]
+ for j := i + 1; j < len(dst.entries); j++ {
+ if checkShortMatch(dst.entries[j].alg, dst.entries[j].val, "", short) {
+ if j > resetIdx {
+ resetIdx = j
+ }
+ extended = true
+ } else {
+ break
+ }
+ }
+ if extended {
+ l++
+ }
+ }
+ }
+ m[dst.entries[i].digest] = short
+ if i >= resetIdx {
+ l = length
+ }
+ }
+ return m
+}
+
+type digestEntry struct {
+ alg Algorithm
+ val string
+ digest Digest
+}
+
+type digestEntries []*digestEntry
+
+func (d digestEntries) Len() int {
+ return len(d)
+}
+
+func (d digestEntries) Less(i, j int) bool {
+ if d[i].val != d[j].val {
+ return d[i].val < d[j].val
+ }
+ return d[i].alg < d[j].alg
+}
+
+func (d digestEntries) Swap(i, j int) {
+ d[i], d[j] = d[j], d[i]
+}
diff --git a/vendor/github.com/docker/distribution/digest/verifiers.go b/vendor/github.com/docker/distribution/digest/verifiers.go
new file mode 100644
index 0000000000000000000000000000000000000000..9af3be1341eca046d6bee8e947b1777637d07697
--- /dev/null
+++ b/vendor/github.com/docker/distribution/digest/verifiers.go
@@ -0,0 +1,44 @@
+package digest
+
+import (
+ "hash"
+ "io"
+)
+
+// Verifier presents a general verification interface to be used with message
+// digests and other byte stream verifications. Users instantiate a Verifier
+// from one of the various methods, write the data under test to it then check
+// the result with the Verified method.
+type Verifier interface {
+ io.Writer
+
+ // Verified will return true if the content written to Verifier matches
+ // the digest.
+ Verified() bool
+}
+
+// NewDigestVerifier returns a verifier that compares the written bytes
+// against a passed in digest.
+func NewDigestVerifier(d Digest) (Verifier, error) {
+ if err := d.Validate(); err != nil {
+ return nil, err
+ }
+
+ return hashVerifier{
+ hash: d.Algorithm().Hash(),
+ digest: d,
+ }, nil
+}
+
+type hashVerifier struct {
+ digest Digest
+ hash hash.Hash
+}
+
+func (hv hashVerifier) Write(p []byte) (n int, err error) {
+ return hv.hash.Write(p)
+}
+
+func (hv hashVerifier) Verified() bool {
+ return hv.digest == NewDigest(hv.digest.Algorithm(), hv.hash)
+}
diff --git a/vendor/github.com/docker/distribution/reference/reference.go b/vendor/github.com/docker/distribution/reference/reference.go
new file mode 100644
index 0000000000000000000000000000000000000000..bb09fa25dae2c905cdf1a7a2b32e78d7087e33af
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/reference.go
@@ -0,0 +1,334 @@
+// Package reference provides a general type to represent any way of referencing images within the registry.
+// Its main purpose is to abstract tags and digests (content-addressable hash).
+//
+// Grammar
+//
+// reference := name [ ":" tag ] [ "@" digest ]
+// name := [hostname '/'] component ['/' component]*
+// hostname := hostcomponent ['.' hostcomponent]* [':' port-number]
+// hostcomponent := /([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])/
+// port-number := /[0-9]+/
+// component := alpha-numeric [separator alpha-numeric]*
+// alpha-numeric := /[a-z0-9]+/
+// separator := /[_.]|__|[-]*/
+//
+// tag := /[\w][\w.-]{0,127}/
+//
+// digest := digest-algorithm ":" digest-hex
+// digest-algorithm := digest-algorithm-component [ digest-algorithm-separator digest-algorithm-component ]
+// digest-algorithm-separator := /[+.-_]/
+// digest-algorithm-component := /[A-Za-z][A-Za-z0-9]*/
+// digest-hex := /[0-9a-fA-F]{32,}/ ; At least 128 bit digest value
+package reference
+
+import (
+ "errors"
+ "fmt"
+
+ "github.com/docker/distribution/digest"
+)
+
+const (
+ // NameTotalLengthMax is the maximum total number of characters in a repository name.
+ NameTotalLengthMax = 255
+)
+
+var (
+ // ErrReferenceInvalidFormat represents an error while trying to parse a string as a reference.
+ ErrReferenceInvalidFormat = errors.New("invalid reference format")
+
+ // ErrTagInvalidFormat represents an error while trying to parse a string as a tag.
+ ErrTagInvalidFormat = errors.New("invalid tag format")
+
+ // ErrDigestInvalidFormat represents an error while trying to parse a string as a tag.
+ ErrDigestInvalidFormat = errors.New("invalid digest format")
+
+ // ErrNameEmpty is returned for empty, invalid repository names.
+ ErrNameEmpty = errors.New("repository name must have at least one component")
+
+ // ErrNameTooLong is returned when a repository name is longer than NameTotalLengthMax.
+ ErrNameTooLong = fmt.Errorf("repository name must not be more than %v characters", NameTotalLengthMax)
+)
+
+// Reference is an opaque object reference identifier that may include
+// modifiers such as a hostname, name, tag, and digest.
+type Reference interface {
+ // String returns the full reference
+ String() string
+}
+
+// Field provides a wrapper type for resolving correct reference types when
+// working with encoding.
+type Field struct {
+ reference Reference
+}
+
+// AsField wraps a reference in a Field for encoding.
+func AsField(reference Reference) Field {
+ return Field{reference}
+}
+
+// Reference unwraps the reference type from the field to
+// return the Reference object. This object should be
+// of the appropriate type to further check for different
+// reference types.
+func (f Field) Reference() Reference {
+ return f.reference
+}
+
+// MarshalText serializes the field to byte text which
+// is the string of the reference.
+func (f Field) MarshalText() (p []byte, err error) {
+ return []byte(f.reference.String()), nil
+}
+
+// UnmarshalText parses text bytes by invoking the
+// reference parser to ensure the appropriately
+// typed reference object is wrapped by field.
+func (f *Field) UnmarshalText(p []byte) error {
+ r, err := Parse(string(p))
+ if err != nil {
+ return err
+ }
+
+ f.reference = r
+ return nil
+}
+
+// Named is an object with a full name
+type Named interface {
+ Reference
+ Name() string
+}
+
+// Tagged is an object which has a tag
+type Tagged interface {
+ Reference
+ Tag() string
+}
+
+// NamedTagged is an object including a name and tag.
+type NamedTagged interface {
+ Named
+ Tag() string
+}
+
+// Digested is an object which has a digest
+// in which it can be referenced by
+type Digested interface {
+ Reference
+ Digest() digest.Digest
+}
+
+// Canonical reference is an object with a fully unique
+// name including a name with hostname and digest
+type Canonical interface {
+ Named
+ Digest() digest.Digest
+}
+
+// SplitHostname splits a named reference into a
+// hostname and name string. If no valid hostname is
+// found, the hostname is empty and the full value
+// is returned as name
+func SplitHostname(named Named) (string, string) {
+ name := named.Name()
+ match := anchoredNameRegexp.FindStringSubmatch(name)
+ if match == nil || len(match) != 3 {
+ return "", name
+ }
+ return match[1], match[2]
+}
+
+// Parse parses s and returns a syntactically valid Reference.
+// If an error was encountered it is returned, along with a nil Reference.
+// NOTE: Parse will not handle short digests.
+func Parse(s string) (Reference, error) {
+ matches := ReferenceRegexp.FindStringSubmatch(s)
+ if matches == nil {
+ if s == "" {
+ return nil, ErrNameEmpty
+ }
+ // TODO(dmcgowan): Provide more specific and helpful error
+ return nil, ErrReferenceInvalidFormat
+ }
+
+ if len(matches[1]) > NameTotalLengthMax {
+ return nil, ErrNameTooLong
+ }
+
+ ref := reference{
+ name: matches[1],
+ tag: matches[2],
+ }
+ if matches[3] != "" {
+ var err error
+ ref.digest, err = digest.ParseDigest(matches[3])
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ r := getBestReferenceType(ref)
+ if r == nil {
+ return nil, ErrNameEmpty
+ }
+
+ return r, nil
+}
+
+// ParseNamed parses s and returns a syntactically valid reference implementing
+// the Named interface. The reference must have a name, otherwise an error is
+// returned.
+// If an error was encountered it is returned, along with a nil Reference.
+// NOTE: ParseNamed will not handle short digests.
+func ParseNamed(s string) (Named, error) {
+ ref, err := Parse(s)
+ if err != nil {
+ return nil, err
+ }
+ named, isNamed := ref.(Named)
+ if !isNamed {
+ return nil, fmt.Errorf("reference %s has no name", ref.String())
+ }
+ return named, nil
+}
+
+// WithName returns a named object representing the given string. If the input
+// is invalid ErrReferenceInvalidFormat will be returned.
+func WithName(name string) (Named, error) {
+ if len(name) > NameTotalLengthMax {
+ return nil, ErrNameTooLong
+ }
+ if !anchoredNameRegexp.MatchString(name) {
+ return nil, ErrReferenceInvalidFormat
+ }
+ return repository(name), nil
+}
+
+// WithTag combines the name from "name" and the tag from "tag" to form a
+// reference incorporating both the name and the tag.
+func WithTag(name Named, tag string) (NamedTagged, error) {
+ if !anchoredTagRegexp.MatchString(tag) {
+ return nil, ErrTagInvalidFormat
+ }
+ return taggedReference{
+ name: name.Name(),
+ tag: tag,
+ }, nil
+}
+
+// WithDigest combines the name from "name" and the digest from "digest" to form
+// a reference incorporating both the name and the digest.
+func WithDigest(name Named, digest digest.Digest) (Canonical, error) {
+ if !anchoredDigestRegexp.MatchString(digest.String()) {
+ return nil, ErrDigestInvalidFormat
+ }
+ return canonicalReference{
+ name: name.Name(),
+ digest: digest,
+ }, nil
+}
+
+func getBestReferenceType(ref reference) Reference {
+ if ref.name == "" {
+ // Allow digest only references
+ if ref.digest != "" {
+ return digestReference(ref.digest)
+ }
+ return nil
+ }
+ if ref.tag == "" {
+ if ref.digest != "" {
+ return canonicalReference{
+ name: ref.name,
+ digest: ref.digest,
+ }
+ }
+ return repository(ref.name)
+ }
+ if ref.digest == "" {
+ return taggedReference{
+ name: ref.name,
+ tag: ref.tag,
+ }
+ }
+
+ return ref
+}
+
+type reference struct {
+ name string
+ tag string
+ digest digest.Digest
+}
+
+func (r reference) String() string {
+ return r.name + ":" + r.tag + "@" + r.digest.String()
+}
+
+func (r reference) Name() string {
+ return r.name
+}
+
+func (r reference) Tag() string {
+ return r.tag
+}
+
+func (r reference) Digest() digest.Digest {
+ return r.digest
+}
+
+type repository string
+
+func (r repository) String() string {
+ return string(r)
+}
+
+func (r repository) Name() string {
+ return string(r)
+}
+
+type digestReference digest.Digest
+
+func (d digestReference) String() string {
+ return d.String()
+}
+
+func (d digestReference) Digest() digest.Digest {
+ return digest.Digest(d)
+}
+
+type taggedReference struct {
+ name string
+ tag string
+}
+
+func (t taggedReference) String() string {
+ return t.name + ":" + t.tag
+}
+
+func (t taggedReference) Name() string {
+ return t.name
+}
+
+func (t taggedReference) Tag() string {
+ return t.tag
+}
+
+type canonicalReference struct {
+ name string
+ digest digest.Digest
+}
+
+func (c canonicalReference) String() string {
+ return c.name + "@" + c.digest.String()
+}
+
+func (c canonicalReference) Name() string {
+ return c.name
+}
+
+func (c canonicalReference) Digest() digest.Digest {
+ return c.digest
+}
diff --git a/vendor/github.com/docker/distribution/reference/regexp.go b/vendor/github.com/docker/distribution/reference/regexp.go
new file mode 100644
index 0000000000000000000000000000000000000000..9a7d366bc8a8c79d895816410b9879cf1bfa0f66
--- /dev/null
+++ b/vendor/github.com/docker/distribution/reference/regexp.go
@@ -0,0 +1,124 @@
+package reference
+
+import "regexp"
+
+var (
+ // alphaNumericRegexp defines the alpha numeric atom, typically a
+ // component of names. This only allows lower case characters and digits.
+ alphaNumericRegexp = match(`[a-z0-9]+`)
+
+ // separatorRegexp defines the separators allowed to be embedded in name
+ // components. This allow one period, one or two underscore and multiple
+ // dashes.
+ separatorRegexp = match(`(?:[._]|__|[-]*)`)
+
+ // nameComponentRegexp restricts registry path component names to start
+ // with at least one letter or number, with following parts able to be
+ // separated by one period, one or two underscore and multiple dashes.
+ nameComponentRegexp = expression(
+ alphaNumericRegexp,
+ optional(repeated(separatorRegexp, alphaNumericRegexp)))
+
+ // hostnameComponentRegexp restricts the registry hostname component of a
+ // repository name to start with a component as defined by hostnameRegexp
+ // and followed by an optional port.
+ hostnameComponentRegexp = match(`(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])`)
+
+ // hostnameRegexp defines the structure of potential hostname components
+ // that may be part of image names. This is purposely a subset of what is
+ // allowed by DNS to ensure backwards compatibility with Docker image
+ // names.
+ hostnameRegexp = expression(
+ hostnameComponentRegexp,
+ optional(repeated(literal(`.`), hostnameComponentRegexp)),
+ optional(literal(`:`), match(`[0-9]+`)))
+
+ // TagRegexp matches valid tag names. From docker/docker:graph/tags.go.
+ TagRegexp = match(`[\w][\w.-]{0,127}`)
+
+ // anchoredTagRegexp matches valid tag names, anchored at the start and
+ // end of the matched string.
+ anchoredTagRegexp = anchored(TagRegexp)
+
+ // DigestRegexp matches valid digests.
+ DigestRegexp = match(`[A-Za-z][A-Za-z0-9]*(?:[-_+.][A-Za-z][A-Za-z0-9]*)*[:][[:xdigit:]]{32,}`)
+
+ // anchoredDigestRegexp matches valid digests, anchored at the start and
+ // end of the matched string.
+ anchoredDigestRegexp = anchored(DigestRegexp)
+
+ // NameRegexp is the format for the name component of references. The
+ // regexp has capturing groups for the hostname and name part omitting
+ // the separating forward slash from either.
+ NameRegexp = expression(
+ optional(hostnameRegexp, literal(`/`)),
+ nameComponentRegexp,
+ optional(repeated(literal(`/`), nameComponentRegexp)))
+
+ // anchoredNameRegexp is used to parse a name value, capturing the
+ // hostname and trailing components.
+ anchoredNameRegexp = anchored(
+ optional(capture(hostnameRegexp), literal(`/`)),
+ capture(nameComponentRegexp,
+ optional(repeated(literal(`/`), nameComponentRegexp))))
+
+ // ReferenceRegexp is the full supported format of a reference. The regexp
+ // is anchored and has capturing groups for name, tag, and digest
+ // components.
+ ReferenceRegexp = anchored(capture(NameRegexp),
+ optional(literal(":"), capture(TagRegexp)),
+ optional(literal("@"), capture(DigestRegexp)))
+)
+
+// match compiles the string to a regular expression.
+var match = regexp.MustCompile
+
+// literal compiles s into a literal regular expression, escaping any regexp
+// reserved characters.
+func literal(s string) *regexp.Regexp {
+ re := match(regexp.QuoteMeta(s))
+
+ if _, complete := re.LiteralPrefix(); !complete {
+ panic("must be a literal")
+ }
+
+ return re
+}
+
+// expression defines a full expression, where each regular expression must
+// follow the previous.
+func expression(res ...*regexp.Regexp) *regexp.Regexp {
+ var s string
+ for _, re := range res {
+ s += re.String()
+ }
+
+ return match(s)
+}
+
+// optional wraps the expression in a non-capturing group and makes the
+// production optional.
+func optional(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(group(expression(res...)).String() + `?`)
+}
+
+// repeated wraps the regexp in a non-capturing group to get one or more
+// matches.
+func repeated(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(group(expression(res...)).String() + `+`)
+}
+
+// group wraps the regexp in a non-capturing group.
+func group(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`(?:` + expression(res...).String() + `)`)
+}
+
+// capture wraps the expression in a capturing group.
+func capture(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`(` + expression(res...).String() + `)`)
+}
+
+// anchored anchors the regular expression by adding start and end delimiters.
+func anchored(res ...*regexp.Regexp) *regexp.Regexp {
+ return match(`^` + expression(res...).String() + `$`)
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/flags.go b/vendor/github.com/docker/docker/pkg/mount/flags.go
new file mode 100644
index 0000000000000000000000000000000000000000..17dbd7a64cf4f4ae15cbcc0038eab358849f3de4
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/flags.go
@@ -0,0 +1,69 @@
+package mount
+
+import (
+ "strings"
+)
+
+// Parse fstab type mount options into mount() flags
+// and device specific data
+func parseOptions(options string) (int, string) {
+ var (
+ flag int
+ data []string
+ )
+
+ flags := map[string]struct {
+ clear bool
+ flag int
+ }{
+ "defaults": {false, 0},
+ "ro": {false, RDONLY},
+ "rw": {true, RDONLY},
+ "suid": {true, NOSUID},
+ "nosuid": {false, NOSUID},
+ "dev": {true, NODEV},
+ "nodev": {false, NODEV},
+ "exec": {true, NOEXEC},
+ "noexec": {false, NOEXEC},
+ "sync": {false, SYNCHRONOUS},
+ "async": {true, SYNCHRONOUS},
+ "dirsync": {false, DIRSYNC},
+ "remount": {false, REMOUNT},
+ "mand": {false, MANDLOCK},
+ "nomand": {true, MANDLOCK},
+ "atime": {true, NOATIME},
+ "noatime": {false, NOATIME},
+ "diratime": {true, NODIRATIME},
+ "nodiratime": {false, NODIRATIME},
+ "bind": {false, BIND},
+ "rbind": {false, RBIND},
+ "unbindable": {false, UNBINDABLE},
+ "runbindable": {false, RUNBINDABLE},
+ "private": {false, PRIVATE},
+ "rprivate": {false, RPRIVATE},
+ "shared": {false, SHARED},
+ "rshared": {false, RSHARED},
+ "slave": {false, SLAVE},
+ "rslave": {false, RSLAVE},
+ "relatime": {false, RELATIME},
+ "norelatime": {true, RELATIME},
+ "strictatime": {false, STRICTATIME},
+ "nostrictatime": {true, STRICTATIME},
+ }
+
+ for _, o := range strings.Split(options, ",") {
+ // If the option does not exist in the flags table or the flag
+ // is not supported on the platform,
+ // then it is a data value for a specific fs type
+ if f, exists := flags[o]; exists && f.flag != 0 {
+ if f.clear {
+ flag &= ^f.flag
+ } else {
+ flag |= f.flag
+ }
+ } else {
+ data = append(data, o)
+ }
+ }
+ return flag, strings.Join(data, ",")
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/flags_freebsd.go b/vendor/github.com/docker/docker/pkg/mount/flags_freebsd.go
new file mode 100644
index 0000000000000000000000000000000000000000..f166cb2f77864fec5a9be945a2264e783585fd59
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/flags_freebsd.go
@@ -0,0 +1,48 @@
+// +build freebsd,cgo
+
+package mount
+
+/*
+#include <sys/mount.h>
+*/
+import "C"
+
+const (
+ // RDONLY will mount the filesystem as read-only.
+ RDONLY = C.MNT_RDONLY
+
+ // NOSUID will not allow set-user-identifier or set-group-identifier bits to
+ // take effect.
+ NOSUID = C.MNT_NOSUID
+
+ // NOEXEC will not allow execution of any binaries on the mounted file system.
+ NOEXEC = C.MNT_NOEXEC
+
+ // SYNCHRONOUS will allow any I/O to the file system to be done synchronously.
+ SYNCHRONOUS = C.MNT_SYNCHRONOUS
+
+ // NOATIME will not update the file access time when reading from a file.
+ NOATIME = C.MNT_NOATIME
+)
+
+// These flags are unsupported.
+const (
+ BIND = 0
+ DIRSYNC = 0
+ MANDLOCK = 0
+ NODEV = 0
+ NODIRATIME = 0
+ UNBINDABLE = 0
+ RUNBINDABLE = 0
+ PRIVATE = 0
+ RPRIVATE = 0
+ SHARED = 0
+ RSHARED = 0
+ SLAVE = 0
+ RSLAVE = 0
+ RBIND = 0
+ RELATIVE = 0
+ RELATIME = 0
+ REMOUNT = 0
+ STRICTATIME = 0
+)
diff --git a/vendor/github.com/docker/docker/pkg/mount/flags_linux.go b/vendor/github.com/docker/docker/pkg/mount/flags_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..2f9f5c58ee5d849e1ecd74eb77e4c16079503bc2
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/flags_linux.go
@@ -0,0 +1,85 @@
+package mount
+
+import (
+ "syscall"
+)
+
+const (
+ // RDONLY will mount the file system read-only.
+ RDONLY = syscall.MS_RDONLY
+
+ // NOSUID will not allow set-user-identifier or set-group-identifier bits to
+ // take effect.
+ NOSUID = syscall.MS_NOSUID
+
+ // NODEV will not interpret character or block special devices on the file
+ // system.
+ NODEV = syscall.MS_NODEV
+
+ // NOEXEC will not allow execution of any binaries on the mounted file system.
+ NOEXEC = syscall.MS_NOEXEC
+
+ // SYNCHRONOUS will allow I/O to the file system to be done synchronously.
+ SYNCHRONOUS = syscall.MS_SYNCHRONOUS
+
+ // DIRSYNC will force all directory updates within the file system to be done
+ // synchronously. This affects the following system calls: creat, link,
+ // unlink, symlink, mkdir, rmdir, mknod and rename.
+ DIRSYNC = syscall.MS_DIRSYNC
+
+ // REMOUNT will attempt to remount an already-mounted file system. This is
+ // commonly used to change the mount flags for a file system, especially to
+ // make a readonly file system writeable. It does not change device or mount
+ // point.
+ REMOUNT = syscall.MS_REMOUNT
+
+ // MANDLOCK will force mandatory locks on a filesystem.
+ MANDLOCK = syscall.MS_MANDLOCK
+
+ // NOATIME will not update the file access time when reading from a file.
+ NOATIME = syscall.MS_NOATIME
+
+ // NODIRATIME will not update the directory access time.
+ NODIRATIME = syscall.MS_NODIRATIME
+
+ // BIND remounts a subtree somewhere else.
+ BIND = syscall.MS_BIND
+
+ // RBIND remounts a subtree and all possible submounts somewhere else.
+ RBIND = syscall.MS_BIND | syscall.MS_REC
+
+ // UNBINDABLE creates a mount which cannot be cloned through a bind operation.
+ UNBINDABLE = syscall.MS_UNBINDABLE
+
+ // RUNBINDABLE marks the entire mount tree as UNBINDABLE.
+ RUNBINDABLE = syscall.MS_UNBINDABLE | syscall.MS_REC
+
+ // PRIVATE creates a mount which carries no propagation abilities.
+ PRIVATE = syscall.MS_PRIVATE
+
+ // RPRIVATE marks the entire mount tree as PRIVATE.
+ RPRIVATE = syscall.MS_PRIVATE | syscall.MS_REC
+
+ // SLAVE creates a mount which receives propagation from its master, but not
+ // vice versa.
+ SLAVE = syscall.MS_SLAVE
+
+ // RSLAVE marks the entire mount tree as SLAVE.
+ RSLAVE = syscall.MS_SLAVE | syscall.MS_REC
+
+ // SHARED creates a mount which provides the ability to create mirrors of
+ // that mount such that mounts and unmounts within any of the mirrors
+ // propagate to the other mirrors.
+ SHARED = syscall.MS_SHARED
+
+ // RSHARED marks the entire mount tree as SHARED.
+ RSHARED = syscall.MS_SHARED | syscall.MS_REC
+
+ // RELATIME updates inode access times relative to modify or change time.
+ RELATIME = syscall.MS_RELATIME
+
+ // STRICTATIME allows to explicitly request full atime updates. This makes
+ // it possible for the kernel to default to relatime or noatime but still
+ // allow userspace to override it.
+ STRICTATIME = syscall.MS_STRICTATIME
+)
diff --git a/vendor/github.com/docker/docker/pkg/mount/flags_unsupported.go b/vendor/github.com/docker/docker/pkg/mount/flags_unsupported.go
new file mode 100644
index 0000000000000000000000000000000000000000..a90d3d1151263bcb8f56e5ea235326cf81de90e3
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/flags_unsupported.go
@@ -0,0 +1,30 @@
+// +build !linux,!freebsd freebsd,!cgo
+
+package mount
+
+// These flags are unsupported.
+const (
+ BIND = 0
+ DIRSYNC = 0
+ MANDLOCK = 0
+ NOATIME = 0
+ NODEV = 0
+ NODIRATIME = 0
+ NOEXEC = 0
+ NOSUID = 0
+ UNBINDABLE = 0
+ RUNBINDABLE = 0
+ PRIVATE = 0
+ RPRIVATE = 0
+ SHARED = 0
+ RSHARED = 0
+ SLAVE = 0
+ RSLAVE = 0
+ RBIND = 0
+ RELATIME = 0
+ RELATIVE = 0
+ REMOUNT = 0
+ STRICTATIME = 0
+ SYNCHRONOUS = 0
+ RDONLY = 0
+)
diff --git a/vendor/github.com/docker/docker/pkg/mount/mount.go b/vendor/github.com/docker/docker/pkg/mount/mount.go
new file mode 100644
index 0000000000000000000000000000000000000000..ed7216e5c04da8b39302a2c30afc1b6c5bef2d46
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mount.go
@@ -0,0 +1,74 @@
+package mount
+
+import (
+ "time"
+)
+
+// GetMounts retrieves a list of mounts for the current running process.
+func GetMounts() ([]*Info, error) {
+ return parseMountTable()
+}
+
+// Mounted looks at /proc/self/mountinfo to determine of the specified
+// mountpoint has been mounted
+func Mounted(mountpoint string) (bool, error) {
+ entries, err := parseMountTable()
+ if err != nil {
+ return false, err
+ }
+
+ // Search the table for the mountpoint
+ for _, e := range entries {
+ if e.Mountpoint == mountpoint {
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+// Mount will mount filesystem according to the specified configuration, on the
+// condition that the target path is *not* already mounted. Options must be
+// specified like the mount or fstab unix commands: "opt1=val1,opt2=val2". See
+// flags.go for supported option flags.
+func Mount(device, target, mType, options string) error {
+ flag, _ := parseOptions(options)
+ if flag&REMOUNT != REMOUNT {
+ if mounted, err := Mounted(target); err != nil || mounted {
+ return err
+ }
+ }
+ return ForceMount(device, target, mType, options)
+}
+
+// ForceMount will mount a filesystem according to the specified configuration,
+// *regardless* if the target path is not already mounted. Options must be
+// specified like the mount or fstab unix commands: "opt1=val1,opt2=val2". See
+// flags.go for supported option flags.
+func ForceMount(device, target, mType, options string) error {
+ flag, data := parseOptions(options)
+ if err := mount(device, target, mType, uintptr(flag), data); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Unmount will unmount the target filesystem, so long as it is mounted.
+func Unmount(target string) error {
+ if mounted, err := Mounted(target); err != nil || !mounted {
+ return err
+ }
+ return ForceUnmount(target)
+}
+
+// ForceUnmount will force an unmount of the target filesystem, regardless if
+// it is mounted or not.
+func ForceUnmount(target string) (err error) {
+ // Simple retry logic for unmount
+ for i := 0; i < 10; i++ {
+ if err = unmount(target, 0); err == nil {
+ return nil
+ }
+ time.Sleep(100 * time.Millisecond)
+ }
+ return
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mounter_freebsd.go b/vendor/github.com/docker/docker/pkg/mount/mounter_freebsd.go
new file mode 100644
index 0000000000000000000000000000000000000000..bb870e6f59b9f2dcd50cf9469b6c7edb11dab281
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mounter_freebsd.go
@@ -0,0 +1,59 @@
+package mount
+
+/*
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/_iovec.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+*/
+import "C"
+
+import (
+ "fmt"
+ "strings"
+ "syscall"
+ "unsafe"
+)
+
+func allocateIOVecs(options []string) []C.struct_iovec {
+ out := make([]C.struct_iovec, len(options))
+ for i, option := range options {
+ out[i].iov_base = unsafe.Pointer(C.CString(option))
+ out[i].iov_len = C.size_t(len(option) + 1)
+ }
+ return out
+}
+
+func mount(device, target, mType string, flag uintptr, data string) error {
+ isNullFS := false
+
+ xs := strings.Split(data, ",")
+ for _, x := range xs {
+ if x == "bind" {
+ isNullFS = true
+ }
+ }
+
+ options := []string{"fspath", target}
+ if isNullFS {
+ options = append(options, "fstype", "nullfs", "target", device)
+ } else {
+ options = append(options, "fstype", mType, "from", device)
+ }
+ rawOptions := allocateIOVecs(options)
+ for _, rawOption := range rawOptions {
+ defer C.free(rawOption.iov_base)
+ }
+
+ if errno := C.nmount(&rawOptions[0], C.uint(len(options)), C.int(flag)); errno != 0 {
+ reason := C.GoString(C.strerror(*C.__error()))
+ return fmt.Errorf("Failed to call nmount: %s", reason)
+ }
+ return nil
+}
+
+func unmount(target string, flag int) error {
+ return syscall.Unmount(target, flag)
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mounter_linux.go b/vendor/github.com/docker/docker/pkg/mount/mounter_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd4280c7778626251ca049f66d18e4d8409ebda2
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mounter_linux.go
@@ -0,0 +1,21 @@
+package mount
+
+import (
+ "syscall"
+)
+
+func mount(device, target, mType string, flag uintptr, data string) error {
+ if err := syscall.Mount(device, target, mType, flag, data); err != nil {
+ return err
+ }
+
+ // If we have a bind mount or remount, remount...
+ if flag&syscall.MS_BIND == syscall.MS_BIND && flag&syscall.MS_RDONLY == syscall.MS_RDONLY {
+ return syscall.Mount(device, target, mType, flag|syscall.MS_REMOUNT, data)
+ }
+ return nil
+}
+
+func unmount(target string, flag int) error {
+ return syscall.Unmount(target, flag)
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mounter_unsupported.go b/vendor/github.com/docker/docker/pkg/mount/mounter_unsupported.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb93365eb74311e59439b44c302594448dc19075
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mounter_unsupported.go
@@ -0,0 +1,11 @@
+// +build !linux,!freebsd freebsd,!cgo
+
+package mount
+
+func mount(device, target, mType string, flag uintptr, data string) error {
+ panic("Not implemented")
+}
+
+func unmount(target string, flag int) error {
+ panic("Not implemented")
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mountinfo.go b/vendor/github.com/docker/docker/pkg/mount/mountinfo.go
new file mode 100644
index 0000000000000000000000000000000000000000..e3fc3535e934f37f00d4f22db5f954fccc65397f
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mountinfo.go
@@ -0,0 +1,40 @@
+package mount
+
+// Info reveals information about a particular mounted filesystem. This
+// struct is populated from the content in the /proc/<pid>/mountinfo file.
+type Info struct {
+ // ID is a unique identifier of the mount (may be reused after umount).
+ ID int
+
+ // Parent indicates the ID of the mount parent (or of self for the top of the
+ // mount tree).
+ Parent int
+
+ // Major indicates one half of the device ID which identifies the device class.
+ Major int
+
+ // Minor indicates one half of the device ID which identifies a specific
+ // instance of device.
+ Minor int
+
+ // Root of the mount within the filesystem.
+ Root string
+
+ // Mountpoint indicates the mount point relative to the process's root.
+ Mountpoint string
+
+ // Opts represents mount-specific options.
+ Opts string
+
+ // Optional represents optional fields.
+ Optional string
+
+ // Fstype indicates the type of filesystem, such as EXT3.
+ Fstype string
+
+ // Source indicates filesystem specific information or "none".
+ Source string
+
+ // VfsOpts represents per super block options.
+ VfsOpts string
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mountinfo_freebsd.go b/vendor/github.com/docker/docker/pkg/mount/mountinfo_freebsd.go
new file mode 100644
index 0000000000000000000000000000000000000000..4f32edcd906adda8167e746d4ed762ff61a487c6
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mountinfo_freebsd.go
@@ -0,0 +1,41 @@
+package mount
+
+/*
+#include <sys/param.h>
+#include <sys/ucred.h>
+#include <sys/mount.h>
+*/
+import "C"
+
+import (
+ "fmt"
+ "reflect"
+ "unsafe"
+)
+
+// Parse /proc/self/mountinfo because comparing Dev and ino does not work from
+// bind mounts.
+func parseMountTable() ([]*Info, error) {
+ var rawEntries *C.struct_statfs
+
+ count := int(C.getmntinfo(&rawEntries, C.MNT_WAIT))
+ if count == 0 {
+ return nil, fmt.Errorf("Failed to call getmntinfo")
+ }
+
+ var entries []C.struct_statfs
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&entries))
+ header.Cap = count
+ header.Len = count
+ header.Data = uintptr(unsafe.Pointer(rawEntries))
+
+ var out []*Info
+ for _, entry := range entries {
+ var mountinfo Info
+ mountinfo.Mountpoint = C.GoString(&entry.f_mntonname[0])
+ mountinfo.Source = C.GoString(&entry.f_mntfromname[0])
+ mountinfo.Fstype = C.GoString(&entry.f_fstypename[0])
+ out = append(out, &mountinfo)
+ }
+ return out, nil
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mountinfo_linux.go b/vendor/github.com/docker/docker/pkg/mount/mountinfo_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..be69fee1d7bbf0383ae1c1dd6564652e1cfaa818
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mountinfo_linux.go
@@ -0,0 +1,95 @@
+// +build linux
+
+package mount
+
+import (
+ "bufio"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+)
+
+const (
+ /* 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
+ (1)(2)(3) (4) (5) (6) (7) (8) (9) (10) (11)
+
+ (1) mount ID: unique identifier of the mount (may be reused after umount)
+ (2) parent ID: ID of parent (or of self for the top of the mount tree)
+ (3) major:minor: value of st_dev for files on filesystem
+ (4) root: root of the mount within the filesystem
+ (5) mount point: mount point relative to the process's root
+ (6) mount options: per mount options
+ (7) optional fields: zero or more fields of the form "tag[:value]"
+ (8) separator: marks the end of the optional fields
+ (9) filesystem type: name of filesystem of the form "type[.subtype]"
+ (10) mount source: filesystem specific information or "none"
+ (11) super options: per super block options*/
+ mountinfoFormat = "%d %d %d:%d %s %s %s %s"
+)
+
+// Parse /proc/self/mountinfo because comparing Dev and ino does not work from
+// bind mounts
+func parseMountTable() ([]*Info, error) {
+ f, err := os.Open("/proc/self/mountinfo")
+ if err != nil {
+ return nil, err
+ }
+ defer f.Close()
+
+ return parseInfoFile(f)
+}
+
+func parseInfoFile(r io.Reader) ([]*Info, error) {
+ var (
+ s = bufio.NewScanner(r)
+ out = []*Info{}
+ )
+
+ for s.Scan() {
+ if err := s.Err(); err != nil {
+ return nil, err
+ }
+
+ var (
+ p = &Info{}
+ text = s.Text()
+ optionalFields string
+ )
+
+ if _, err := fmt.Sscanf(text, mountinfoFormat,
+ &p.ID, &p.Parent, &p.Major, &p.Minor,
+ &p.Root, &p.Mountpoint, &p.Opts, &optionalFields); err != nil {
+ return nil, fmt.Errorf("Scanning '%s' failed: %s", text, err)
+ }
+ // Safe as mountinfo encodes mountpoints with spaces as \040.
+ index := strings.Index(text, " - ")
+ postSeparatorFields := strings.Fields(text[index+3:])
+ if len(postSeparatorFields) < 3 {
+ return nil, fmt.Errorf("Error found less than 3 fields post '-' in %q", text)
+ }
+
+ if optionalFields != "-" {
+ p.Optional = optionalFields
+ }
+
+ p.Fstype = postSeparatorFields[0]
+ p.Source = postSeparatorFields[1]
+ p.VfsOpts = strings.Join(postSeparatorFields[2:], " ")
+ out = append(out, p)
+ }
+ return out, nil
+}
+
+// PidMountInfo collects the mounts for a specific process ID. If the process
+// ID is unknown, it is better to use `GetMounts` which will inspect
+// "/proc/self/mountinfo" instead.
+func PidMountInfo(pid int) ([]*Info, error) {
+ f, err := os.Open(fmt.Sprintf("/proc/%d/mountinfo", pid))
+ if err != nil {
+ return nil, err
+ }
+ defer f.Close()
+
+ return parseInfoFile(f)
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/mountinfo_unsupported.go b/vendor/github.com/docker/docker/pkg/mount/mountinfo_unsupported.go
new file mode 100644
index 0000000000000000000000000000000000000000..8245f01d42bc2b5c36c270d219c30b6aa338ea39
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/mountinfo_unsupported.go
@@ -0,0 +1,12 @@
+// +build !linux,!freebsd freebsd,!cgo
+
+package mount
+
+import (
+ "fmt"
+ "runtime"
+)
+
+func parseMountTable() ([]*Info, error) {
+ return nil, fmt.Errorf("mount.parseMountTable is not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/vendor/github.com/docker/docker/pkg/mount/sharedsubtree_linux.go b/vendor/github.com/docker/docker/pkg/mount/sharedsubtree_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..47303bbcb610da9a5a4be65196a9551459ab6176
--- /dev/null
+++ b/vendor/github.com/docker/docker/pkg/mount/sharedsubtree_linux.go
@@ -0,0 +1,70 @@
+// +build linux
+
+package mount
+
+// MakeShared ensures a mounted filesystem has the SHARED mount option enabled.
+// See the supported options in flags.go for further reference.
+func MakeShared(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "shared")
+}
+
+// MakeRShared ensures a mounted filesystem has the RSHARED mount option enabled.
+// See the supported options in flags.go for further reference.
+func MakeRShared(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "rshared")
+}
+
+// MakePrivate ensures a mounted filesystem has the PRIVATE mount option enabled.
+// See the supported options in flags.go for further reference.
+func MakePrivate(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "private")
+}
+
+// MakeRPrivate ensures a mounted filesystem has the RPRIVATE mount option
+// enabled. See the supported options in flags.go for further reference.
+func MakeRPrivate(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "rprivate")
+}
+
+// MakeSlave ensures a mounted filesystem has the SLAVE mount option enabled.
+// See the supported options in flags.go for further reference.
+func MakeSlave(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "slave")
+}
+
+// MakeRSlave ensures a mounted filesystem has the RSLAVE mount option enabled.
+// See the supported options in flags.go for further reference.
+func MakeRSlave(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "rslave")
+}
+
+// MakeUnbindable ensures a mounted filesystem has the UNBINDABLE mount option
+// enabled. See the supported options in flags.go for further reference.
+func MakeUnbindable(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "unbindable")
+}
+
+// MakeRUnbindable ensures a mounted filesystem has the RUNBINDABLE mount
+// option enabled. See the supported options in flags.go for further reference.
+func MakeRUnbindable(mountPoint string) error {
+ return ensureMountedAs(mountPoint, "runbindable")
+}
+
+func ensureMountedAs(mountPoint, options string) error {
+ mounted, err := Mounted(mountPoint)
+ if err != nil {
+ return err
+ }
+
+ if !mounted {
+ if err := Mount(mountPoint, mountPoint, "none", "bind,rw"); err != nil {
+ return err
+ }
+ }
+ mounted, err = Mounted(mountPoint)
+ if err != nil {
+ return err
+ }
+
+ return ForceMount("", mountPoint, "none", options)
+}
diff --git a/Godeps/_workspace/src/github.com/docker/docker/LICENSE b/vendor/github.com/docker/engine-api/LICENSE
similarity index 99%
rename from Godeps/_workspace/src/github.com/docker/docker/LICENSE
rename to vendor/github.com/docker/engine-api/LICENSE
index c7a3f0cfd4562c0a99091050ae17a33878af9d20..c157bff96a05ad41cdadc830e24aaf1bec2fcc57 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/LICENSE
+++ b/vendor/github.com/docker/engine-api/LICENSE
@@ -176,7 +176,7 @@
END OF TERMS AND CONDITIONS
- Copyright 2013-2015 Docker, Inc.
+ Copyright 2015-2016 Docker, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
diff --git a/vendor/github.com/docker/engine-api/types/auth.go b/vendor/github.com/docker/engine-api/types/auth.go
new file mode 100644
index 0000000000000000000000000000000000000000..056af6b842595184bc61e858ac57883b39aaf522
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/auth.go
@@ -0,0 +1,22 @@
+package types
+
+// AuthConfig contains authorization information for connecting to a Registry
+type AuthConfig struct {
+ Username string `json:"username,omitempty"`
+ Password string `json:"password,omitempty"`
+ Auth string `json:"auth,omitempty"`
+
+ // Email is an optional value associated with the username.
+ // This field is deprecated and will be removed in a later
+ // version of docker.
+ Email string `json:"email,omitempty"`
+
+ ServerAddress string `json:"serveraddress,omitempty"`
+
+ // IdentityToken is used to authenticate the user and get
+ // an access token for the registry.
+ IdentityToken string `json:"identitytoken,omitempty"`
+
+ // RegistryToken is a bearer token to be sent to a registry
+ RegistryToken string `json:"registrytoken,omitempty"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/blkiodev/blkio.go b/vendor/github.com/docker/engine-api/types/blkiodev/blkio.go
new file mode 100644
index 0000000000000000000000000000000000000000..931ae10ab1efa6450aa22e6b132fcbfcf51fa80f
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/blkiodev/blkio.go
@@ -0,0 +1,23 @@
+package blkiodev
+
+import "fmt"
+
+// WeightDevice is a structure that holds device:weight pair
+type WeightDevice struct {
+ Path string
+ Weight uint16
+}
+
+func (w *WeightDevice) String() string {
+ return fmt.Sprintf("%s:%d", w.Path, w.Weight)
+}
+
+// ThrottleDevice is a structure that holds device:rate_per_second pair
+type ThrottleDevice struct {
+ Path string
+ Rate uint64
+}
+
+func (t *ThrottleDevice) String() string {
+ return fmt.Sprintf("%s:%d", t.Path, t.Rate)
+}
diff --git a/vendor/github.com/docker/engine-api/types/client.go b/vendor/github.com/docker/engine-api/types/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..b9245b0956ce78323498fbe11116a56deea06ced
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/client.go
@@ -0,0 +1,300 @@
+package types
+
+import (
+ "bufio"
+ "io"
+ "net"
+
+ "github.com/docker/engine-api/types/container"
+ "github.com/docker/engine-api/types/filters"
+ "github.com/docker/go-units"
+)
+
+// CheckpointCreateOptions holds parameters to create a checkpoint from a container
+type CheckpointCreateOptions struct {
+ CheckpointID string
+ Exit bool
+}
+
+// ContainerAttachOptions holds parameters to attach to a container.
+type ContainerAttachOptions struct {
+ Stream bool
+ Stdin bool
+ Stdout bool
+ Stderr bool
+ DetachKeys string
+}
+
+// ContainerCommitOptions holds parameters to commit changes into a container.
+type ContainerCommitOptions struct {
+ Reference string
+ Comment string
+ Author string
+ Changes []string
+ Pause bool
+ Config *container.Config
+}
+
+// ContainerExecInspect holds information returned by exec inspect.
+type ContainerExecInspect struct {
+ ExecID string
+ ContainerID string
+ Running bool
+ ExitCode int
+}
+
+// ContainerListOptions holds parameters to list containers with.
+type ContainerListOptions struct {
+ Quiet bool
+ Size bool
+ All bool
+ Latest bool
+ Since string
+ Before string
+ Limit int
+ Filter filters.Args
+}
+
+// ContainerLogsOptions holds parameters to filter logs with.
+type ContainerLogsOptions struct {
+ ShowStdout bool
+ ShowStderr bool
+ Since string
+ Timestamps bool
+ Follow bool
+ Tail string
+ Details bool
+}
+
+// ContainerRemoveOptions holds parameters to remove containers.
+type ContainerRemoveOptions struct {
+ RemoveVolumes bool
+ RemoveLinks bool
+ Force bool
+}
+
+// ContainerStartOptions holds parameters to start containers.
+type ContainerStartOptions struct {
+ CheckpointID string
+}
+
+// CopyToContainerOptions holds information
+// about files to copy into a container
+type CopyToContainerOptions struct {
+ AllowOverwriteDirWithFile bool
+}
+
+// EventsOptions hold parameters to filter events with.
+type EventsOptions struct {
+ Since string
+ Until string
+ Filters filters.Args
+}
+
+// NetworkListOptions holds parameters to filter the list of networks with.
+type NetworkListOptions struct {
+ Filters filters.Args
+}
+
+// HijackedResponse holds connection information for a hijacked request.
+type HijackedResponse struct {
+ Conn net.Conn
+ Reader *bufio.Reader
+}
+
+// Close closes the hijacked connection and reader.
+func (h *HijackedResponse) Close() {
+ h.Conn.Close()
+}
+
+// CloseWriter is an interface that implements structs
+// that close input streams to prevent from writing.
+type CloseWriter interface {
+ CloseWrite() error
+}
+
+// CloseWrite closes a readWriter for writing.
+func (h *HijackedResponse) CloseWrite() error {
+ if conn, ok := h.Conn.(CloseWriter); ok {
+ return conn.CloseWrite()
+ }
+ return nil
+}
+
+// ImageBuildOptions holds the information
+// necessary to build images.
+type ImageBuildOptions struct {
+ Tags []string
+ SuppressOutput bool
+ RemoteContext string
+ NoCache bool
+ Remove bool
+ ForceRemove bool
+ PullParent bool
+ Isolation container.Isolation
+ CPUSetCPUs string
+ CPUSetMems string
+ CPUShares int64
+ CPUQuota int64
+ CPUPeriod int64
+ Memory int64
+ MemorySwap int64
+ CgroupParent string
+ ShmSize int64
+ Dockerfile string
+ Ulimits []*units.Ulimit
+ BuildArgs map[string]string
+ AuthConfigs map[string]AuthConfig
+ Context io.Reader
+ Labels map[string]string
+ // squash the resulting image's layers to the parent
+ // preserves the original image and creates a new one from the parent with all
+ // the changes applied to a single layer
+ Squash bool
+}
+
+// ImageBuildResponse holds information
+// returned by a server after building
+// an image.
+type ImageBuildResponse struct {
+ Body io.ReadCloser
+ OSType string
+}
+
+// ImageCreateOptions holds information to create images.
+type ImageCreateOptions struct {
+ RegistryAuth string // RegistryAuth is the base64 encoded credentials for the registry
+}
+
+// ImageImportSource holds source information for ImageImport
+type ImageImportSource struct {
+ Source io.Reader // Source is the data to send to the server to create this image from (mutually exclusive with SourceName)
+ SourceName string // SourceName is the name of the image to pull (mutually exclusive with Source)
+}
+
+// ImageImportOptions holds information to import images from the client host.
+type ImageImportOptions struct {
+ Tag string // Tag is the name to tag this image with. This attribute is deprecated.
+ Message string // Message is the message to tag the image with
+ Changes []string // Changes are the raw changes to apply to this image
+}
+
+// ImageListOptions holds parameters to filter the list of images with.
+type ImageListOptions struct {
+ MatchName string
+ All bool
+ Filters filters.Args
+}
+
+// ImageLoadResponse returns information to the client about a load process.
+type ImageLoadResponse struct {
+ // Body must be closed to avoid a resource leak
+ Body io.ReadCloser
+ JSON bool
+}
+
+// ImagePullOptions holds information to pull images.
+type ImagePullOptions struct {
+ All bool
+ RegistryAuth string // RegistryAuth is the base64 encoded credentials for the registry
+ PrivilegeFunc RequestPrivilegeFunc
+}
+
+// RequestPrivilegeFunc is a function interface that
+// clients can supply to retry operations after
+// getting an authorization error.
+// This function returns the registry authentication
+// header value in base 64 format, or an error
+// if the privilege request fails.
+type RequestPrivilegeFunc func() (string, error)
+
+//ImagePushOptions holds information to push images.
+type ImagePushOptions ImagePullOptions
+
+// ImageRemoveOptions holds parameters to remove images.
+type ImageRemoveOptions struct {
+ Force bool
+ PruneChildren bool
+}
+
+// ImageSearchOptions holds parameters to search images with.
+type ImageSearchOptions struct {
+ RegistryAuth string
+ PrivilegeFunc RequestPrivilegeFunc
+ Filters filters.Args
+ Limit int
+}
+
+// ResizeOptions holds parameters to resize a tty.
+// It can be used to resize container ttys and
+// exec process ttys too.
+type ResizeOptions struct {
+ Height int
+ Width int
+}
+
+// VersionResponse holds version information for the client and the server
+type VersionResponse struct {
+ Client *Version
+ Server *Version
+}
+
+// ServerOK returns true when the client could connect to the docker server
+// and parse the information received. It returns false otherwise.
+func (v VersionResponse) ServerOK() bool {
+ return v.Server != nil
+}
+
+// NodeListOptions holds parameters to list nodes with.
+type NodeListOptions struct {
+ Filter filters.Args
+}
+
+// NodeRemoveOptions holds parameters to remove nodes with.
+type NodeRemoveOptions struct {
+ Force bool
+}
+
+// ServiceCreateOptions contains the options to use when creating a service.
+type ServiceCreateOptions struct {
+ // EncodedRegistryAuth is the encoded registry authorization credentials to
+ // use when updating the service.
+ //
+ // This field follows the format of the X-Registry-Auth header.
+ EncodedRegistryAuth string
+}
+
+// ServiceCreateResponse contains the information returned to a client
+// on the creation of a new service.
+type ServiceCreateResponse struct {
+ // ID is the ID of the created service.
+ ID string
+}
+
+// ServiceUpdateOptions contains the options to be used for updating services.
+type ServiceUpdateOptions struct {
+ // EncodedRegistryAuth is the encoded registry authorization credentials to
+ // use when updating the service.
+ //
+ // This field follows the format of the X-Registry-Auth header.
+ EncodedRegistryAuth string
+
+ // TODO(stevvooe): Consider moving the version parameter of ServiceUpdate
+ // into this field. While it does open API users up to racy writes, most
+ // users may not need that level of consistency in practice.
+}
+
+// ServiceListOptions holds parameters to list services with.
+type ServiceListOptions struct {
+ Filter filters.Args
+}
+
+// TaskListOptions holds parameters to list tasks with.
+type TaskListOptions struct {
+ Filter filters.Args
+}
+
+// PluginRemoveOptions holds parameters to remove plugins.
+type PluginRemoveOptions struct {
+ Force bool
+}
diff --git a/vendor/github.com/docker/engine-api/types/configs.go b/vendor/github.com/docker/engine-api/types/configs.go
new file mode 100644
index 0000000000000000000000000000000000000000..13e73cb9bdcd6d191d5414ea7e056894e54a8ba7
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/configs.go
@@ -0,0 +1,60 @@
+package types
+
+import (
+ "github.com/docker/engine-api/types/container"
+ "github.com/docker/engine-api/types/network"
+)
+
+// configs holds structs used for internal communication between the
+// frontend (such as an http server) and the backend (such as the
+// docker daemon).
+
+// ContainerCreateConfig is the parameter set to ContainerCreate()
+type ContainerCreateConfig struct {
+ Name string
+ Config *container.Config
+ HostConfig *container.HostConfig
+ NetworkingConfig *network.NetworkingConfig
+ AdjustCPUShares bool
+}
+
+// ContainerRmConfig holds arguments for the container remove
+// operation. This struct is used to tell the backend what operations
+// to perform.
+type ContainerRmConfig struct {
+ ForceRemove, RemoveVolume, RemoveLink bool
+}
+
+// ContainerCommitConfig contains build configs for commit operation,
+// and is used when making a commit with the current state of the container.
+type ContainerCommitConfig struct {
+ Pause bool
+ Repo string
+ Tag string
+ Author string
+ Comment string
+ // merge container config into commit config before commit
+ MergeConfigs bool
+ Config *container.Config
+}
+
+// ExecConfig is a small subset of the Config struct that holds the configuration
+// for the exec feature of docker.
+type ExecConfig struct {
+ User string // User that will run the command
+ Privileged bool // Is the container in privileged mode
+ Tty bool // Attach standard streams to a tty.
+ AttachStdin bool // Attach the standard input, makes possible user interaction
+ AttachStderr bool // Attach the standard error
+ AttachStdout bool // Attach the standard output
+ Detach bool // Execute in detach mode
+ DetachKeys string // Escape keys for detach
+ Cmd []string // Execution commands and args
+}
+
+// PluginRmConfig holds arguments for the plugin remove
+// operation. This struct is used to tell the backend what operations
+// to perform.
+type PluginRmConfig struct {
+ ForceRemove bool
+}
diff --git a/vendor/github.com/docker/engine-api/types/container/config.go b/vendor/github.com/docker/engine-api/types/container/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..e300e119e7ff71ecae6ee6ce05f31c2661f2b82d
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/container/config.go
@@ -0,0 +1,62 @@
+package container
+
+import (
+ "time"
+
+ "github.com/docker/engine-api/types/strslice"
+ "github.com/docker/go-connections/nat"
+)
+
+// HealthConfig holds configuration settings for the HEALTHCHECK feature.
+type HealthConfig struct {
+ // Test is the test to perform to check that the container is healthy.
+ // An empty slice means to inherit the default.
+ // The options are:
+ // {} : inherit healthcheck
+ // {"NONE"} : disable healthcheck
+ // {"CMD", args...} : exec arguments directly
+ // {"CMD-SHELL", command} : run command with system's default shell
+ Test []string `json:",omitempty"`
+
+ // Zero means to inherit. Durations are expressed as integer nanoseconds.
+ Interval time.Duration `json:",omitempty"` // Interval is the time to wait between checks.
+ Timeout time.Duration `json:",omitempty"` // Timeout is the time to wait before considering the check to have hung.
+
+ // Retries is the number of consecutive failures needed to consider a container as unhealthy.
+ // Zero means inherit.
+ Retries int `json:",omitempty"`
+}
+
+// Config contains the configuration data about a container.
+// It should hold only portable information about the container.
+// Here, "portable" means "independent from the host we are running on".
+// Non-portable information *should* appear in HostConfig.
+// All fields added to this struct must be marked `omitempty` to keep getting
+// predictable hashes from the old `v1Compatibility` configuration.
+type Config struct {
+ Hostname string // Hostname
+ Domainname string // Domainname
+ User string // User that will run the command(s) inside the container, also support user:group
+ AttachStdin bool // Attach the standard input, makes possible user interaction
+ AttachStdout bool // Attach the standard output
+ AttachStderr bool // Attach the standard error
+ ExposedPorts map[nat.Port]struct{} `json:",omitempty"` // List of exposed ports
+ Tty bool // Attach standard streams to a tty, including stdin if it is not closed.
+ OpenStdin bool // Open stdin
+ StdinOnce bool // If true, close stdin after the 1 attached client disconnects.
+ Env []string // List of environment variable to set in the container
+ Cmd strslice.StrSlice // Command to run when starting the container
+ Healthcheck *HealthConfig `json:",omitempty"` // Healthcheck describes how to check the container is healthy
+ ArgsEscaped bool `json:",omitempty"` // True if command is already escaped (Windows specific)
+ Image string // Name of the image as it was passed by the operator (eg. could be symbolic)
+ Volumes map[string]struct{} // List of volumes (mounts) used for the container
+ WorkingDir string // Current directory (PWD) in the command will be launched
+ Entrypoint strslice.StrSlice // Entrypoint to run when starting the container
+ NetworkDisabled bool `json:",omitempty"` // Is network disabled
+ MacAddress string `json:",omitempty"` // Mac Address of the container
+ OnBuild []string // ONBUILD metadata that were defined on the image Dockerfile
+ Labels map[string]string // List of labels set to this container
+ StopSignal string `json:",omitempty"` // Signal to stop a container
+ StopTimeout *int `json:",omitempty"` // Timeout (in seconds) to stop a container
+ Shell strslice.StrSlice `json:",omitempty"` // Shell for shell-form of RUN, CMD, ENTRYPOINT
+}
diff --git a/vendor/github.com/docker/engine-api/types/container/host_config.go b/vendor/github.com/docker/engine-api/types/container/host_config.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a4069ac6bc9bb8003407bdbd71f14f477b1540c
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/container/host_config.go
@@ -0,0 +1,324 @@
+package container
+
+import (
+ "strings"
+
+ "github.com/docker/engine-api/types/blkiodev"
+ "github.com/docker/engine-api/types/mount"
+ "github.com/docker/engine-api/types/strslice"
+ "github.com/docker/go-connections/nat"
+ "github.com/docker/go-units"
+)
+
+// NetworkMode represents the container network stack.
+type NetworkMode string
+
+// Isolation represents the isolation technology of a container. The supported
+// values are platform specific
+type Isolation string
+
+// IsDefault indicates the default isolation technology of a container. On Linux this
+// is the native driver. On Windows, this is a Windows Server Container.
+func (i Isolation) IsDefault() bool {
+ return strings.ToLower(string(i)) == "default" || string(i) == ""
+}
+
+// IpcMode represents the container ipc stack.
+type IpcMode string
+
+// IsPrivate indicates whether the container uses its private ipc stack.
+func (n IpcMode) IsPrivate() bool {
+ return !(n.IsHost() || n.IsContainer())
+}
+
+// IsHost indicates whether the container uses the host's ipc stack.
+func (n IpcMode) IsHost() bool {
+ return n == "host"
+}
+
+// IsContainer indicates whether the container uses a container's ipc stack.
+func (n IpcMode) IsContainer() bool {
+ parts := strings.SplitN(string(n), ":", 2)
+ return len(parts) > 1 && parts[0] == "container"
+}
+
+// Valid indicates whether the ipc stack is valid.
+func (n IpcMode) Valid() bool {
+ parts := strings.Split(string(n), ":")
+ switch mode := parts[0]; mode {
+ case "", "host":
+ case "container":
+ if len(parts) != 2 || parts[1] == "" {
+ return false
+ }
+ default:
+ return false
+ }
+ return true
+}
+
+// Container returns the name of the container ipc stack is going to be used.
+func (n IpcMode) Container() string {
+ parts := strings.SplitN(string(n), ":", 2)
+ if len(parts) > 1 {
+ return parts[1]
+ }
+ return ""
+}
+
+// UsernsMode represents userns mode in the container.
+type UsernsMode string
+
+// IsHost indicates whether the container uses the host's userns.
+func (n UsernsMode) IsHost() bool {
+ return n == "host"
+}
+
+// IsPrivate indicates whether the container uses the a private userns.
+func (n UsernsMode) IsPrivate() bool {
+ return !(n.IsHost())
+}
+
+// Valid indicates whether the userns is valid.
+func (n UsernsMode) Valid() bool {
+ parts := strings.Split(string(n), ":")
+ switch mode := parts[0]; mode {
+ case "", "host":
+ default:
+ return false
+ }
+ return true
+}
+
+// CgroupSpec represents the cgroup to use for the container.
+type CgroupSpec string
+
+// IsContainer indicates whether the container is using another container cgroup
+func (c CgroupSpec) IsContainer() bool {
+ parts := strings.SplitN(string(c), ":", 2)
+ return len(parts) > 1 && parts[0] == "container"
+}
+
+// Valid indicates whether the cgroup spec is valid.
+func (c CgroupSpec) Valid() bool {
+ return c.IsContainer() || c == ""
+}
+
+// Container returns the name of the container whose cgroup will be used.
+func (c CgroupSpec) Container() string {
+ parts := strings.SplitN(string(c), ":", 2)
+ if len(parts) > 1 {
+ return parts[1]
+ }
+ return ""
+}
+
+// UTSMode represents the UTS namespace of the container.
+type UTSMode string
+
+// IsPrivate indicates whether the container uses its private UTS namespace.
+func (n UTSMode) IsPrivate() bool {
+ return !(n.IsHost())
+}
+
+// IsHost indicates whether the container uses the host's UTS namespace.
+func (n UTSMode) IsHost() bool {
+ return n == "host"
+}
+
+// Valid indicates whether the UTS namespace is valid.
+func (n UTSMode) Valid() bool {
+ parts := strings.Split(string(n), ":")
+ switch mode := parts[0]; mode {
+ case "", "host":
+ default:
+ return false
+ }
+ return true
+}
+
+// PidMode represents the pid namespace of the container.
+type PidMode string
+
+// IsPrivate indicates whether the container uses its own new pid namespace.
+func (n PidMode) IsPrivate() bool {
+ return !(n.IsHost() || n.IsContainer())
+}
+
+// IsHost indicates whether the container uses the host's pid namespace.
+func (n PidMode) IsHost() bool {
+ return n == "host"
+}
+
+// IsContainer indicates whether the container uses a container's pid namespace.
+func (n PidMode) IsContainer() bool {
+ parts := strings.SplitN(string(n), ":", 2)
+ return len(parts) > 1 && parts[0] == "container"
+}
+
+// Valid indicates whether the pid namespace is valid.
+func (n PidMode) Valid() bool {
+ parts := strings.Split(string(n), ":")
+ switch mode := parts[0]; mode {
+ case "", "host":
+ case "container":
+ if len(parts) != 2 || parts[1] == "" {
+ return false
+ }
+ default:
+ return false
+ }
+ return true
+}
+
+// Container returns the name of the container whose pid namespace is going to be used.
+func (n PidMode) Container() string {
+ parts := strings.SplitN(string(n), ":", 2)
+ if len(parts) > 1 {
+ return parts[1]
+ }
+ return ""
+}
+
+// DeviceMapping represents the device mapping between the host and the container.
+type DeviceMapping struct {
+ PathOnHost string
+ PathInContainer string
+ CgroupPermissions string
+}
+
+// RestartPolicy represents the restart policies of the container.
+type RestartPolicy struct {
+ Name string
+ MaximumRetryCount int
+}
+
+// IsNone indicates whether the container has the "no" restart policy.
+// This means the container will not automatically restart when exiting.
+func (rp *RestartPolicy) IsNone() bool {
+ return rp.Name == "no" || rp.Name == ""
+}
+
+// IsAlways indicates whether the container has the "always" restart policy.
+// This means the container will automatically restart regardless of the exit status.
+func (rp *RestartPolicy) IsAlways() bool {
+ return rp.Name == "always"
+}
+
+// IsOnFailure indicates whether the container has the "on-failure" restart policy.
+// This means the container will automatically restart of exiting with a non-zero exit status.
+func (rp *RestartPolicy) IsOnFailure() bool {
+ return rp.Name == "on-failure"
+}
+
+// IsUnlessStopped indicates whether the container has the
+// "unless-stopped" restart policy. This means the container will
+// automatically restart unless user has put it to stopped state.
+func (rp *RestartPolicy) IsUnlessStopped() bool {
+ return rp.Name == "unless-stopped"
+}
+
+// IsSame compares two RestartPolicy to see if they are the same
+func (rp *RestartPolicy) IsSame(tp *RestartPolicy) bool {
+ return rp.Name == tp.Name && rp.MaximumRetryCount == tp.MaximumRetryCount
+}
+
+// LogConfig represents the logging configuration of the container.
+type LogConfig struct {
+ Type string
+ Config map[string]string
+}
+
+// Resources contains container's resources (cgroups config, ulimits...)
+type Resources struct {
+ // Applicable to all platforms
+ CPUShares int64 `json:"CpuShares"` // CPU shares (relative weight vs. other containers)
+ Memory int64 // Memory limit (in bytes)
+
+ // Applicable to UNIX platforms
+ CgroupParent string // Parent cgroup.
+ BlkioWeight uint16 // Block IO weight (relative weight vs. other containers)
+ BlkioWeightDevice []*blkiodev.WeightDevice
+ BlkioDeviceReadBps []*blkiodev.ThrottleDevice
+ BlkioDeviceWriteBps []*blkiodev.ThrottleDevice
+ BlkioDeviceReadIOps []*blkiodev.ThrottleDevice
+ BlkioDeviceWriteIOps []*blkiodev.ThrottleDevice
+ CPUPeriod int64 `json:"CpuPeriod"` // CPU CFS (Completely Fair Scheduler) period
+ CPUQuota int64 `json:"CpuQuota"` // CPU CFS (Completely Fair Scheduler) quota
+ CpusetCpus string // CpusetCpus 0-2, 0,1
+ CpusetMems string // CpusetMems 0-2, 0,1
+ Devices []DeviceMapping // List of devices to map inside the container
+ DiskQuota int64 // Disk limit (in bytes)
+ KernelMemory int64 // Kernel memory limit (in bytes)
+ MemoryReservation int64 // Memory soft limit (in bytes)
+ MemorySwap int64 // Total memory usage (memory + swap); set `-1` to enable unlimited swap
+ MemorySwappiness *int64 // Tuning container memory swappiness behaviour
+ OomKillDisable *bool // Whether to disable OOM Killer or not
+ PidsLimit int64 // Setting pids limit for a container
+ Ulimits []*units.Ulimit // List of ulimits to be set in the container
+
+ // Applicable to Windows
+ CPUCount int64 `json:"CpuCount"` // CPU count
+ CPUPercent int64 `json:"CpuPercent"` // CPU percent
+ IOMaximumIOps uint64 // Maximum IOps for the container system drive
+ IOMaximumBandwidth uint64 // Maximum IO in bytes per second for the container system drive
+}
+
+// UpdateConfig holds the mutable attributes of a Container.
+// Those attributes can be updated at runtime.
+type UpdateConfig struct {
+ // Contains container's resources (cgroups, ulimits)
+ Resources
+ RestartPolicy RestartPolicy
+}
+
+// HostConfig the non-portable Config structure of a container.
+// Here, "non-portable" means "dependent of the host we are running on".
+// Portable information *should* appear in Config.
+type HostConfig struct {
+ // Applicable to all platforms
+ Binds []string // List of volume bindings for this container
+ ContainerIDFile string // File (path) where the containerId is written
+ LogConfig LogConfig // Configuration of the logs for this container
+ NetworkMode NetworkMode // Network mode to use for the container
+ PortBindings nat.PortMap // Port mapping between the exposed port (container) and the host
+ RestartPolicy RestartPolicy // Restart policy to be used for the container
+ AutoRemove bool // Automatically remove container when it exits
+ VolumeDriver string // Name of the volume driver used to mount volumes
+ VolumesFrom []string // List of volumes to take from other container
+
+ // Applicable to UNIX platforms
+ CapAdd strslice.StrSlice // List of kernel capabilities to add to the container
+ CapDrop strslice.StrSlice // List of kernel capabilities to remove from the container
+ DNS []string `json:"Dns"` // List of DNS server to lookup
+ DNSOptions []string `json:"DnsOptions"` // List of DNSOption to look for
+ DNSSearch []string `json:"DnsSearch"` // List of DNSSearch to look for
+ ExtraHosts []string // List of extra hosts
+ GroupAdd []string // List of additional groups that the container process will run as
+ IpcMode IpcMode // IPC namespace to use for the container
+ Cgroup CgroupSpec // Cgroup to use for the container
+ Links []string // List of links (in the name:alias form)
+ OomScoreAdj int // Container preference for OOM-killing
+ PidMode PidMode // PID namespace to use for the container
+ Privileged bool // Is the container in privileged mode
+ PublishAllPorts bool // Should docker publish all exposed port for the container
+ ReadonlyRootfs bool // Is the container root filesystem in read-only
+ SecurityOpt []string // List of string values to customize labels for MLS systems, such as SELinux.
+ StorageOpt map[string]string `json:",omitempty"` // Storage driver options per container.
+ Tmpfs map[string]string `json:",omitempty"` // List of tmpfs (mounts) used for the container
+ UTSMode UTSMode // UTS namespace to use for the container
+ UsernsMode UsernsMode // The user namespace to use for the container
+ ShmSize int64 // Total shm memory usage
+ Sysctls map[string]string `json:",omitempty"` // List of Namespaced sysctls used for the container
+ Runtime string `json:",omitempty"` // Runtime to use with this container
+
+ // Applicable to Windows
+ ConsoleSize [2]int // Initial console size
+ Isolation Isolation // Isolation technology of the container (eg default, hyperv)
+
+ // Contains container's resources (cgroups, ulimits)
+ Resources
+
+ // Mounts specs used by the container
+ Mounts []mount.Mount `json:",omitempty"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/container/hostconfig_unix.go b/vendor/github.com/docker/engine-api/types/container/hostconfig_unix.go
new file mode 100644
index 0000000000000000000000000000000000000000..4171059a476aa3fc10db10c8c16fd4c620214725
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/container/hostconfig_unix.go
@@ -0,0 +1,81 @@
+// +build !windows
+
+package container
+
+import "strings"
+
+// IsValid indicates if an isolation technology is valid
+func (i Isolation) IsValid() bool {
+ return i.IsDefault()
+}
+
+// IsPrivate indicates whether container uses it's private network stack.
+func (n NetworkMode) IsPrivate() bool {
+ return !(n.IsHost() || n.IsContainer())
+}
+
+// IsDefault indicates whether container uses the default network stack.
+func (n NetworkMode) IsDefault() bool {
+ return n == "default"
+}
+
+// NetworkName returns the name of the network stack.
+func (n NetworkMode) NetworkName() string {
+ if n.IsBridge() {
+ return "bridge"
+ } else if n.IsHost() {
+ return "host"
+ } else if n.IsContainer() {
+ return "container"
+ } else if n.IsNone() {
+ return "none"
+ } else if n.IsDefault() {
+ return "default"
+ } else if n.IsUserDefined() {
+ return n.UserDefined()
+ }
+ return ""
+}
+
+// IsBridge indicates whether container uses the bridge network stack
+func (n NetworkMode) IsBridge() bool {
+ return n == "bridge"
+}
+
+// IsHost indicates whether container uses the host network stack.
+func (n NetworkMode) IsHost() bool {
+ return n == "host"
+}
+
+// IsContainer indicates whether container uses a container network stack.
+func (n NetworkMode) IsContainer() bool {
+ parts := strings.SplitN(string(n), ":", 2)
+ return len(parts) > 1 && parts[0] == "container"
+}
+
+// IsNone indicates whether container isn't using a network stack.
+func (n NetworkMode) IsNone() bool {
+ return n == "none"
+}
+
+// ConnectedContainer is the id of the container which network this container is connected to.
+func (n NetworkMode) ConnectedContainer() string {
+ parts := strings.SplitN(string(n), ":", 2)
+ if len(parts) > 1 {
+ return parts[1]
+ }
+ return ""
+}
+
+// IsUserDefined indicates user-created network
+func (n NetworkMode) IsUserDefined() bool {
+ return !n.IsDefault() && !n.IsBridge() && !n.IsHost() && !n.IsNone() && !n.IsContainer()
+}
+
+//UserDefined indicates user-created network
+func (n NetworkMode) UserDefined() string {
+ if n.IsUserDefined() {
+ return string(n)
+ }
+ return ""
+}
diff --git a/vendor/github.com/docker/engine-api/types/container/hostconfig_windows.go b/vendor/github.com/docker/engine-api/types/container/hostconfig_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..0ee332ba689934260a3413d95ac43e9ffbe66b9e
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/container/hostconfig_windows.go
@@ -0,0 +1,87 @@
+package container
+
+import (
+ "strings"
+)
+
+// IsDefault indicates whether container uses the default network stack.
+func (n NetworkMode) IsDefault() bool {
+ return n == "default"
+}
+
+// IsNone indicates whether container isn't using a network stack.
+func (n NetworkMode) IsNone() bool {
+ return n == "none"
+}
+
+// IsContainer indicates whether container uses a container network stack.
+// Returns false as windows doesn't support this mode
+func (n NetworkMode) IsContainer() bool {
+ return false
+}
+
+// IsBridge indicates whether container uses the bridge network stack
+// in windows it is given the name NAT
+func (n NetworkMode) IsBridge() bool {
+ return n == "nat"
+}
+
+// IsHost indicates whether container uses the host network stack.
+// returns false as this is not supported by windows
+func (n NetworkMode) IsHost() bool {
+ return false
+}
+
+// IsPrivate indicates whether container uses its private network stack.
+func (n NetworkMode) IsPrivate() bool {
+ return !(n.IsHost() || n.IsContainer())
+}
+
+// ConnectedContainer is the id of the container which network this container is connected to.
+// Returns blank string on windows
+func (n NetworkMode) ConnectedContainer() string {
+ return ""
+}
+
+// IsUserDefined indicates user-created network
+func (n NetworkMode) IsUserDefined() bool {
+ return !n.IsDefault() && !n.IsNone() && !n.IsBridge()
+}
+
+// IsHyperV indicates the use of a Hyper-V partition for isolation
+func (i Isolation) IsHyperV() bool {
+ return strings.ToLower(string(i)) == "hyperv"
+}
+
+// IsProcess indicates the use of process isolation
+func (i Isolation) IsProcess() bool {
+ return strings.ToLower(string(i)) == "process"
+}
+
+// IsValid indicates if an isolation technology is valid
+func (i Isolation) IsValid() bool {
+ return i.IsDefault() || i.IsHyperV() || i.IsProcess()
+}
+
+// NetworkName returns the name of the network stack.
+func (n NetworkMode) NetworkName() string {
+ if n.IsDefault() {
+ return "default"
+ } else if n.IsBridge() {
+ return "nat"
+ } else if n.IsNone() {
+ return "none"
+ } else if n.IsUserDefined() {
+ return n.UserDefined()
+ }
+
+ return ""
+}
+
+//UserDefined indicates user-created network
+func (n NetworkMode) UserDefined() string {
+ if n.IsUserDefined() {
+ return string(n)
+ }
+ return ""
+}
diff --git a/vendor/github.com/docker/engine-api/types/errors.go b/vendor/github.com/docker/engine-api/types/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..649ab95131aa60253a5d6cb1585de9564def39f3
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/errors.go
@@ -0,0 +1,6 @@
+package types
+
+// ErrorResponse is the response body of API errors.
+type ErrorResponse struct {
+ Message string `json:"message"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/filters/parse.go b/vendor/github.com/docker/engine-api/types/filters/parse.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc2c48b89422c9e37c319f04b85a48eaa0d3f8b0
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/filters/parse.go
@@ -0,0 +1,307 @@
+// Package filters provides helper function to parse and handle command line
+// filter, used for example in docker ps or docker images commands.
+package filters
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "regexp"
+ "strings"
+
+ "github.com/docker/engine-api/types/versions"
+)
+
+// Args stores filter arguments as map key:{map key: bool}.
+// It contains an aggregation of the map of arguments (which are in the form
+// of -f 'key=value') based on the key, and stores values for the same key
+// in a map with string keys and boolean values.
+// e.g given -f 'label=label1=1' -f 'label=label2=2' -f 'image.name=ubuntu'
+// the args will be {"image.name":{"ubuntu":true},"label":{"label1=1":true,"label2=2":true}}
+type Args struct {
+ fields map[string]map[string]bool
+}
+
+// NewArgs initializes a new Args struct.
+func NewArgs() Args {
+ return Args{fields: map[string]map[string]bool{}}
+}
+
+// ParseFlag parses the argument to the filter flag. Like
+//
+// `docker ps -f 'created=today' -f 'image.name=ubuntu*'`
+//
+// If prev map is provided, then it is appended to, and returned. By default a new
+// map is created.
+func ParseFlag(arg string, prev Args) (Args, error) {
+ filters := prev
+ if len(arg) == 0 {
+ return filters, nil
+ }
+
+ if !strings.Contains(arg, "=") {
+ return filters, ErrBadFormat
+ }
+
+ f := strings.SplitN(arg, "=", 2)
+
+ name := strings.ToLower(strings.TrimSpace(f[0]))
+ value := strings.TrimSpace(f[1])
+
+ filters.Add(name, value)
+
+ return filters, nil
+}
+
+// ErrBadFormat is an error returned in case of bad format for a filter.
+var ErrBadFormat = errors.New("bad format of filter (expected name=value)")
+
+// ToParam packs the Args into a string for easy transport from client to server.
+func ToParam(a Args) (string, error) {
+ // this way we don't URL encode {}, just empty space
+ if a.Len() == 0 {
+ return "", nil
+ }
+
+ buf, err := json.Marshal(a.fields)
+ if err != nil {
+ return "", err
+ }
+ return string(buf), nil
+}
+
+// ToParamWithVersion packs the Args into a string for easy transport from client to server.
+// The generated string will depend on the specified version (corresponding to the API version).
+func ToParamWithVersion(version string, a Args) (string, error) {
+ // this way we don't URL encode {}, just empty space
+ if a.Len() == 0 {
+ return "", nil
+ }
+
+ // for daemons older than v1.10, filter must be of the form map[string][]string
+ buf := []byte{}
+ err := errors.New("")
+ if version != "" && versions.LessThan(version, "1.22") {
+ buf, err = json.Marshal(convertArgsToSlice(a.fields))
+ } else {
+ buf, err = json.Marshal(a.fields)
+ }
+ if err != nil {
+ return "", err
+ }
+ return string(buf), nil
+}
+
+// FromParam unpacks the filter Args.
+func FromParam(p string) (Args, error) {
+ if len(p) == 0 {
+ return NewArgs(), nil
+ }
+
+ r := strings.NewReader(p)
+ d := json.NewDecoder(r)
+
+ m := map[string]map[string]bool{}
+ if err := d.Decode(&m); err != nil {
+ r.Seek(0, 0)
+
+ // Allow parsing old arguments in slice format.
+ // Because other libraries might be sending them in this format.
+ deprecated := map[string][]string{}
+ if deprecatedErr := d.Decode(&deprecated); deprecatedErr == nil {
+ m = deprecatedArgs(deprecated)
+ } else {
+ return NewArgs(), err
+ }
+ }
+ return Args{m}, nil
+}
+
+// Get returns the list of values associates with a field.
+// It returns a slice of strings to keep backwards compatibility with old code.
+func (filters Args) Get(field string) []string {
+ values := filters.fields[field]
+ if values == nil {
+ return make([]string, 0)
+ }
+ slice := make([]string, 0, len(values))
+ for key := range values {
+ slice = append(slice, key)
+ }
+ return slice
+}
+
+// Add adds a new value to a filter field.
+func (filters Args) Add(name, value string) {
+ if _, ok := filters.fields[name]; ok {
+ filters.fields[name][value] = true
+ } else {
+ filters.fields[name] = map[string]bool{value: true}
+ }
+}
+
+// Del removes a value from a filter field.
+func (filters Args) Del(name, value string) {
+ if _, ok := filters.fields[name]; ok {
+ delete(filters.fields[name], value)
+ }
+}
+
+// Len returns the number of fields in the arguments.
+func (filters Args) Len() int {
+ return len(filters.fields)
+}
+
+// MatchKVList returns true if the values for the specified field matches the ones
+// from the sources.
+// e.g. given Args are {'label': {'label1=1','label2=1'}, 'image.name', {'ubuntu'}},
+// field is 'label' and sources are {'label1': '1', 'label2': '2'}
+// it returns true.
+func (filters Args) MatchKVList(field string, sources map[string]string) bool {
+ fieldValues := filters.fields[field]
+
+ //do not filter if there is no filter set or cannot determine filter
+ if len(fieldValues) == 0 {
+ return true
+ }
+
+ if sources == nil || len(sources) == 0 {
+ return false
+ }
+
+ for name2match := range fieldValues {
+ testKV := strings.SplitN(name2match, "=", 2)
+
+ v, ok := sources[testKV[0]]
+ if !ok {
+ return false
+ }
+ if len(testKV) == 2 && testKV[1] != v {
+ return false
+ }
+ }
+
+ return true
+}
+
+// Match returns true if the values for the specified field matches the source string
+// e.g. given Args are {'label': {'label1=1','label2=1'}, 'image.name', {'ubuntu'}},
+// field is 'image.name' and source is 'ubuntu'
+// it returns true.
+func (filters Args) Match(field, source string) bool {
+ if filters.ExactMatch(field, source) {
+ return true
+ }
+
+ fieldValues := filters.fields[field]
+ for name2match := range fieldValues {
+ match, err := regexp.MatchString(name2match, source)
+ if err != nil {
+ continue
+ }
+ if match {
+ return true
+ }
+ }
+ return false
+}
+
+// ExactMatch returns true if the source matches exactly one of the filters.
+func (filters Args) ExactMatch(field, source string) bool {
+ fieldValues, ok := filters.fields[field]
+ //do not filter if there is no filter set or cannot determine filter
+ if !ok || len(fieldValues) == 0 {
+ return true
+ }
+
+ // try to match full name value to avoid O(N) regular expression matching
+ return fieldValues[source]
+}
+
+// UniqueExactMatch returns true if there is only one filter and the source matches exactly this one.
+func (filters Args) UniqueExactMatch(field, source string) bool {
+ fieldValues := filters.fields[field]
+ //do not filter if there is no filter set or cannot determine filter
+ if len(fieldValues) == 0 {
+ return true
+ }
+ if len(filters.fields[field]) != 1 {
+ return false
+ }
+
+ // try to match full name value to avoid O(N) regular expression matching
+ return fieldValues[source]
+}
+
+// FuzzyMatch returns true if the source matches exactly one of the filters,
+// or the source has one of the filters as a prefix.
+func (filters Args) FuzzyMatch(field, source string) bool {
+ if filters.ExactMatch(field, source) {
+ return true
+ }
+
+ fieldValues := filters.fields[field]
+ for prefix := range fieldValues {
+ if strings.HasPrefix(source, prefix) {
+ return true
+ }
+ }
+ return false
+}
+
+// Include returns true if the name of the field to filter is in the filters.
+func (filters Args) Include(field string) bool {
+ _, ok := filters.fields[field]
+ return ok
+}
+
+// Validate ensures that all the fields in the filter are valid.
+// It returns an error as soon as it finds an invalid field.
+func (filters Args) Validate(accepted map[string]bool) error {
+ for name := range filters.fields {
+ if !accepted[name] {
+ return fmt.Errorf("Invalid filter '%s'", name)
+ }
+ }
+ return nil
+}
+
+// WalkValues iterates over the list of filtered values for a field.
+// It stops the iteration if it finds an error and it returns that error.
+func (filters Args) WalkValues(field string, op func(value string) error) error {
+ if _, ok := filters.fields[field]; !ok {
+ return nil
+ }
+ for v := range filters.fields[field] {
+ if err := op(v); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func deprecatedArgs(d map[string][]string) map[string]map[string]bool {
+ m := map[string]map[string]bool{}
+ for k, v := range d {
+ values := map[string]bool{}
+ for _, vv := range v {
+ values[vv] = true
+ }
+ m[k] = values
+ }
+ return m
+}
+
+func convertArgsToSlice(f map[string]map[string]bool) map[string][]string {
+ m := map[string][]string{}
+ for k, v := range f {
+ values := []string{}
+ for kk := range v {
+ if v[kk] {
+ values = append(values, kk)
+ }
+ }
+ m[k] = values
+ }
+ return m
+}
diff --git a/vendor/github.com/docker/engine-api/types/network/network.go b/vendor/github.com/docker/engine-api/types/network/network.go
new file mode 100644
index 0000000000000000000000000000000000000000..47080b652eb413f9ea8715d1542178de6af9bad5
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/network/network.go
@@ -0,0 +1,53 @@
+package network
+
+// Address represents an IP address
+type Address struct {
+ Addr string
+ PrefixLen int
+}
+
+// IPAM represents IP Address Management
+type IPAM struct {
+ Driver string
+ Options map[string]string //Per network IPAM driver options
+ Config []IPAMConfig
+}
+
+// IPAMConfig represents IPAM configurations
+type IPAMConfig struct {
+ Subnet string `json:",omitempty"`
+ IPRange string `json:",omitempty"`
+ Gateway string `json:",omitempty"`
+ AuxAddress map[string]string `json:"AuxiliaryAddresses,omitempty"`
+}
+
+// EndpointIPAMConfig represents IPAM configurations for the endpoint
+type EndpointIPAMConfig struct {
+ IPv4Address string `json:",omitempty"`
+ IPv6Address string `json:",omitempty"`
+ LinkLocalIPs []string `json:",omitempty"`
+}
+
+// EndpointSettings stores the network endpoint details
+type EndpointSettings struct {
+ // Configurations
+ IPAMConfig *EndpointIPAMConfig
+ Links []string
+ Aliases []string
+ // Operational data
+ NetworkID string
+ EndpointID string
+ Gateway string
+ IPAddress string
+ IPPrefixLen int
+ IPv6Gateway string
+ GlobalIPv6Address string
+ GlobalIPv6PrefixLen int
+ MacAddress string
+}
+
+// NetworkingConfig represents the container's networking configuration for each of its interfaces
+// Carries the networking configs specified in the `docker run` and `docker network connect` commands
+type NetworkingConfig struct {
+ EndpointsConfig map[string]*EndpointSettings // Endpoint configs for each connecting network
+}
diff --git a/vendor/github.com/docker/engine-api/types/plugin.go b/vendor/github.com/docker/engine-api/types/plugin.go
new file mode 100644
index 0000000000000000000000000000000000000000..601c0ac12a3f0aefa9c2e7fcd9e14c4274b1aba8
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/plugin.go
@@ -0,0 +1,170 @@
+// +build experimental
+
+package types
+
+import (
+ "encoding/json"
+ "fmt"
+)
+
+// PluginInstallOptions holds parameters to install a plugin.
+type PluginInstallOptions struct {
+ Disabled bool
+ AcceptAllPermissions bool
+ RegistryAuth string // RegistryAuth is the base64 encoded credentials for the registry
+ PrivilegeFunc RequestPrivilegeFunc
+ AcceptPermissionsFunc func(PluginPrivileges) (bool, error)
+}
+
+// PluginConfig represents the values of settings potentially modifiable by a user
+type PluginConfig struct {
+ Mounts []PluginMount
+ Env []string
+ Args []string
+ Devices []PluginDevice
+}
+
+// Plugin represents a Docker plugin for the remote API
+type Plugin struct {
+ ID string `json:"Id,omitempty"`
+ Name string
+ Tag string
+ // Enabled is true when the plugin is running, is false when the plugin is not running, only installed.
+ Enabled bool
+ Config PluginConfig
+ Manifest PluginManifest
+}
+
+// PluginsListResponse contains the response for the remote API
+type PluginsListResponse []*Plugin
+
+const (
+ authzDriver = "AuthzDriver"
+ graphDriver = "GraphDriver"
+ ipamDriver = "IpamDriver"
+ networkDriver = "NetworkDriver"
+ volumeDriver = "VolumeDriver"
+)
+
+// PluginInterfaceType represents a type that a plugin implements.
+type PluginInterfaceType struct {
+ Prefix string // This is always "docker"
+ Capability string // Capability should be validated against the above list.
+ Version string // Plugin API version. Depends on the capability
+}
+
+// UnmarshalJSON implements json.Unmarshaler for PluginInterfaceType
+func (t *PluginInterfaceType) UnmarshalJSON(p []byte) error {
+ versionIndex := len(p)
+ prefixIndex := 0
+ if len(p) < 2 || p[0] != '"' || p[len(p)-1] != '"' {
+ return fmt.Errorf("%q is not a plugin interface type", p)
+ }
+ p = p[1 : len(p)-1]
+loop:
+ for i, b := range p {
+ switch b {
+ case '.':
+ prefixIndex = i
+ case '/':
+ versionIndex = i
+ break loop
+ }
+ }
+ t.Prefix = string(p[:prefixIndex])
+ t.Capability = string(p[prefixIndex+1 : versionIndex])
+ if versionIndex < len(p) {
+ t.Version = string(p[versionIndex+1:])
+ }
+ return nil
+}
+
+// MarshalJSON implements json.Marshaler for PluginInterfaceType
+func (t *PluginInterfaceType) MarshalJSON() ([]byte, error) {
+ return json.Marshal(t.String())
+}
+
+// String implements fmt.Stringer for PluginInterfaceType
+func (t PluginInterfaceType) String() string {
+ return fmt.Sprintf("%s.%s/%s", t.Prefix, t.Capability, t.Version)
+}
+
+// PluginInterface describes the interface between Docker and plugin
+type PluginInterface struct {
+ Types []PluginInterfaceType
+ Socket string
+}
+
+// PluginSetting is to be embedded in other structs, if they are supposed to be
+// modifiable by the user.
+type PluginSetting struct {
+ Name string
+ Description string
+ Settable []string
+}
+
+// PluginNetwork represents the network configuration for a plugin
+type PluginNetwork struct {
+ Type string
+}
+
+// PluginMount represents the mount configuration for a plugin
+type PluginMount struct {
+ PluginSetting
+ Source *string
+ Destination string
+ Type string
+ Options []string
+}
+
+// PluginEnv represents an environment variable for a plugin
+type PluginEnv struct {
+ PluginSetting
+ Value *string
+}
+
+// PluginArgs represents the command line arguments for a plugin
+type PluginArgs struct {
+ PluginSetting
+ Value []string
+}
+
+// PluginDevice represents a device for a plugin
+type PluginDevice struct {
+ PluginSetting
+ Path *string
+}
+
+// PluginUser represents the user for the plugin's process
+type PluginUser struct {
+ UID uint32 `json:"Uid,omitempty"`
+ GID uint32 `json:"Gid,omitempty"`
+}
+
+// PluginManifest represents the manifest of a plugin
+type PluginManifest struct {
+ ManifestVersion string
+ Description string
+ Documentation string
+ Interface PluginInterface
+ Entrypoint []string
+ Workdir string
+ User PluginUser `json:",omitempty"`
+ Network PluginNetwork
+ Capabilities []string
+ Mounts []PluginMount
+ Devices []PluginDevice
+ Env []PluginEnv
+ Args PluginArgs
+}
+
+// PluginPrivilege describes a permission the user has to accept
+// upon installing a plugin.
+type PluginPrivilege struct {
+ Name string
+ Description string
+ Value []string
+}
+
+// PluginPrivileges is a list of PluginPrivilege
+type PluginPrivileges []PluginPrivilege
diff --git a/vendor/github.com/docker/engine-api/types/registry/registry.go b/vendor/github.com/docker/engine-api/types/registry/registry.go
new file mode 100644
index 0000000000000000000000000000000000000000..28fafab901bd4c66272b4317768bf259f34fec76
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/registry/registry.go
@@ -0,0 +1,104 @@
+package registry
+
+import (
+ "encoding/json"
+ "net"
+)
+
+// ServiceConfig stores daemon registry services configuration.
+type ServiceConfig struct {
+ InsecureRegistryCIDRs []*NetIPNet `json:"InsecureRegistryCIDRs"`
+ IndexConfigs map[string]*IndexInfo `json:"IndexConfigs"`
+ Mirrors []string
+}
+
+// NetIPNet is the net.IPNet type, which can be marshalled and
+// unmarshalled to JSON
+type NetIPNet net.IPNet
+
+// String returns the CIDR notation of ipnet
+func (ipnet *NetIPNet) String() string {
+ return (*net.IPNet)(ipnet).String()
+}
+
+// MarshalJSON returns the JSON representation of the IPNet
+func (ipnet *NetIPNet) MarshalJSON() ([]byte, error) {
+ return json.Marshal((*net.IPNet)(ipnet).String())
+}
+
+// UnmarshalJSON sets the IPNet from a byte array of JSON
+func (ipnet *NetIPNet) UnmarshalJSON(b []byte) (err error) {
+ var ipnetStr string
+ if err = json.Unmarshal(b, &ipnetStr); err == nil {
+ var cidr *net.IPNet
+ if _, cidr, err = net.ParseCIDR(ipnetStr); err == nil {
+ *ipnet = NetIPNet(*cidr)
+ }
+ }
+ return
+}
+
+// IndexInfo contains information about a registry
+//
+// RepositoryInfo Examples:
+// {
+// "Index" : {
+// "Name" : "docker.io",
+// "Mirrors" : ["https://registry-2.docker.io/v1/", "https://registry-3.docker.io/v1/"],
+// "Secure" : true,
+// "Official" : true,
+// },
+// "RemoteName" : "library/debian",
+// "LocalName" : "debian",
+// "CanonicalName" : "docker.io/debian"
+// "Official" : true,
+// }
+//
+// {
+// "Index" : {
+// "Name" : "127.0.0.1:5000",
+// "Mirrors" : [],
+// "Secure" : false,
+// "Official" : false,
+// },
+// "RemoteName" : "user/repo",
+// "LocalName" : "127.0.0.1:5000/user/repo",
+// "CanonicalName" : "127.0.0.1:5000/user/repo",
+// "Official" : false,
+// }
+type IndexInfo struct {
+ // Name is the name of the registry, such as "docker.io"
+ Name string
+ // Mirrors is a list of mirrors, expressed as URIs
+ Mirrors []string
+ // Secure is set to false if the registry is part of the list of
+ // insecure registries. Insecure registries accept HTTP and/or accept
+ // HTTPS with certificates from unknown CAs.
+ Secure bool
+ // Official indicates whether this is an official registry
+ Official bool
+}
+
+// SearchResult describes a search result returned from a registry
+type SearchResult struct {
+ // StarCount indicates the number of stars this repository has
+ StarCount int `json:"star_count"`
+ // IsOfficial is true if the result is from an official repository.
+ IsOfficial bool `json:"is_official"`
+ // Name is the name of the repository
+ Name string `json:"name"`
+ // IsAutomated indicates whether the result is automated
+ IsAutomated bool `json:"is_automated"`
+ // Description is a textual description of the repository
+ Description string `json:"description"`
+}
+
+// SearchResults lists a collection search results returned from a registry
+type SearchResults struct {
+ // Query contains the query string that generated the search results
+ Query string `json:"query"`
+ // NumResults indicates the number of results the query returned
+ NumResults int `json:"num_results"`
+ // Results is a slice containing the actual results for the search
+ Results []SearchResult `json:"results"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/seccomp.go b/vendor/github.com/docker/engine-api/types/seccomp.go
new file mode 100644
index 0000000000000000000000000000000000000000..854f1c4538a28ac32d51eaf5b909e45b64359f55
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/seccomp.go
@@ -0,0 +1,73 @@
+package types
+
+// Seccomp represents the config for a seccomp profile for syscall restriction.
+type Seccomp struct {
+ DefaultAction Action `json:"defaultAction"`
+ Architectures []Arch `json:"architectures"`
+ Syscalls []*Syscall `json:"syscalls"`
+}
+
+// Arch used for additional architectures
+type Arch string
+
+// Additional architectures permitted to be used for system calls
+// By default only the native architecture of the kernel is permitted
+const (
+ ArchX86 Arch = "SCMP_ARCH_X86"
+ ArchX86_64 Arch = "SCMP_ARCH_X86_64"
+ ArchX32 Arch = "SCMP_ARCH_X32"
+ ArchARM Arch = "SCMP_ARCH_ARM"
+ ArchAARCH64 Arch = "SCMP_ARCH_AARCH64"
+ ArchMIPS Arch = "SCMP_ARCH_MIPS"
+ ArchMIPS64 Arch = "SCMP_ARCH_MIPS64"
+ ArchMIPS64N32 Arch = "SCMP_ARCH_MIPS64N32"
+ ArchMIPSEL Arch = "SCMP_ARCH_MIPSEL"
+ ArchMIPSEL64 Arch = "SCMP_ARCH_MIPSEL64"
+ ArchMIPSEL64N32 Arch = "SCMP_ARCH_MIPSEL64N32"
+ ArchPPC Arch = "SCMP_ARCH_PPC"
+ ArchPPC64 Arch = "SCMP_ARCH_PPC64"
+ ArchPPC64LE Arch = "SCMP_ARCH_PPC64LE"
+ ArchS390 Arch = "SCMP_ARCH_S390"
+ ArchS390X Arch = "SCMP_ARCH_S390X"
+)
+
+// Action taken upon Seccomp rule match
+type Action string
+
+// Define actions for Seccomp rules
+const (
+ ActKill Action = "SCMP_ACT_KILL"
+ ActTrap Action = "SCMP_ACT_TRAP"
+ ActErrno Action = "SCMP_ACT_ERRNO"
+ ActTrace Action = "SCMP_ACT_TRACE"
+ ActAllow Action = "SCMP_ACT_ALLOW"
+)
+
+// Operator used to match syscall arguments in Seccomp
+type Operator string
+
+// Define operators for syscall arguments in Seccomp
+const (
+ OpNotEqual Operator = "SCMP_CMP_NE"
+ OpLessThan Operator = "SCMP_CMP_LT"
+ OpLessEqual Operator = "SCMP_CMP_LE"
+ OpEqualTo Operator = "SCMP_CMP_EQ"
+ OpGreaterEqual Operator = "SCMP_CMP_GE"
+ OpGreaterThan Operator = "SCMP_CMP_GT"
+ OpMaskedEqual Operator = "SCMP_CMP_MASKED_EQ"
+)
+
+// Arg used for matching specific syscall arguments in Seccomp
+type Arg struct {
+ Index uint `json:"index"`
+ Value uint64 `json:"value"`
+ ValueTwo uint64 `json:"valueTwo"`
+ Op Operator `json:"op"`
+}
+
+// Syscall is used to match a syscall in Seccomp
+type Syscall struct {
+ Name string `json:"name"`
+ Action Action `json:"action"`
+ Args []*Arg `json:"args"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/stats.go b/vendor/github.com/docker/engine-api/types/stats.go
new file mode 100644
index 0000000000000000000000000000000000000000..b420ebe7f6ab1ff80117c24a5f1412480c285b9e
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/stats.go
@@ -0,0 +1,115 @@
+// Package types is used for API stability in the types and response to the
+// consumers of the API stats endpoint.
+package types
+
+import "time"
+
+// ThrottlingData stores CPU throttling stats of one running container
+type ThrottlingData struct {
+ // Number of periods with throttling active
+ Periods uint64 `json:"periods"`
+ // Number of periods when the container hits its throttling limit.
+ ThrottledPeriods uint64 `json:"throttled_periods"`
+ // Aggregate time the container was throttled for in nanoseconds.
+ ThrottledTime uint64 `json:"throttled_time"`
+}
+
+// CPUUsage stores All CPU stats aggregated since container inception.
+type CPUUsage struct {
+ // Total CPU time consumed.
+ // Units: nanoseconds.
+ TotalUsage uint64 `json:"total_usage"`
+ // Total CPU time consumed per core.
+ // Units: nanoseconds.
+ PercpuUsage []uint64 `json:"percpu_usage"`
+ // Time spent by tasks of the cgroup in kernel mode.
+ // Units: nanoseconds.
+ UsageInKernelmode uint64 `json:"usage_in_kernelmode"`
+ // Time spent by tasks of the cgroup in user mode.
+ // Units: nanoseconds.
+ UsageInUsermode uint64 `json:"usage_in_usermode"`
+}
+
+// CPUStats aggregates and wraps all CPU related info of container
+type CPUStats struct {
+ CPUUsage CPUUsage `json:"cpu_usage"`
+ SystemUsage uint64 `json:"system_cpu_usage"`
+ ThrottlingData ThrottlingData `json:"throttling_data,omitempty"`
+}
+
+// MemoryStats aggregates All memory stats since container inception
+type MemoryStats struct {
+ // current res_counter usage for memory
+ Usage uint64 `json:"usage"`
+ // maximum usage ever recorded.
+ MaxUsage uint64 `json:"max_usage"`
+ // TODO(vishh): Export these as stronger types.
+ // all the stats exported via memory.stat.
+ Stats map[string]uint64 `json:"stats"`
+ // number of times memory usage hits limits.
+ Failcnt uint64 `json:"failcnt"`
+ Limit uint64 `json:"limit"`
+}
+
+// BlkioStatEntry is one small entity to store a piece of Blkio stats
+// TODO Windows: This can be factored out
+type BlkioStatEntry struct {
+ Major uint64 `json:"major"`
+ Minor uint64 `json:"minor"`
+ Op string `json:"op"`
+ Value uint64 `json:"value"`
+}
+
+// BlkioStats stores All IO service stats for data read and write
+// TODO Windows: This can be factored out
+type BlkioStats struct {
+ // number of bytes transferred to and from the block device
+ IoServiceBytesRecursive []BlkioStatEntry `json:"io_service_bytes_recursive"`
+ IoServicedRecursive []BlkioStatEntry `json:"io_serviced_recursive"`
+ IoQueuedRecursive []BlkioStatEntry `json:"io_queue_recursive"`
+ IoServiceTimeRecursive []BlkioStatEntry `json:"io_service_time_recursive"`
+ IoWaitTimeRecursive []BlkioStatEntry `json:"io_wait_time_recursive"`
+ IoMergedRecursive []BlkioStatEntry `json:"io_merged_recursive"`
+ IoTimeRecursive []BlkioStatEntry `json:"io_time_recursive"`
+ SectorsRecursive []BlkioStatEntry `json:"sectors_recursive"`
+}
+
+// NetworkStats aggregates All network stats of one container
+// TODO Windows: This will require refactoring
+type NetworkStats struct {
+ RxBytes uint64 `json:"rx_bytes"`
+ RxPackets uint64 `json:"rx_packets"`
+ RxErrors uint64 `json:"rx_errors"`
+ RxDropped uint64 `json:"rx_dropped"`
+ TxBytes uint64 `json:"tx_bytes"`
+ TxPackets uint64 `json:"tx_packets"`
+ TxErrors uint64 `json:"tx_errors"`
+ TxDropped uint64 `json:"tx_dropped"`
+}
+
+// PidsStats contains the stats of a container's pids
+type PidsStats struct {
+ // Current is the number of pids in the cgroup
+ Current uint64 `json:"current,omitempty"`
+ // Limit is the hard limit on the number of pids in the cgroup.
+ // A "Limit" of 0 means that there is no limit.
+ Limit uint64 `json:"limit,omitempty"`
+}
+
+// Stats is Ultimate struct aggregating all types of stats of one container
+type Stats struct {
+ Read time.Time `json:"read"`
+ PreCPUStats CPUStats `json:"precpu_stats,omitempty"`
+ CPUStats CPUStats `json:"cpu_stats,omitempty"`
+ MemoryStats MemoryStats `json:"memory_stats,omitempty"`
+ BlkioStats BlkioStats `json:"blkio_stats,omitempty"`
+ PidsStats PidsStats `json:"pids_stats,omitempty"`
+}
+
+// StatsJSON is newly used Networks
+type StatsJSON struct {
+ Stats
+
+ // Networks request version >=1.21
+ Networks map[string]NetworkStats `json:"networks,omitempty"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/strslice/strslice.go b/vendor/github.com/docker/engine-api/types/strslice/strslice.go
new file mode 100644
index 0000000000000000000000000000000000000000..bad493fb89fdb85ff56c954fd2bf4bb07c39aed0
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/strslice/strslice.go
@@ -0,0 +1,30 @@
+package strslice
+
+import "encoding/json"
+
+// StrSlice represents a string or an array of strings.
+// We need to override the json decoder to accept both options.
+type StrSlice []string
+
+// UnmarshalJSON decodes the byte slice whether it's a string or an array of
+// strings. This method is needed to implement json.Unmarshaler.
+func (e *StrSlice) UnmarshalJSON(b []byte) error {
+ if len(b) == 0 {
+ // With no input, we preserve the existing value by returning nil and
+ // leaving the target alone. This allows defining default values for
+ // the type.
+ return nil
+ }
+
+ p := make([]string, 0, 1)
+ if err := json.Unmarshal(b, &p); err != nil {
+ var s string
+ if err := json.Unmarshal(b, &s); err != nil {
+ return err
+ }
+ p = append(p, s)
+ }
+
+ *e = p
+ return nil
+}
diff --git a/vendor/github.com/docker/engine-api/types/types.go b/vendor/github.com/docker/engine-api/types/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..ad826ee0b4d36d79448a35b0a3f9c0b682fd8521
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/types.go
@@ -0,0 +1,517 @@
+package types
+
+import (
+ "os"
+ "time"
+
+ "github.com/docker/engine-api/types/container"
+ "github.com/docker/engine-api/types/mount"
+ "github.com/docker/engine-api/types/network"
+ "github.com/docker/engine-api/types/registry"
+ "github.com/docker/engine-api/types/swarm"
+ "github.com/docker/go-connections/nat"
+)
+
+// ContainerCreateResponse contains the information returned to a client on the
+// creation of a new container.
+type ContainerCreateResponse struct {
+ // ID is the ID of the created container.
+ ID string `json:"Id"`
+
+ // Warnings are any warnings encountered during the creation of the container.
+ Warnings []string `json:"Warnings"`
+}
+
+// ContainerExecCreateResponse contains response of Remote API:
+// POST "/containers/{name:.*}/exec"
+type ContainerExecCreateResponse struct {
+ // ID is the exec ID.
+ ID string `json:"Id"`
+}
+
+// ContainerUpdateResponse contains response of Remote API:
+// POST "/containers/{name:.*}/update"
+type ContainerUpdateResponse struct {
+ // Warnings are any warnings encountered during the updating of the container.
+ Warnings []string `json:"Warnings"`
+}
+
+// AuthResponse contains response of Remote API:
+// POST "/auth"
+type AuthResponse struct {
+ // Status is the authentication status
+ Status string `json:"Status"`
+
+ // IdentityToken is an opaque token used for authenticating
+ // a user after a successful login.
+ IdentityToken string `json:"IdentityToken,omitempty"`
+}
+
+// ContainerWaitResponse contains response of Remote API:
+// POST "/containers/"+containerID+"/wait"
+type ContainerWaitResponse struct {
+ // StatusCode is the status code of the wait job
+ StatusCode int `json:"StatusCode"`
+}
+
+// ContainerCommitResponse contains response of Remote API:
+// POST "/commit?container="+containerID
+type ContainerCommitResponse struct {
+ ID string `json:"Id"`
+}
+
+// ContainerChange contains response of Remote API:
+// GET "/containers/{name:.*}/changes"
+type ContainerChange struct {
+ Kind int
+ Path string
+}
+
+// ImageHistory contains response of Remote API:
+// GET "/images/{name:.*}/history"
+type ImageHistory struct {
+ ID string `json:"Id"`
+ Created int64
+ CreatedBy string
+ Tags []string
+ Size int64
+ Comment string
+}
+
+// ImageDelete contains response of Remote API:
+// DELETE "/images/{name:.*}"
+type ImageDelete struct {
+ Untagged string `json:",omitempty"`
+ Deleted string `json:",omitempty"`
+}
+
+// Image contains response of Remote API:
+// GET "/images/json"
+type Image struct {
+ ID string `json:"Id"`
+ ParentID string `json:"ParentId"`
+ RepoTags []string
+ RepoDigests []string
+ Created int64
+ Size int64
+ VirtualSize int64
+ Labels map[string]string
+}
+
+// GraphDriverData returns Image's graph driver config info
+// when calling inspect command
+type GraphDriverData struct {
+ Name string
+ Data map[string]string
+}
+
+// RootFS returns Image's RootFS description including the layer IDs.
+type RootFS struct {
+ Type string
+ Layers []string `json:",omitempty"`
+ BaseLayer string `json:",omitempty"`
+}
+
+// ImageInspect contains response of Remote API:
+// GET "/images/{name:.*}/json"
+type ImageInspect struct {
+ ID string `json:"Id"`
+ RepoTags []string
+ RepoDigests []string
+ Parent string
+ Comment string
+ Created string
+ Container string
+ ContainerConfig *container.Config
+ DockerVersion string
+ Author string
+ Config *container.Config
+ Architecture string
+ Os string
+ Size int64
+ VirtualSize int64
+ GraphDriver GraphDriverData
+ RootFS RootFS
+}
+
+// Port stores open ports info of container
+// e.g. {"PrivatePort": 8080, "PublicPort": 80, "Type": "tcp"}
+type Port struct {
+ IP string `json:",omitempty"`
+ PrivatePort int
+ PublicPort int `json:",omitempty"`
+ Type string
+}
+
+// Container contains response of Remote API:
+// GET "/containers/json"
+type Container struct {
+ ID string `json:"Id"`
+ Names []string
+ Image string
+ ImageID string
+ Command string
+ Created int64
+ Ports []Port
+ SizeRw int64 `json:",omitempty"`
+ SizeRootFs int64 `json:",omitempty"`
+ Labels map[string]string
+ State string
+ Status string
+ HostConfig struct {
+ NetworkMode string `json:",omitempty"`
+ }
+ NetworkSettings *SummaryNetworkSettings
+ Mounts []MountPoint
+}
+
+// CopyConfig contains request body of Remote API:
+// POST "/containers/"+containerID+"/copy"
+type CopyConfig struct {
+ Resource string
+}
+
+// ContainerPathStat is used to encode the header from
+// GET "/containers/{name:.*}/archive"
+// "Name" is the file or directory name.
+type ContainerPathStat struct {
+ Name string `json:"name"`
+ Size int64 `json:"size"`
+ Mode os.FileMode `json:"mode"`
+ Mtime time.Time `json:"mtime"`
+ LinkTarget string `json:"linkTarget"`
+}
+
+// ContainerProcessList contains response of Remote API:
+// GET "/containers/{name:.*}/top"
+type ContainerProcessList struct {
+ Processes [][]string
+ Titles []string
+}
+
+// Version contains response of Remote API:
+// GET "/version"
+type Version struct {
+ Version string
+ APIVersion string `json:"ApiVersion"`
+ GitCommit string
+ GoVersion string
+ Os string
+ Arch string
+ KernelVersion string `json:",omitempty"`
+ Experimental bool `json:",omitempty"`
+ BuildTime string `json:",omitempty"`
+}
+
+// Info contains response of Remote API:
+// GET "/info"
+type Info struct {
+ ID string
+ Containers int
+ ContainersRunning int
+ ContainersPaused int
+ ContainersStopped int
+ Images int
+ Driver string
+ DriverStatus [][2]string
+ SystemStatus [][2]string
+ Plugins PluginsInfo
+ MemoryLimit bool
+ SwapLimit bool
+ KernelMemory bool
+ CPUCfsPeriod bool `json:"CpuCfsPeriod"`
+ CPUCfsQuota bool `json:"CpuCfsQuota"`
+ CPUShares bool
+ CPUSet bool
+ IPv4Forwarding bool
+ BridgeNfIptables bool
+ BridgeNfIP6tables bool `json:"BridgeNfIp6tables"`
+ Debug bool
+ NFd int
+ OomKillDisable bool
+ NGoroutines int
+ SystemTime string
+ LoggingDriver string
+ CgroupDriver string
+ NEventsListener int
+ KernelVersion string
+ OperatingSystem string
+ OSType string
+ Architecture string
+ IndexServerAddress string
+ RegistryConfig *registry.ServiceConfig
+ NCPU int
+ MemTotal int64
+ DockerRootDir string
+ HTTPProxy string `json:"HttpProxy"`
+ HTTPSProxy string `json:"HttpsProxy"`
+ NoProxy string
+ Name string
+ Labels []string
+ ExperimentalBuild bool
+ ServerVersion string
+ ClusterStore string
+ ClusterAdvertise string
+ SecurityOptions []string
+ Runtimes map[string]Runtime
+ DefaultRuntime string
+ Swarm swarm.Info
+ // LiveRestoreEnabled determines whether containers should be kept
+ // running when the daemon is shutdown or upon daemon start if
+ // running containers are detected
+ LiveRestoreEnabled bool
+}
+
+// PluginsInfo is a temp struct holding Plugins name
+// registered with docker daemon. It is used by Info struct
+type PluginsInfo struct {
+ // List of Volume plugins registered
+ Volume []string
+ // List of Network plugins registered
+ Network []string
+ // List of Authorization plugins registered
+ Authorization []string
+}
+
+// ExecStartCheck is a temp struct used by execStart
+// Config fields is part of ExecConfig in runconfig package
+type ExecStartCheck struct {
+ // ExecStart will first check if it's detached
+ Detach bool
+ // Check if there's a tty
+ Tty bool
+}
+
+// HealthcheckResult stores information about a single run of a healthcheck probe
+type HealthcheckResult struct {
+ Start time.Time // Start is the time this check started
+ End time.Time // End is the time this check ended
+ ExitCode int // ExitCode meanings: 0=healthy, 1=unhealthy, 2=reserved (considered unhealthy), else=error running probe
+ Output string // Output from last check
+}
+
+// Health states
+const (
+ Starting = "starting" // Starting indicates that the container is not yet ready
+ Healthy = "healthy" // Healthy indicates that the container is running correctly
+ Unhealthy = "unhealthy" // Unhealthy indicates that the container has a problem
+)
+
+// Health stores information about the container's healthcheck results
+type Health struct {
+ Status string // Status is one of Starting, Healthy or Unhealthy
+ FailingStreak int // FailingStreak is the number of consecutive failures
+ Log []*HealthcheckResult // Log contains the last few results (oldest first)
+}
+
+// ContainerState stores container's running state
+// it's part of ContainerJSONBase and will return by "inspect" command
+type ContainerState struct {
+ Status string
+ Running bool
+ Paused bool
+ Restarting bool
+ OOMKilled bool
+ Dead bool
+ Pid int
+ ExitCode int
+ Error string
+ StartedAt string
+ FinishedAt string
+ Health *Health `json:",omitempty"`
+}
+
+// ContainerNode stores information about the node that a container
+// is running on. It's only available in Docker Swarm
+type ContainerNode struct {
+ ID string
+ IPAddress string `json:"IP"`
+ Addr string
+ Name string
+ Cpus int
+ Memory int64
+ Labels map[string]string
+}
+
+// ContainerJSONBase contains response of Remote API:
+// GET "/containers/{name:.*}/json"
+type ContainerJSONBase struct {
+ ID string `json:"Id"`
+ Created string
+ Path string
+ Args []string
+ State *ContainerState
+ Image string
+ ResolvConfPath string
+ HostnamePath string
+ HostsPath string
+ LogPath string
+ Node *ContainerNode `json:",omitempty"`
+ Name string
+ RestartCount int
+ Driver string
+ MountLabel string
+ ProcessLabel string
+ AppArmorProfile string
+ ExecIDs []string
+ HostConfig *container.HostConfig
+ GraphDriver GraphDriverData
+ SizeRw *int64 `json:",omitempty"`
+ SizeRootFs *int64 `json:",omitempty"`
+}
+
+// ContainerJSON is newly used struct along with MountPoint
+type ContainerJSON struct {
+ *ContainerJSONBase
+ Mounts []MountPoint
+ Config *container.Config
+ NetworkSettings *NetworkSettings
+}
+
+// NetworkSettings exposes the network settings in the api
+type NetworkSettings struct {
+ NetworkSettingsBase
+ DefaultNetworkSettings
+ Networks map[string]*network.EndpointSettings
+}
+
+// SummaryNetworkSettings provides a summary of container's networks
+// in /containers/json
+type SummaryNetworkSettings struct {
+ Networks map[string]*network.EndpointSettings
+}
+
+// NetworkSettingsBase holds basic information about networks
+type NetworkSettingsBase struct {
+ Bridge string // Bridge is the Bridge name the network uses(e.g. `docker0`)
+ SandboxID string // SandboxID uniquely represents a container's network stack
+ HairpinMode bool // HairpinMode specifies if hairpin NAT should be enabled on the virtual interface
+ LinkLocalIPv6Address string // LinkLocalIPv6Address is an IPv6 unicast address using the link-local prefix
+ LinkLocalIPv6PrefixLen int // LinkLocalIPv6PrefixLen is the prefix length of an IPv6 unicast address
+ Ports nat.PortMap // Ports is a collection of PortBinding indexed by Port
+ SandboxKey string // SandboxKey identifies the sandbox
+ SecondaryIPAddresses []network.Address
+ SecondaryIPv6Addresses []network.Address
+}
+
+// DefaultNetworkSettings holds network information
+// during the 2 release deprecation period.
+// It will be removed in Docker 1.11.
+type DefaultNetworkSettings struct {
+ EndpointID string // EndpointID uniquely represents a service endpoint in a Sandbox
+ Gateway string // Gateway holds the gateway address for the network
+ GlobalIPv6Address string // GlobalIPv6Address holds network's global IPv6 address
+ GlobalIPv6PrefixLen int // GlobalIPv6PrefixLen represents mask length of network's global IPv6 address
+ IPAddress string // IPAddress holds the IPv4 address for the network
+ IPPrefixLen int // IPPrefixLen represents mask length of network's IPv4 address
+ IPv6Gateway string // IPv6Gateway holds gateway address specific for IPv6
+ MacAddress string // MacAddress holds the MAC address for the network
+}
+
+// MountPoint represents a mount point configuration inside the container.
+// This is used for reporting the mountpoints in use by a container.
+type MountPoint struct {
+ Type mount.Type `json:",omitempty"`
+ Name string `json:",omitempty"`
+ Source string
+ Destination string
+ Driver string `json:",omitempty"`
+ Mode string
+ RW bool
+ Propagation mount.Propagation
+}
+
+// Volume represents the configuration of a volume for the remote API
+type Volume struct {
+ Name string // Name is the name of the volume
+ Driver string // Driver is the Driver name used to create the volume
+ Mountpoint string // Mountpoint is the location on disk of the volume
+ Status map[string]interface{} `json:",omitempty"` // Status provides low-level status information about the volume
+ Labels map[string]string // Labels is metadata specific to the volume
+ Scope string // Scope describes the level at which the volume exists (e.g. `global` for cluster-wide or `local` for machine level)
+}
+
+// VolumesListResponse contains the response for the remote API:
+// GET "/volumes"
+type VolumesListResponse struct {
+ Volumes []*Volume // Volumes is the list of volumes being returned
+ Warnings []string // Warnings is a list of warnings that occurred when getting the list from the volume drivers
+}
+
+// VolumeCreateRequest contains the response for the remote API:
+// POST "/volumes/create"
+type VolumeCreateRequest struct {
+ Name string // Name is the requested name of the volume
+ Driver string // Driver is the name of the driver that should be used to create the volume
+ DriverOpts map[string]string // DriverOpts holds the driver specific options to use for when creating the volume.
+ Labels map[string]string // Labels holds metadata specific to the volume being created.
+}
+
+// NetworkResource is the body of the "get network" http response message
+type NetworkResource struct {
+ Name string // Name is the requested name of the network
+ ID string `json:"Id"` // ID uniquely identifies a network on a single machine
+ Scope string // Scope describes the level at which the network exists (e.g. `global` for cluster-wide or `local` for machine level)
+ Driver string // Driver is the Driver name used to create the network (e.g. `bridge`, `overlay`)
+ EnableIPv6 bool // EnableIPv6 represents whether to enable IPv6
+ IPAM network.IPAM // IPAM is the network's IP Address Management
+ Internal bool // Internal represents if the network is used internal only
+ Containers map[string]EndpointResource // Containers contains endpoints belonging to the network
+ Options map[string]string // Options holds the network specific options to use for when creating the network
+ Labels map[string]string // Labels holds metadata specific to the network being created
+}
+
+// EndpointResource contains network resources allocated and used for a container in a network
+type EndpointResource struct {
+ Name string
+ EndpointID string
+ MacAddress string
+ IPv4Address string
+ IPv6Address string
+}
+
+// NetworkCreate is the expected body of the "create network" http request message
+type NetworkCreate struct {
+ CheckDuplicate bool
+ Driver string
+ EnableIPv6 bool
+ IPAM network.IPAM
+ Internal bool
+ Options map[string]string
+ Labels map[string]string
+}
+
+// NetworkCreateRequest is the request message sent to the server for network create call.
+type NetworkCreateRequest struct {
+ NetworkCreate
+ Name string
+}
+
+// NetworkCreateResponse is the response message sent by the server for network create call
+type NetworkCreateResponse struct {
+ ID string `json:"Id"`
+ Warning string
+}
+
+// NetworkConnect represents the data to be used to connect a container to the network
+type NetworkConnect struct {
+ Container string
+ EndpointConfig *network.EndpointSettings `json:",omitempty"`
+}
+
+// NetworkDisconnect represents the data to be used to disconnect a container from the network
+type NetworkDisconnect struct {
+ Container string
+ Force bool
+}
+
+// Checkpoint represents the details of a checkpoint
+type Checkpoint struct {
+ Name string // Name is the name of the checkpoint
+}
+
+// Runtime describes an OCI runtime
+type Runtime struct {
+ Path string `json:"path"`
+ Args []string `json:"runtimeArgs,omitempty"`
+}
diff --git a/vendor/github.com/docker/engine-api/types/versions/README.md b/vendor/github.com/docker/engine-api/types/versions/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cdac50a53c019e2efe971660f3ae11a297aac8ec
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/versions/README.md
@@ -0,0 +1,14 @@
+## Legacy API type versions
+
+This package includes types for legacy API versions. The stable version of the API types live in `api/types/*.go`.
+
+Consider moving a type here when you need to keep backwards compatibility in the API. This legacy types are organized by the latest API version they appear in. For instance, types in the `v1p19` package are valid for API versions below or equal `1.19`. Types in the `v1p20` package are valid for the API version `1.20`, since the versions below that will use the legacy types in `v1p19`.
+
+### Package name conventions
+
+The package name convention is to use `v` as a prefix for the version number and `p`(patch) as a separator. We use this nomenclature due to a few restrictions in the Go package name convention:
+
+1. We cannot use `.` because it's interpreted by the language, think of `v1.20.CallFunction`.
+2. We cannot use `_` because golint complains about it. The code is actually valid, but it looks probably more weird: `v1_20.CallFunction`.
+
+For instance, if you want to modify a type that was available in the version `1.21` of the API but it will have different fields in the version `1.22`, you want to create a new package under `api/types/versions/v1p21`.
diff --git a/vendor/github.com/docker/engine-api/types/versions/compare.go b/vendor/github.com/docker/engine-api/types/versions/compare.go
new file mode 100644
index 0000000000000000000000000000000000000000..611d4fed66e5f136446d3fc771f747a6c4c192a9
--- /dev/null
+++ b/vendor/github.com/docker/engine-api/types/versions/compare.go
@@ -0,0 +1,62 @@
+package versions
+
+import (
+ "strconv"
+ "strings"
+)
+
+// compare compares two version strings
+// returns -1 if v1 < v2, 1 if v1 > v2, 0 otherwise.
+func compare(v1, v2 string) int {
+ var (
+ currTab = strings.Split(v1, ".")
+ otherTab = strings.Split(v2, ".")
+ )
+
+ max := len(currTab)
+ if len(otherTab) > max {
+ max = len(otherTab)
+ }
+ for i := 0; i < max; i++ {
+ var currInt, otherInt int
+
+ if len(currTab) > i {
+ currInt, _ = strconv.Atoi(currTab[i])
+ }
+ if len(otherTab) > i {
+ otherInt, _ = strconv.Atoi(otherTab[i])
+ }
+ if currInt > otherInt {
+ return 1
+ }
+ if otherInt > currInt {
+ return -1
+ }
+ }
+ return 0
+}
+
+// LessThan checks if a version is less than another
+func LessThan(v, other string) bool {
+ return compare(v, other) == -1
+}
+
+// LessThanOrEqualTo checks if a version is less than or equal to another
+func LessThanOrEqualTo(v, other string) bool {
+ return compare(v, other) <= 0
+}
+
+// GreaterThan checks if a version is greater than another
+func GreaterThan(v, other string) bool {
+ return compare(v, other) == 1
+}
+
+// GreaterThanOrEqualTo checks if a version is greater than or equal to another
+func GreaterThanOrEqualTo(v, other string) bool {
+ return compare(v, other) >= 0
+}
+
+// Equal checks if a version is equal to another
+func Equal(v, other string) bool {
+ return compare(v, other) == 0
+}
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/LICENSE.code b/vendor/github.com/docker/go-connections/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/LICENSE.code
rename to vendor/github.com/docker/go-connections/LICENSE
diff --git a/vendor/github.com/docker/go-connections/nat/nat.go b/vendor/github.com/docker/go-connections/nat/nat.go
new file mode 100644
index 0000000000000000000000000000000000000000..e19c73c378d6c1424e9f4a0385700d58880881b7
--- /dev/null
+++ b/vendor/github.com/docker/go-connections/nat/nat.go
@@ -0,0 +1,239 @@
+// Package nat is a convenience package for manipulation of strings describing network ports.
+package nat
+
+import (
+ "fmt"
+ "net"
+ "strconv"
+ "strings"
+)
+
+const (
+ // portSpecTemplate is the expected format for port specifications
+ portSpecTemplate = "ip:hostPort:containerPort"
+)
+
+// PortBinding represents a binding between a Host IP address and a Host Port
+type PortBinding struct {
+ // HostIP is the host IP Address
+ HostIP string `json:"HostIp"`
+ // HostPort is the host port number
+ HostPort string
+}
+
+// PortMap is a collection of PortBinding indexed by Port
+type PortMap map[Port][]PortBinding
+
+// PortSet is a collection of structs indexed by Port
+type PortSet map[Port]struct{}
+
+// Port is a string containing port number and protocol in the format "80/tcp"
+type Port string
+
+// NewPort creates a new instance of a Port given a protocol and port number or port range
+func NewPort(proto, port string) (Port, error) {
+ // Check for parsing issues on "port" now so we can avoid having
+ // to check it later on.
+
+ portStartInt, portEndInt, err := ParsePortRangeToInt(port)
+ if err != nil {
+ return "", err
+ }
+
+ if portStartInt == portEndInt {
+ return Port(fmt.Sprintf("%d/%s", portStartInt, proto)), nil
+ }
+ return Port(fmt.Sprintf("%d-%d/%s", portStartInt, portEndInt, proto)), nil
+}
+
+// ParsePort parses the port number string and returns an int
+func ParsePort(rawPort string) (int, error) {
+ if len(rawPort) == 0 {
+ return 0, nil
+ }
+ port, err := strconv.ParseUint(rawPort, 10, 16)
+ if err != nil {
+ return 0, err
+ }
+ return int(port), nil
+}
+
+// ParsePortRangeToInt parses the port range string and returns start/end ints
+func ParsePortRangeToInt(rawPort string) (int, int, error) {
+ if len(rawPort) == 0 {
+ return 0, 0, nil
+ }
+ start, end, err := ParsePortRange(rawPort)
+ if err != nil {
+ return 0, 0, err
+ }
+ return int(start), int(end), nil
+}
+
+// Proto returns the protocol of a Port
+func (p Port) Proto() string {
+ proto, _ := SplitProtoPort(string(p))
+ return proto
+}
+
+// Port returns the port number of a Port
+func (p Port) Port() string {
+ _, port := SplitProtoPort(string(p))
+ return port
+}
+
+// Int returns the port number of a Port as an int
+func (p Port) Int() int {
+ portStr := p.Port()
+ // We don't need to check for an error because we're going to
+ // assume that any error would have been found, and reported, in NewPort()
+ port, _ := ParsePort(portStr)
+ return port
+}
+
+// Range returns the start/end port numbers of a Port range as ints
+func (p Port) Range() (int, int, error) {
+ return ParsePortRangeToInt(p.Port())
+}
+
+// SplitProtoPort splits a port in the format of proto/port
+func SplitProtoPort(rawPort string) (string, string) {
+ parts := strings.Split(rawPort, "/")
+ l := len(parts)
+ if len(rawPort) == 0 || l == 0 || len(parts[0]) == 0 {
+ return "", ""
+ }
+ if l == 1 {
+ return "tcp", rawPort
+ }
+ if len(parts[1]) == 0 {
+ return "tcp", parts[0]
+ }
+ return parts[1], parts[0]
+}
+
+func validateProto(proto string) bool {
+ for _, availableProto := range []string{"tcp", "udp"} {
+ if availableProto == proto {
+ return true
+ }
+ }
+ return false
+}
+
+// ParsePortSpecs receives port specs in the format of ip:public:private/proto and parses
+// these in to the internal types
+func ParsePortSpecs(ports []string) (map[Port]struct{}, map[Port][]PortBinding, error) {
+ var (
+ exposedPorts = make(map[Port]struct{}, len(ports))
+ bindings = make(map[Port][]PortBinding)
+ )
+ for _, rawPort := range ports {
+ portMappings, err := ParsePortSpec(rawPort)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ for _, portMapping := range portMappings {
+ port := portMapping.Port
+ if _, exists := exposedPorts[port]; !exists {
+ exposedPorts[port] = struct{}{}
+ }
+ bslice, exists := bindings[port]
+ if !exists {
+ bslice = []PortBinding{}
+ }
+ bindings[port] = append(bslice, portMapping.Binding)
+ }
+ }
+ return exposedPorts, bindings, nil
+}
+
+// PortMapping is a data object mapping a Port to a PortBinding
+type PortMapping struct {
+ Port Port
+ Binding PortBinding
+}
+
+// ParsePortSpec parses a port specification string into a slice of PortMappings
+func ParsePortSpec(rawPort string) ([]PortMapping, error) {
+ proto := "tcp"
+
+ if i := strings.LastIndex(rawPort, "/"); i != -1 {
+ proto = rawPort[i+1:]
+ rawPort = rawPort[:i]
+ }
+ if !strings.Contains(rawPort, ":") {
+ rawPort = fmt.Sprintf("::%s", rawPort)
+ } else if len(strings.Split(rawPort, ":")) == 2 {
+ rawPort = fmt.Sprintf(":%s", rawPort)
+ }
+
+ parts, err := PartParser(portSpecTemplate, rawPort)
+ if err != nil {
+ return nil, err
+ }
+
+ var (
+ containerPort = parts["containerPort"]
+ rawIP = parts["ip"]
+ hostPort = parts["hostPort"]
+ )
+
+ if rawIP != "" && net.ParseIP(rawIP) == nil {
+ return nil, fmt.Errorf("Invalid ip address: %s", rawIP)
+ }
+ if containerPort == "" {
+ return nil, fmt.Errorf("No port specified: %s<empty>", rawPort)
+ }
+
+ startPort, endPort, err := ParsePortRange(containerPort)
+ if err != nil {
+ return nil, fmt.Errorf("Invalid containerPort: %s", containerPort)
+ }
+
+ var startHostPort, endHostPort uint64 = 0, 0
+ if len(hostPort) > 0 {
+ startHostPort, endHostPort, err = ParsePortRange(hostPort)
+ if err != nil {
+ return nil, fmt.Errorf("Invalid hostPort: %s", hostPort)
+ }
+ }
+
+ if hostPort != "" && (endPort-startPort) != (endHostPort-startHostPort) {
+ // Allow host port range iff containerPort is not a range.
+ // In this case, use the host port range as the dynamic
+ // host port range to allocate into.
+ if endPort != startPort {
+ return nil, fmt.Errorf("Invalid ranges specified for container and host Ports: %s and %s", containerPort, hostPort)
+ }
+ }
+
+ if !validateProto(strings.ToLower(proto)) {
+ return nil, fmt.Errorf("Invalid proto: %s", proto)
+ }
+
+ ports := []PortMapping{}
+ for i := uint64(0); i <= (endPort - startPort); i++ {
+ containerPort = strconv.FormatUint(startPort+i, 10)
+ if len(hostPort) > 0 {
+ hostPort = strconv.FormatUint(startHostPort+i, 10)
+ }
+ // Set hostPort to a range only if there is a single container port
+ // and a dynamic host port.
+ if startPort == endPort && startHostPort != endHostPort {
+ hostPort = fmt.Sprintf("%s-%s", hostPort, strconv.FormatUint(endHostPort, 10))
+ }
+ port, err := NewPort(strings.ToLower(proto), containerPort)
+ if err != nil {
+ return nil, err
+ }
+
+ binding := PortBinding{
+ HostIP: rawIP,
+ HostPort: hostPort,
+ }
+ ports = append(ports, PortMapping{Port: port, Binding: binding})
+ }
+ return ports, nil
+}
diff --git a/vendor/github.com/docker/go-connections/nat/parse.go b/vendor/github.com/docker/go-connections/nat/parse.go
new file mode 100644
index 0000000000000000000000000000000000000000..872050205f4952b12afa7287b7e69d59f6e8d19e
--- /dev/null
+++ b/vendor/github.com/docker/go-connections/nat/parse.go
@@ -0,0 +1,56 @@
+package nat
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// PartParser parses and validates the specified string (data) using the specified template
+// e.g. ip:public:private -> 192.168.0.1:80:8000
+func PartParser(template, data string) (map[string]string, error) {
+ // ip:public:private
+ var (
+ templateParts = strings.Split(template, ":")
+ parts = strings.Split(data, ":")
+ out = make(map[string]string, len(templateParts))
+ )
+ if len(parts) != len(templateParts) {
+ return nil, fmt.Errorf("Invalid format to parse. %s should match template %s", data, template)
+ }
+
+ for i, t := range templateParts {
+ value := ""
+ if len(parts) > i {
+ value = parts[i]
+ }
+ out[t] = value
+ }
+ return out, nil
+}
+
+// ParsePortRange parses and validates the specified string as a port-range (8000-9000)
+func ParsePortRange(ports string) (uint64, uint64, error) {
+ if ports == "" {
+ return 0, 0, fmt.Errorf("Empty string specified for ports.")
+ }
+ if !strings.Contains(ports, "-") {
+ start, err := strconv.ParseUint(ports, 10, 16)
+ end := start
+ return start, end, err
+ }
+
+ parts := strings.Split(ports, "-")
+ start, err := strconv.ParseUint(parts[0], 10, 16)
+ if err != nil {
+ return 0, 0, err
+ }
+ end, err := strconv.ParseUint(parts[1], 10, 16)
+ if err != nil {
+ return 0, 0, err
+ }
+ if end < start {
+ return 0, 0, fmt.Errorf("Invalid range specified for the Port: %s", ports)
+ }
+ return start, end, nil
+}
diff --git a/vendor/github.com/docker/go-connections/nat/sort.go b/vendor/github.com/docker/go-connections/nat/sort.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce950171e3154043884855967a2ebad897b0f58d
--- /dev/null
+++ b/vendor/github.com/docker/go-connections/nat/sort.go
@@ -0,0 +1,96 @@
+package nat
+
+import (
+ "sort"
+ "strings"
+)
+
+type portSorter struct {
+ ports []Port
+ by func(i, j Port) bool
+}
+
+func (s *portSorter) Len() int {
+ return len(s.ports)
+}
+
+func (s *portSorter) Swap(i, j int) {
+ s.ports[i], s.ports[j] = s.ports[j], s.ports[i]
+}
+
+func (s *portSorter) Less(i, j int) bool {
+ ip := s.ports[i]
+ jp := s.ports[j]
+
+ return s.by(ip, jp)
+}
+
+// Sort sorts a list of ports using the provided predicate
+// This function should compare `i` and `j`, returning true if `i` is
+// considered to be less than `j`
+func Sort(ports []Port, predicate func(i, j Port) bool) {
+ s := &portSorter{ports, predicate}
+ sort.Sort(s)
+}
+
+type portMapEntry struct {
+ port Port
+ binding PortBinding
+}
+
+type portMapSorter []portMapEntry
+
+func (s portMapSorter) Len() int { return len(s) }
+func (s portMapSorter) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// sort the port so that the order is:
+// 1. port with larger specified bindings
+// 2. larger port
+// 3. port with tcp protocol
+func (s portMapSorter) Less(i, j int) bool {
+ pi, pj := s[i].port, s[j].port
+ hpi, hpj := toInt(s[i].binding.HostPort), toInt(s[j].binding.HostPort)
+ return hpi > hpj || pi.Int() > pj.Int() || (pi.Int() == pj.Int() && strings.ToLower(pi.Proto()) == "tcp")
+}
+
+// SortPortMap sorts the list of ports and their respected mapping. The ports
+// will explicit HostPort will be placed first.
+func SortPortMap(ports []Port, bindings PortMap) {
+ s := portMapSorter{}
+ for _, p := range ports {
+ if binding, ok := bindings[p]; ok {
+ for _, b := range binding {
+ s = append(s, portMapEntry{port: p, binding: b})
+ }
+ bindings[p] = []PortBinding{}
+ } else {
+ s = append(s, portMapEntry{port: p})
+ }
+ }
+
+ sort.Sort(s)
+ var (
+ i int
+ pm = make(map[Port]struct{})
+ )
+ // reorder ports
+ for _, entry := range s {
+ if _, ok := pm[entry.port]; !ok {
+ ports[i] = entry.port
+ pm[entry.port] = struct{}{}
+ i++
+ }
+ // reorder bindings for this port
+ if _, ok := bindings[entry.port]; ok {
+ bindings[entry.port] = append(bindings[entry.port], entry.binding)
+ }
+ }
+}
+
+func toInt(s string) uint64 {
+ i, _, err := ParsePortRange(s)
+ if err != nil {
+ i = 0
+ }
+ return i
+}
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/CONTRIBUTING.md b/vendor/github.com/docker/go-units/CONTRIBUTING.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/CONTRIBUTING.md
rename to vendor/github.com/docker/go-units/CONTRIBUTING.md
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/LICENSE b/vendor/github.com/docker/go-units/LICENSE
similarity index 98%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/LICENSE
rename to vendor/github.com/docker/go-units/LICENSE
index 27448585ad49c79581d0b3dcb76da380fb6df4b7..b55b37bc3162090c6e7c3458fbe0771089ef633b 100644
--- a/Godeps/_workspace/src/github.com/opencontainers/runc/LICENSE
+++ b/vendor/github.com/docker/go-units/LICENSE
@@ -1,7 +1,7 @@
Apache License
Version 2.0, January 2004
- http://www.apache.org/licenses/
+ https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
@@ -176,13 +176,13 @@
END OF TERMS AND CONDITIONS
- Copyright 2014 Docker, Inc.
+ Copyright 2015 Docker, Inc.
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
+ https://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,
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/MAINTAINERS b/vendor/github.com/docker/go-units/MAINTAINERS
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/MAINTAINERS
rename to vendor/github.com/docker/go-units/MAINTAINERS
diff --git a/vendor/github.com/docker/go-units/README.md b/vendor/github.com/docker/go-units/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f70a4e1345f7d3b7c357c1be1e06b720b012b60
--- /dev/null
+++ b/vendor/github.com/docker/go-units/README.md
@@ -0,0 +1,16 @@
+[](https://godoc.org/github.com/docker/go-units)
+
+# Introduction
+
+go-units is a library to transform human friendly measurements into machine friendly values.
+
+## Usage
+
+See the [docs in godoc](https://godoc.org/github.com/docker/go-units) for examples and documentation.
+
+## Copyright and license
+
+Copyright © 2015 Docker, Inc.
+
+go-units is licensed under the Apache License, Version 2.0.
+See [LICENSE](LICENSE) for the full text of the license.
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/circle.yml b/vendor/github.com/docker/go-units/circle.yml
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/circle.yml
rename to vendor/github.com/docker/go-units/circle.yml
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/duration.go b/vendor/github.com/docker/go-units/duration.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/docker/go-units/duration.go
rename to vendor/github.com/docker/go-units/duration.go
index c219a8a968c40035a4f3a44d448f94ac4bceece9..d4a6454907931da0faff5b834ddd673a62db4994 100644
--- a/Godeps/_workspace/src/github.com/docker/go-units/duration.go
+++ b/vendor/github.com/docker/go-units/duration.go
@@ -12,6 +12,8 @@ import (
func HumanDuration(d time.Duration) string {
if seconds := int(d.Seconds()); seconds < 1 {
return "Less than a second"
+ } else if seconds == 1 {
+ return "1 second"
} else if seconds < 60 {
return fmt.Sprintf("%d seconds", seconds)
} else if minutes := int(d.Minutes()); minutes == 1 {
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/size.go b/vendor/github.com/docker/go-units/size.go
similarity index 88%
rename from Godeps/_workspace/src/github.com/docker/go-units/size.go
rename to vendor/github.com/docker/go-units/size.go
index 3b59daff31b73be02f2fc36b7f172cd7dc187657..f5b82ea24656e0856c25f5886bfd6b0e0b182f43 100644
--- a/Godeps/_workspace/src/github.com/docker/go-units/size.go
+++ b/vendor/github.com/docker/go-units/size.go
@@ -31,7 +31,7 @@ type unitMap map[string]int64
var (
decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
- sizeRegex = regexp.MustCompile(`^(\d+)([kKmMgGtTpP])?[bB]?$`)
+ sizeRegex = regexp.MustCompile(`^(\d+(\.\d+)*) ?([kKmMgGtTpP])?[bB]?$`)
)
var decimapAbbrs = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}
@@ -41,7 +41,8 @@ var binaryAbbrs = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB",
// using custom format.
func CustomSize(format string, size float64, base float64, _map []string) string {
i := 0
- for size >= base {
+ unitsLimit := len(_map) - 1
+ for size >= base && i < unitsLimit {
size = size / base
i++
}
@@ -77,19 +78,19 @@ func RAMInBytes(size string) (int64, error) {
// Parses the human-readable size string into the amount it represents.
func parseSize(sizeStr string, uMap unitMap) (int64, error) {
matches := sizeRegex.FindStringSubmatch(sizeStr)
- if len(matches) != 3 {
+ if len(matches) != 4 {
return -1, fmt.Errorf("invalid size: '%s'", sizeStr)
}
- size, err := strconv.ParseInt(matches[1], 10, 0)
+ size, err := strconv.ParseFloat(matches[1], 64)
if err != nil {
return -1, err
}
- unitPrefix := strings.ToLower(matches[2])
+ unitPrefix := strings.ToLower(matches[3])
if mul, ok := uMap[unitPrefix]; ok {
- size *= mul
+ size *= float64(mul)
}
- return size, nil
+ return int64(size), nil
}
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/ulimit.go b/vendor/github.com/docker/go-units/ulimit.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/ulimit.go
rename to vendor/github.com/docker/go-units/ulimit.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/CONTRIBUTING.md b/vendor/github.com/docker/spdystream/CONTRIBUTING.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/CONTRIBUTING.md
rename to vendor/github.com/docker/spdystream/CONTRIBUTING.md
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/LICENSE b/vendor/github.com/docker/spdystream/LICENSE
similarity index 99%
rename from Godeps/_workspace/src/github.com/docker/spdystream/LICENSE
rename to vendor/github.com/docker/spdystream/LICENSE
index 27448585ad49c79581d0b3dcb76da380fb6df4b7..9e4bd4dbee94d6801a7e07f12ad320e87386c212 100644
--- a/Godeps/_workspace/src/github.com/docker/spdystream/LICENSE
+++ b/vendor/github.com/docker/spdystream/LICENSE
@@ -176,7 +176,7 @@
END OF TERMS AND CONDITIONS
- Copyright 2014 Docker, Inc.
+ Copyright 2014-2015 Docker, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
diff --git a/Godeps/_workspace/src/github.com/docker/go-units/LICENSE.docs b/vendor/github.com/docker/spdystream/LICENSE.docs
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/go-units/LICENSE.docs
rename to vendor/github.com/docker/spdystream/LICENSE.docs
diff --git a/vendor/github.com/docker/spdystream/MAINTAINERS b/vendor/github.com/docker/spdystream/MAINTAINERS
new file mode 100644
index 0000000000000000000000000000000000000000..14e263325c708b3441b2d42d3930751e9b43023b
--- /dev/null
+++ b/vendor/github.com/docker/spdystream/MAINTAINERS
@@ -0,0 +1,28 @@
+# Spdystream maintainers file
+#
+# This file describes who runs the docker/spdystream project and how.
+# This is a living document - if you see something out of date or missing, speak up!
+#
+# It is structured to be consumable by both humans and programs.
+# To extract its contents programmatically, use any TOML-compliant parser.
+#
+# This file is compiled into the MAINTAINERS file in docker/opensource.
+#
+[Org]
+ [Org."Core maintainers"]
+ people = [
+ "dmcgowan",
+ ]
+
+[people]
+
+# A reference list of all people associated with the project.
+# All other sections should refer to people by their canonical key
+# in the people section.
+
+ # ADD YOURSELF HERE IN ALPHABETICAL ORDER
+
+ [people.dmcgowan]
+ Name = "Derek McGowan"
+ Email = "derek@docker.com"
+ GitHub = "dmcgowan"
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/README.md b/vendor/github.com/docker/spdystream/README.md
similarity index 72%
rename from Godeps/_workspace/src/github.com/docker/spdystream/README.md
rename to vendor/github.com/docker/spdystream/README.md
index 076b17919c085770724bec0664e6dbfd174bbe0b..11cccd0a09e4301773d4747bb69ccbfdaf0fa8e9 100644
--- a/Godeps/_workspace/src/github.com/docker/spdystream/README.md
+++ b/vendor/github.com/docker/spdystream/README.md
@@ -74,5 +74,4 @@ func main() {
## Copyright and license
-Code and documentation copyright 2013-2014 Docker, inc. Code released under the Apache 2.0 license.
-Docs released under Creative commons.
+Copyright © 2014-2015 Docker, Inc. All rights reserved, except as follows. Code is released under the Apache 2.0 license. The README.md file, and files in the "docs" folder are licensed under the Creative Commons Attribution 4.0 International License under the terms and conditions set forth in the file "LICENSE.docs". You may obtain a duplicate copy of the same license, titled CC-BY-SA-4.0, at http://creativecommons.org/licenses/by/4.0/.
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/connection.go b/vendor/github.com/docker/spdystream/connection.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/docker/spdystream/connection.go
rename to vendor/github.com/docker/spdystream/connection.go
index f5ef2a999dd195b1db28d57bd31178c8565b142d..6031a0db1ab494837dd6c9ca76e3bd6d5105a5b8 100644
--- a/Godeps/_workspace/src/github.com/docker/spdystream/connection.go
+++ b/vendor/github.com/docker/spdystream/connection.go
@@ -33,24 +33,28 @@ type idleAwareFramer struct {
conn *Connection
writeLock sync.Mutex
resetChan chan struct{}
+ setTimeoutLock sync.Mutex
setTimeoutChan chan time.Duration
timeout time.Duration
}
func newIdleAwareFramer(framer *spdy.Framer) *idleAwareFramer {
iaf := &idleAwareFramer{
- f: framer,
- resetChan: make(chan struct{}, 2),
- setTimeoutChan: make(chan time.Duration),
+ f: framer,
+ resetChan: make(chan struct{}, 2),
+ // setTimeoutChan needs to be buffered to avoid deadlocks when calling setIdleTimeout at about
+ // the same time the connection is being closed
+ setTimeoutChan: make(chan time.Duration, 1),
}
return iaf
}
func (i *idleAwareFramer) monitor() {
var (
- timer *time.Timer
- expired <-chan time.Time
- resetChan = i.resetChan
+ timer *time.Timer
+ expired <-chan time.Time
+ resetChan = i.resetChan
+ setTimeoutChan = i.setTimeoutChan
)
Loop:
for {
@@ -103,11 +107,21 @@ Loop:
}
}()
+ go func() {
+ for _ = range setTimeoutChan {
+ }
+ }()
+
i.writeLock.Lock()
close(resetChan)
i.resetChan = nil
i.writeLock.Unlock()
+ i.setTimeoutLock.Lock()
+ close(i.setTimeoutChan)
+ i.setTimeoutChan = nil
+ i.setTimeoutLock.Unlock()
+
break Loop
}
}
@@ -148,6 +162,17 @@ func (i *idleAwareFramer) ReadFrame() (spdy.Frame, error) {
return frame, nil
}
+func (i *idleAwareFramer) setIdleTimeout(timeout time.Duration) {
+ i.setTimeoutLock.Lock()
+ defer i.setTimeoutLock.Unlock()
+
+ if i.setTimeoutChan == nil {
+ return
+ }
+
+ i.setTimeoutChan <- timeout
+}
+
type Connection struct {
conn net.Conn
framer *idleAwareFramer
@@ -295,6 +320,7 @@ func (s *Connection) Serve(newHandler StreamHandler) {
partitionRoundRobin int
goAwayFrame *spdy.GoAwayFrame
)
+Loop:
for {
readFrame, err := s.framer.ReadFrame()
if err != nil {
@@ -337,7 +363,7 @@ func (s *Connection) Serve(newHandler StreamHandler) {
case *spdy.GoAwayFrame:
// hold on to the go away frame and exit the loop
goAwayFrame = frame
- break
+ break Loop
default:
priority = 7
partition = partitionRoundRobin
@@ -794,7 +820,7 @@ func (s *Connection) SetCloseTimeout(timeout time.Duration) {
// SetIdleTimeout sets the amount of time the connection may sit idle before
// it is forcefully terminated.
func (s *Connection) SetIdleTimeout(timeout time.Duration) {
- s.framer.setTimeoutChan <- timeout
+ s.framer.setIdleTimeout(timeout)
}
func (s *Connection) sendHeaders(headers http.Header, stream *Stream, fin bool) error {
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/handlers.go b/vendor/github.com/docker/spdystream/handlers.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/handlers.go
rename to vendor/github.com/docker/spdystream/handlers.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/priority.go b/vendor/github.com/docker/spdystream/priority.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/priority.go
rename to vendor/github.com/docker/spdystream/priority.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/spdy/dictionary.go b/vendor/github.com/docker/spdystream/spdy/dictionary.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/spdy/dictionary.go
rename to vendor/github.com/docker/spdystream/spdy/dictionary.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/spdy/read.go b/vendor/github.com/docker/spdystream/spdy/read.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/spdy/read.go
rename to vendor/github.com/docker/spdystream/spdy/read.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/spdy/types.go b/vendor/github.com/docker/spdystream/spdy/types.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/spdy/types.go
rename to vendor/github.com/docker/spdystream/spdy/types.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/spdy/write.go b/vendor/github.com/docker/spdystream/spdy/write.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/spdy/write.go
rename to vendor/github.com/docker/spdystream/spdy/write.go
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/stream.go b/vendor/github.com/docker/spdystream/stream.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/docker/spdystream/stream.go
rename to vendor/github.com/docker/spdystream/stream.go
index 66b342d668cd33100037fe84fbbcbcbf726a6c2b..f9e9ee267f861268345aa5ad37836ef96359b1ba 100644
--- a/Godeps/_workspace/src/github.com/docker/spdystream/stream.go
+++ b/vendor/github.com/docker/spdystream/stream.go
@@ -170,6 +170,11 @@ func (s *Stream) Reset() error {
}
func (s *Stream) resetStream() error {
+ // Always call closeRemoteChannels, even if s.finished is already true.
+ // This makes it so that stream.Close() followed by stream.Reset() allows
+ // stream.Read() to unblock.
+ s.closeRemoteChannels()
+
s.finishLock.Lock()
if s.finished {
s.finishLock.Unlock()
@@ -178,8 +183,6 @@ func (s *Stream) resetStream() error {
s.finished = true
s.finishLock.Unlock()
- s.closeRemoteChannels()
-
resetFrame := &spdy.RstStreamFrame{
StreamId: s.streamId,
Status: spdy.Cancel,
@@ -320,8 +323,5 @@ func (s *Stream) closeRemoteChannels() {
case <-s.closeChan:
default:
close(s.closeChan)
- s.dataLock.Lock()
- defer s.dataLock.Unlock()
- close(s.dataChan)
}
}
diff --git a/Godeps/_workspace/src/github.com/docker/spdystream/utils.go b/vendor/github.com/docker/spdystream/utils.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/docker/spdystream/utils.go
rename to vendor/github.com/docker/spdystream/utils.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/.gitignore b/vendor/github.com/emicklei/go-restful/.gitignore
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/.gitignore
rename to vendor/github.com/emicklei/go-restful/.gitignore
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md b/vendor/github.com/emicklei/go-restful/CHANGES.md
similarity index 96%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md
rename to vendor/github.com/emicklei/go-restful/CHANGES.md
index 45bd2012930f244abcc20cde3967e6272d25101b..070bca7cdc46daf413d7ae911daac26e6759a19a 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md
+++ b/vendor/github.com/emicklei/go-restful/CHANGES.md
@@ -1,5 +1,9 @@
Change history of go-restful
=
+2016-02-14
+- take the qualify factor of the Accept header mediatype into account when deciding the contentype of the response
+- add constructors for custom entity accessors for xml and json
+
2015-09-27
- rename new WriteStatusAnd... to WriteHeaderAnd... for consistency
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/LICENSE b/vendor/github.com/emicklei/go-restful/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/LICENSE
rename to vendor/github.com/emicklei/go-restful/LICENSE
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/README.md b/vendor/github.com/emicklei/go-restful/README.md
similarity index 91%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/README.md
rename to vendor/github.com/emicklei/go-restful/README.md
index 8f954c0163c03a1d8fcb862a66d40e45c9fec095..cfe6d0a916b6791e956a046f1010c4d762c7cab4 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/README.md
+++ b/vendor/github.com/emicklei/go-restful/README.md
@@ -40,7 +40,7 @@ func (u UserResource) findUser(request *restful.Request, response *restful.Respo
- Routes for request → function mapping with path parameter (e.g. {id}) support
- Configurable router:
- - Routing algorithm after [JSR311](http://jsr311.java.net/nonav/releases/1.1/spec/spec.html) that is implemented using (but doest **not** accept) regular expressions (See RouterJSR311 which is used by default)
+ - Routing algorithm after [JSR311](http://jsr311.java.net/nonav/releases/1.1/spec/spec.html) that is implemented using (but does **not** accept) regular expressions (See RouterJSR311 which is used by default)
- Fast routing algorithm that allows static elements, regular expressions and dynamic parameters in the URL path (e.g. /meetings/{id} or /static/{subpath:*}, See CurlyRouter)
- Request API for reading structs from JSON/XML and accesing parameters (path,query,header)
- Response API for writing structs to JSON/XML and setting headers
@@ -61,8 +61,8 @@ func (u UserResource) findUser(request *restful.Request, response *restful.Respo
- [Documentation on godoc.org](http://godoc.org/github.com/emicklei/go-restful)
- [Code examples](https://github.com/emicklei/go-restful/tree/master/examples)
-- [Example posted on blog](http://ernestmicklei.com/2012/11/24/go-restful-first-working-example/)
-- [Design explained on blog](http://ernestmicklei.com/2012/11/11/go-restful-api-design/)
+- [Example posted on blog](http://ernestmicklei.com/2012/11/go-restful-first-working-example/)
+- [Design explained on blog](http://ernestmicklei.com/2012/11/go-restful-api-design/)
- [sourcegraph](https://sourcegraph.com/github.com/emicklei/go-restful)
- [gopkg.in](https://gopkg.in/emicklei/go-restful.v1)
- [showcase: Mora - MongoDB REST Api server](https://github.com/emicklei/mora)
@@ -71,4 +71,4 @@ func (u UserResource) findUser(request *restful.Request, response *restful.Respo
(c) 2012 - 2015, http://ernestmicklei.com. MIT License
-Type ```git shortlog -s``` for a full list of contributors.
\ No newline at end of file
+Type ```git shortlog -s``` for a full list of contributors.
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/Srcfile b/vendor/github.com/emicklei/go-restful/Srcfile
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/Srcfile
rename to vendor/github.com/emicklei/go-restful/Srcfile
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/bench_test.sh b/vendor/github.com/emicklei/go-restful/bench_test.sh
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/bench_test.sh
rename to vendor/github.com/emicklei/go-restful/bench_test.sh
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/compress.go b/vendor/github.com/emicklei/go-restful/compress.go
similarity index 87%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/compress.go
rename to vendor/github.com/emicklei/go-restful/compress.go
index 66f3603e4e2e73efb16ab45d312c45cc62dd7d3f..220b37712f558ed12ffc6d42aa228f6e988ae264 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/compress.go
+++ b/vendor/github.com/emicklei/go-restful/compress.go
@@ -5,10 +5,12 @@ package restful
// that can be found in the LICENSE file.
import (
+ "bufio"
"compress/gzip"
"compress/zlib"
"errors"
"io"
+ "net"
"net/http"
"strings"
)
@@ -69,6 +71,17 @@ func (c *CompressingResponseWriter) isCompressorClosed() bool {
return nil == c.compressor
}
+// Hijack implements the Hijacker interface
+// This is especially useful when combining Container.EnabledContentEncoding
+// in combination with websockets (for instance gorilla/websocket)
+func (c *CompressingResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ hijacker, ok := c.writer.(http.Hijacker)
+ if !ok {
+ return nil, nil, errors.New("ResponseWriter doesn't support Hijacker interface")
+ }
+ return hijacker.Hijack()
+}
+
// WantsCompressedResponse reads the Accept-Encoding header to see if and which encoding is requested.
func wantsCompressedResponse(httpRequest *http.Request) (bool, string) {
header := httpRequest.Header.Get(HEADER_AcceptEncoding)
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/compressor_cache.go b/vendor/github.com/emicklei/go-restful/compressor_cache.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/compressor_cache.go
rename to vendor/github.com/emicklei/go-restful/compressor_cache.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/compressor_pools.go b/vendor/github.com/emicklei/go-restful/compressor_pools.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/compressor_pools.go
rename to vendor/github.com/emicklei/go-restful/compressor_pools.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/compressors.go b/vendor/github.com/emicklei/go-restful/compressors.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/compressors.go
rename to vendor/github.com/emicklei/go-restful/compressors.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/constants.go b/vendor/github.com/emicklei/go-restful/constants.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/constants.go
rename to vendor/github.com/emicklei/go-restful/constants.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/container.go b/vendor/github.com/emicklei/go-restful/container.go
similarity index 84%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/container.go
rename to vendor/github.com/emicklei/go-restful/container.go
index 59f34abea9c65f6479a1fe71367c894a03a1b034..4e53cccb93310746d27a60bcd7a9ebbba830f6d7 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/container.go
+++ b/vendor/github.com/emicklei/go-restful/container.go
@@ -6,6 +6,7 @@ package restful
import (
"bytes"
+ "errors"
"fmt"
"net/http"
"os"
@@ -83,34 +84,16 @@ func (c *Container) EnableContentEncoding(enabled bool) {
c.contentEncodingEnabled = enabled
}
-// Add a WebService to the Container. It will detect duplicate root paths and panic in that case.
+// Add a WebService to the Container. It will detect duplicate root paths and exit in that case.
func (c *Container) Add(service *WebService) *Container {
c.webServicesLock.Lock()
defer c.webServicesLock.Unlock()
- // If registered on root then no additional specific mapping is needed
- if !c.isRegisteredOnRoot {
- pattern := c.fixedPrefixPath(service.RootPath())
- // check if root path registration is needed
- if "/" == pattern || "" == pattern {
- c.ServeMux.HandleFunc("/", c.dispatch)
- c.isRegisteredOnRoot = true
- } else {
- // detect if registration already exists
- alreadyMapped := false
- for _, each := range c.webServices {
- if each.RootPath() == service.RootPath() {
- alreadyMapped = true
- break
- }
- }
- if !alreadyMapped {
- c.ServeMux.HandleFunc(pattern, c.dispatch)
- if !strings.HasSuffix(pattern, "/") {
- c.ServeMux.HandleFunc(pattern+"/", c.dispatch)
- }
- }
- }
+
+ // if rootPath was not set then lazy initialize it
+ if len(service.rootPath) == 0 {
+ service.Path("/")
}
+
// cannot have duplicate root paths
for _, each := range c.webServices {
if each.RootPath() == service.RootPath() {
@@ -118,24 +101,64 @@ func (c *Container) Add(service *WebService) *Container {
os.Exit(1)
}
}
- // if rootPath was not set then lazy initialize it
- if len(service.rootPath) == 0 {
- service.Path("/")
+
+ // If not registered on root then add specific mapping
+ if !c.isRegisteredOnRoot {
+ c.isRegisteredOnRoot = c.addHandler(service, c.ServeMux)
}
c.webServices = append(c.webServices, service)
return c
}
+// addHandler may set a new HandleFunc for the serveMux
+// this function must run inside the critical region protected by the webServicesLock.
+// returns true if the function was registered on root ("/")
+func (c *Container) addHandler(service *WebService, serveMux *http.ServeMux) bool {
+ pattern := fixedPrefixPath(service.RootPath())
+ // check if root path registration is needed
+ if "/" == pattern || "" == pattern {
+ serveMux.HandleFunc("/", c.dispatch)
+ return true
+ }
+ // detect if registration already exists
+ alreadyMapped := false
+ for _, each := range c.webServices {
+ if each.RootPath() == service.RootPath() {
+ alreadyMapped = true
+ break
+ }
+ }
+ if !alreadyMapped {
+ serveMux.HandleFunc(pattern, c.dispatch)
+ if !strings.HasSuffix(pattern, "/") {
+ serveMux.HandleFunc(pattern+"/", c.dispatch)
+ }
+ }
+ return false
+}
+
func (c *Container) Remove(ws *WebService) error {
+ if c.ServeMux == http.DefaultServeMux {
+ errMsg := fmt.Sprintf("[restful] cannot remove a WebService from a Container using the DefaultServeMux: ['%v']", ws)
+ log.Printf(errMsg)
+ return errors.New(errMsg)
+ }
c.webServicesLock.Lock()
defer c.webServicesLock.Unlock()
+ // build a new ServeMux and re-register all WebServices
+ newServeMux := http.NewServeMux()
newServices := []*WebService{}
- for ix := range c.webServices {
- if c.webServices[ix].rootPath != ws.rootPath {
- newServices = append(newServices, c.webServices[ix])
+ newIsRegisteredOnRoot := false
+ for _, each := range c.webServices {
+ if each.rootPath != ws.rootPath {
+ // If not registered on root then add specific mapping
+ if !newIsRegisteredOnRoot {
+ newIsRegisteredOnRoot = c.addHandler(each, newServeMux)
+ }
+ newServices = append(newServices, each)
}
}
- c.webServices = newServices
+ c.webServices, c.ServeMux, c.isRegisteredOnRoot = newServices, newServeMux, newIsRegisteredOnRoot
return nil
}
@@ -251,7 +274,7 @@ func (c *Container) dispatch(httpWriter http.ResponseWriter, httpRequest *http.R
}
// fixedPrefixPath returns the fixed part of the partspec ; it may include template vars {}
-func (c Container) fixedPrefixPath(pathspec string) string {
+func fixedPrefixPath(pathspec string) string {
varBegin := strings.Index(pathspec, "{")
if -1 == varBegin {
return pathspec
@@ -260,12 +283,12 @@ func (c Container) fixedPrefixPath(pathspec string) string {
}
// ServeHTTP implements net/http.Handler therefore a Container can be a Handler in a http.Server
-func (c Container) ServeHTTP(httpwriter http.ResponseWriter, httpRequest *http.Request) {
+func (c *Container) ServeHTTP(httpwriter http.ResponseWriter, httpRequest *http.Request) {
c.ServeMux.ServeHTTP(httpwriter, httpRequest)
}
// Handle registers the handler for the given pattern. If a handler already exists for pattern, Handle panics.
-func (c Container) Handle(pattern string, handler http.Handler) {
+func (c *Container) Handle(pattern string, handler http.Handler) {
c.ServeMux.Handle(pattern, handler)
}
@@ -295,7 +318,7 @@ func (c *Container) Filter(filter FilterFunction) {
}
// RegisteredWebServices returns the collections of added WebServices
-func (c Container) RegisteredWebServices() []*WebService {
+func (c *Container) RegisteredWebServices() []*WebService {
c.webServicesLock.RLock()
defer c.webServicesLock.RUnlock()
result := make([]*WebService, len(c.webServices))
@@ -306,7 +329,7 @@ func (c Container) RegisteredWebServices() []*WebService {
}
// computeAllowedMethods returns a list of HTTP methods that are valid for a Request
-func (c Container) computeAllowedMethods(req *Request) []string {
+func (c *Container) computeAllowedMethods(req *Request) []string {
// Go through all RegisteredWebServices() and all its Routes to collect the options
methods := []string{}
requestPath := req.Request.URL.Path
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/cors_filter.go b/vendor/github.com/emicklei/go-restful/cors_filter.go
similarity index 75%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/cors_filter.go
rename to vendor/github.com/emicklei/go-restful/cors_filter.go
index cd9e7fd291f0f9a1fd6c45ebef74a7a9a2d08930..1efeef072d03efe82bd3f83712f3f7be67b4d299 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/cors_filter.go
+++ b/vendor/github.com/emicklei/go-restful/cors_filter.go
@@ -5,6 +5,7 @@ package restful
// that can be found in the LICENSE file.
import (
+ "regexp"
"strconv"
"strings"
)
@@ -19,11 +20,13 @@ import (
type CrossOriginResourceSharing struct {
ExposeHeaders []string // list of Header names
AllowedHeaders []string // list of Header names
- AllowedDomains []string // list of allowed values for Http Origin. If empty all are allowed.
+ AllowedDomains []string // list of allowed values for Http Origin. An allowed value can be a regular expression to support subdomain matching. If empty all are allowed.
AllowedMethods []string
MaxAge int // number of seconds before requiring new Options request
CookiesAllowed bool
Container *Container
+
+ allowedOriginPatterns []*regexp.Regexp // internal field for origin regexp check.
}
// Filter is a filter function that implements the CORS flow as documented on http://enable-cors.org/server.html
@@ -37,21 +40,12 @@ func (c CrossOriginResourceSharing) Filter(req *Request, resp *Response, chain *
chain.ProcessFilter(req, resp)
return
}
- if len(c.AllowedDomains) > 0 { // if provided then origin must be included
- included := false
- for _, each := range c.AllowedDomains {
- if each == origin {
- included = true
- break
- }
- }
- if !included {
- if trace {
- traceLogger.Printf("HTTP Origin:%s is not part of %v", origin, c.AllowedDomains)
- }
- chain.ProcessFilter(req, resp)
- return
+ if !c.isOriginAllowed(origin) { // check whether this origin is allowed
+ if trace {
+ traceLogger.Printf("HTTP Origin:%s is not part of %v, neither matches any part of %v", origin, c.AllowedDomains, c.allowedOriginPatterns)
}
+ chain.ProcessFilter(req, resp)
+ return
}
if req.Request.Method != "OPTIONS" {
c.doActualRequest(req, resp)
@@ -74,7 +68,11 @@ func (c CrossOriginResourceSharing) doActualRequest(req *Request, resp *Response
func (c *CrossOriginResourceSharing) doPreflightRequest(req *Request, resp *Response) {
if len(c.AllowedMethods) == 0 {
- c.AllowedMethods = c.Container.computeAllowedMethods(req)
+ if c.Container == nil {
+ c.AllowedMethods = DefaultContainer.computeAllowedMethods(req)
+ } else {
+ c.AllowedMethods = c.Container.computeAllowedMethods(req)
+ }
}
acrm := req.Request.Header.Get(HEADER_AccessControlRequestMethod)
@@ -124,13 +122,32 @@ func (c CrossOriginResourceSharing) isOriginAllowed(origin string) bool {
if len(c.AllowedDomains) == 0 {
return true
}
+
allowed := false
- for _, each := range c.AllowedDomains {
- if each == origin {
+ for _, domain := range c.AllowedDomains {
+ if domain == origin {
allowed = true
break
}
}
+
+ if !allowed {
+ if len(c.allowedOriginPatterns) == 0 {
+ // compile allowed domains to allowed origin patterns
+ allowedOriginRegexps, err := compileRegexps(c.AllowedDomains)
+ if err != nil {
+ return false
+ }
+ c.allowedOriginPatterns = allowedOriginRegexps
+ }
+
+ for _, pattern := range c.allowedOriginPatterns {
+ if allowed = pattern.MatchString(origin); allowed {
+ break
+ }
+ }
+ }
+
return allowed
}
@@ -170,3 +187,16 @@ func (c CrossOriginResourceSharing) isValidAccessControlRequestHeader(header str
}
return false
}
+
+// Take a list of strings and compile them into a list of regular expressions.
+func compileRegexps(regexpStrings []string) ([]*regexp.Regexp, error) {
+ regexps := []*regexp.Regexp{}
+ for _, regexpStr := range regexpStrings {
+ r, err := regexp.Compile(regexpStr)
+ if err != nil {
+ return regexps, err
+ }
+ regexps = append(regexps, r)
+ }
+ return regexps, nil
+}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/coverage.sh b/vendor/github.com/emicklei/go-restful/coverage.sh
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/coverage.sh
rename to vendor/github.com/emicklei/go-restful/coverage.sh
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go b/vendor/github.com/emicklei/go-restful/curly.go
similarity index 93%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go
rename to vendor/github.com/emicklei/go-restful/curly.go
index ce284f74768052258fb03864997470e2ea34ac02..185300dbc73d5b7830731fc0f25b3e4cd33cf234 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go
+++ b/vendor/github.com/emicklei/go-restful/curly.go
@@ -44,16 +44,16 @@ func (c CurlyRouter) SelectRoute(
}
// selectRoutes return a collection of Route from a WebService that matches the path tokens from the request.
-func (c CurlyRouter) selectRoutes(ws *WebService, requestTokens []string) []Route {
- candidates := &sortableCurlyRoutes{[]*curlyRoute{}}
+func (c CurlyRouter) selectRoutes(ws *WebService, requestTokens []string) sortableCurlyRoutes {
+ candidates := sortableCurlyRoutes{}
for _, each := range ws.routes {
matches, paramCount, staticCount := c.matchesRouteByPathTokens(each.pathParts, requestTokens)
if matches {
- candidates.add(&curlyRoute{each, paramCount, staticCount}) // TODO make sure Routes() return pointers?
+ candidates.add(curlyRoute{each, paramCount, staticCount}) // TODO make sure Routes() return pointers?
}
}
sort.Sort(sort.Reverse(candidates))
- return candidates.routes()
+ return candidates
}
// matchesRouteByPathTokens computes whether it matches, howmany parameters do match and what the number of static path elements are.
@@ -110,9 +110,9 @@ func (c CurlyRouter) regularMatchesPathToken(routeToken string, colon int, reque
// detectRoute selectes from a list of Route the first match by inspecting both the Accept and Content-Type
// headers of the Request. See also RouterJSR311 in jsr311.go
-func (c CurlyRouter) detectRoute(candidateRoutes []Route, httpRequest *http.Request) (*Route, error) {
+func (c CurlyRouter) detectRoute(candidateRoutes sortableCurlyRoutes, httpRequest *http.Request) (*Route, error) {
// tracing is done inside detectRoute
- return RouterJSR311{}.detectRoute(candidateRoutes, httpRequest)
+ return RouterJSR311{}.detectRoute(candidateRoutes.routes(), httpRequest)
}
// detectWebService returns the best matching webService given the list of path tokens.
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_route.go b/vendor/github.com/emicklei/go-restful/curly_route.go
similarity index 58%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/curly_route.go
rename to vendor/github.com/emicklei/go-restful/curly_route.go
index 3edab72fd80364fb4aa7b7d5c8f6de91c1ba2c7d..296f94650e655e7cc0473f109e8b3fef7fb9a712 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_route.go
+++ b/vendor/github.com/emicklei/go-restful/curly_route.go
@@ -11,30 +11,28 @@ type curlyRoute struct {
staticCount int
}
-type sortableCurlyRoutes struct {
- candidates []*curlyRoute
-}
+type sortableCurlyRoutes []curlyRoute
-func (s *sortableCurlyRoutes) add(route *curlyRoute) {
- s.candidates = append(s.candidates, route)
+func (s *sortableCurlyRoutes) add(route curlyRoute) {
+ *s = append(*s, route)
}
-func (s *sortableCurlyRoutes) routes() (routes []Route) {
- for _, each := range s.candidates {
+func (s sortableCurlyRoutes) routes() (routes []Route) {
+ for _, each := range s {
routes = append(routes, each.route) // TODO change return type
}
return routes
}
-func (s *sortableCurlyRoutes) Len() int {
- return len(s.candidates)
+func (s sortableCurlyRoutes) Len() int {
+ return len(s)
}
-func (s *sortableCurlyRoutes) Swap(i, j int) {
- s.candidates[i], s.candidates[j] = s.candidates[j], s.candidates[i]
+func (s sortableCurlyRoutes) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
}
-func (s *sortableCurlyRoutes) Less(i, j int) bool {
- ci := s.candidates[i]
- cj := s.candidates[j]
+func (s sortableCurlyRoutes) Less(i, j int) bool {
+ ci := s[i]
+ cj := s[j]
// primary key
if ci.staticCount < cj.staticCount {
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/doc.go b/vendor/github.com/emicklei/go-restful/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/doc.go
rename to vendor/github.com/emicklei/go-restful/doc.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/entity_accessors.go b/vendor/github.com/emicklei/go-restful/entity_accessors.go
similarity index 83%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/entity_accessors.go
rename to vendor/github.com/emicklei/go-restful/entity_accessors.go
index e3ab79d9b12664fe30de1ede48ed139256bfea68..6ecf6c7f897b11a956232bc3eb51e654498c9601 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/entity_accessors.go
+++ b/vendor/github.com/emicklei/go-restful/entity_accessors.go
@@ -36,8 +36,8 @@ type entityReaderWriters struct {
}
func init() {
- RegisterEntityAccessor(MIME_JSON, entityJSONAccess{ContentType: MIME_JSON})
- RegisterEntityAccessor(MIME_XML, entityXMLAccess{ContentType: MIME_XML})
+ RegisterEntityAccessor(MIME_JSON, NewEntityAccessorJSON(MIME_JSON))
+ RegisterEntityAccessor(MIME_XML, NewEntityAccessorXML(MIME_XML))
}
// RegisterEntityAccessor add/overrides the ReaderWriter for encoding content with this MIME type.
@@ -47,8 +47,20 @@ func RegisterEntityAccessor(mime string, erw EntityReaderWriter) {
entityAccessRegistry.accessors[mime] = erw
}
-// AccessorAt returns the registered ReaderWriter for this MIME type.
-func (r *entityReaderWriters) AccessorAt(mime string) (EntityReaderWriter, bool) {
+// NewEntityAccessorJSON returns a new EntityReaderWriter for accessing JSON content.
+// This package is already initialized with such an accessor using the MIME_JSON contentType.
+func NewEntityAccessorJSON(contentType string) EntityReaderWriter {
+ return entityJSONAccess{ContentType: contentType}
+}
+
+// NewEntityAccessorXML returns a new EntityReaderWriter for accessing XML content.
+// This package is already initialized with such an accessor using the MIME_XML contentType.
+func NewEntityAccessorXML(contentType string) EntityReaderWriter {
+ return entityXMLAccess{ContentType: contentType}
+}
+
+// accessorAt returns the registered ReaderWriter for this MIME type.
+func (r *entityReaderWriters) accessorAt(mime string) (EntityReaderWriter, bool) {
r.protection.RLock()
defer r.protection.RUnlock()
er, ok := r.accessors[mime]
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/filter.go b/vendor/github.com/emicklei/go-restful/filter.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/filter.go
rename to vendor/github.com/emicklei/go-restful/filter.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/install.sh b/vendor/github.com/emicklei/go-restful/install.sh
similarity index 79%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/install.sh
rename to vendor/github.com/emicklei/go-restful/install.sh
index 5fe03b56978fcc83c4ff8ecd61206b9264a8f3d5..36cbf25f82a3dd047e69fb1c79fcded3895866ab 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/install.sh
+++ b/vendor/github.com/emicklei/go-restful/install.sh
@@ -1,9 +1,10 @@
-cd examples
- ls *.go | xargs -I {} go build -o /tmp/ignore {}
- cd ..
-go fmt ...swagger && \
+go test -test.v ...restful && \
go test -test.v ...swagger && \
+go vet ...restful && \
+go fmt ...swagger && \
go install ...swagger && \
go fmt ...restful && \
-go test -test.v ...restful && \
-go install ...restful
\ No newline at end of file
+go install ...restful
+cd examples
+ ls *.go | xargs -I {} go build -o /tmp/ignore {}
+ cd ..
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go b/vendor/github.com/emicklei/go-restful/jsr311.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go
rename to vendor/github.com/emicklei/go-restful/jsr311.go
index b4fa9bbae69fad45f6e42f993101618eccb2e9d3..511444ac6854a1f9d0b9f2d1b8102d5d43ab2cce 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go
+++ b/vendor/github.com/emicklei/go-restful/jsr311.go
@@ -74,7 +74,7 @@ func (r RouterJSR311) detectRoute(routes []Route, httpRequest *http.Request) (*R
// accept
outputMediaOk := []Route{}
accept := httpRequest.Header.Get(HEADER_Accept)
- if accept == "" {
+ if len(accept) == 0 {
accept = "*/*"
}
for _, each := range inputMediaOk {
@@ -88,7 +88,8 @@ func (r RouterJSR311) detectRoute(routes []Route, httpRequest *http.Request) (*R
}
return nil, NewError(http.StatusNotAcceptable, "406: Not Acceptable")
}
- return r.bestMatchByMedia(outputMediaOk, contentType, accept), nil
+ // return r.bestMatchByMedia(outputMediaOk, contentType, accept), nil
+ return &outputMediaOk[0], nil
}
// http://jsr311.java.net/nonav/releases/1.1/spec/spec3.html#x3-360003.7.2
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/log/log.go b/vendor/github.com/emicklei/go-restful/log/log.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/log/log.go
rename to vendor/github.com/emicklei/go-restful/log/log.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/logger.go b/vendor/github.com/emicklei/go-restful/logger.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/logger.go
rename to vendor/github.com/emicklei/go-restful/logger.go
diff --git a/vendor/github.com/emicklei/go-restful/mime.go b/vendor/github.com/emicklei/go-restful/mime.go
new file mode 100644
index 0000000000000000000000000000000000000000..d7ea2b6157949919619c67ac90ff9c496fb6cf0c
--- /dev/null
+++ b/vendor/github.com/emicklei/go-restful/mime.go
@@ -0,0 +1,45 @@
+package restful
+
+import (
+ "strconv"
+ "strings"
+)
+
+type mime struct {
+ media string
+ quality float64
+}
+
+// insertMime adds a mime to a list and keeps it sorted by quality.
+func insertMime(l []mime, e mime) []mime {
+ for i, each := range l {
+ // if current mime has lower quality then insert before
+ if e.quality > each.quality {
+ left := append([]mime{}, l[0:i]...)
+ return append(append(left, e), l[i:]...)
+ }
+ }
+ return append(l, e)
+}
+
+// sortedMimes returns a list of mime sorted (desc) by its specified quality.
+func sortedMimes(accept string) (sorted []mime) {
+ for _, each := range strings.Split(accept, ",") {
+ typeAndQuality := strings.Split(strings.Trim(each, " "), ";")
+ if len(typeAndQuality) == 1 {
+ sorted = insertMime(sorted, mime{typeAndQuality[0], 1.0})
+ } else {
+ // take factor
+ parts := strings.Split(typeAndQuality[1], "=")
+ if len(parts) == 2 {
+ f, err := strconv.ParseFloat(parts[1], 64)
+ if err != nil {
+ traceLogger.Printf("unable to parse quality in %s, %v", each, err)
+ } else {
+ sorted = insertMime(sorted, mime{typeAndQuality[0], f})
+ }
+ }
+ }
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/options_filter.go b/vendor/github.com/emicklei/go-restful/options_filter.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/options_filter.go
rename to vendor/github.com/emicklei/go-restful/options_filter.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/parameter.go b/vendor/github.com/emicklei/go-restful/parameter.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/parameter.go
rename to vendor/github.com/emicklei/go-restful/parameter.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/path_expression.go b/vendor/github.com/emicklei/go-restful/path_expression.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/path_expression.go
rename to vendor/github.com/emicklei/go-restful/path_expression.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/request.go b/vendor/github.com/emicklei/go-restful/request.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/request.go
rename to vendor/github.com/emicklei/go-restful/request.go
index 988adc9848f17cd774adec77c6de3c04d116d711..3e4234697d6999a76d69c20509a5d4d02de22f03 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/request.go
+++ b/vendor/github.com/emicklei/go-restful/request.go
@@ -108,7 +108,7 @@ func (r *Request) ReadEntity(entityPointer interface{}) (err error) {
}
// lookup the EntityReader
- entityReader, ok := entityAccessRegistry.AccessorAt(contentType)
+ entityReader, ok := entityAccessRegistry.accessorAt(contentType)
if !ok {
return NewError(http.StatusBadRequest, "Unable to unmarshal content of type:"+contentType)
}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/response.go b/vendor/github.com/emicklei/go-restful/response.go
similarity index 86%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/response.go
rename to vendor/github.com/emicklei/go-restful/response.go
index 3798f18c838e9c29e67a7a08a9a08a5f16484964..971cd0b42ced8d88570bff3f53ddedc191994741 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/response.go
+++ b/vendor/github.com/emicklei/go-restful/response.go
@@ -7,7 +7,6 @@ package restful
import (
"errors"
"net/http"
- "strings"
)
// DEPRECATED, use DefaultResponseContentType(mime)
@@ -68,38 +67,39 @@ func (r *Response) SetRequestAccepts(mime string) {
// can write according to what the request wants (Accept) and what the Route can produce or what the restful defaults say.
// If called before WriteEntity and WriteHeader then a false return value can be used to write a 406: Not Acceptable.
func (r *Response) EntityWriter() (EntityReaderWriter, bool) {
- for _, qualifiedMime := range strings.Split(r.requestAccept, ",") {
- mime := strings.Trim(strings.Split(qualifiedMime, ";")[0], " ")
- if 0 == len(mime) || mime == "*/*" {
- for _, each := range r.routeProduces {
- if MIME_JSON == each {
- return entityAccessRegistry.AccessorAt(MIME_JSON)
- }
- if MIME_XML == each {
- return entityAccessRegistry.AccessorAt(MIME_XML)
+ sorted := sortedMimes(r.requestAccept)
+ for _, eachAccept := range sorted {
+ for _, eachProduce := range r.routeProduces {
+ if eachProduce == eachAccept.media {
+ if w, ok := entityAccessRegistry.accessorAt(eachAccept.media); ok {
+ return w, true
}
}
- } else { // mime is not blank; see if we have a match in Produces
+ }
+ if eachAccept.media == "*/*" {
for _, each := range r.routeProduces {
- if mime == each {
- if MIME_JSON == each {
- return entityAccessRegistry.AccessorAt(MIME_JSON)
- }
- if MIME_XML == each {
- return entityAccessRegistry.AccessorAt(MIME_XML)
- }
+ if w, ok := entityAccessRegistry.accessorAt(each); ok {
+ return w, true
}
}
}
}
- writer, ok := entityAccessRegistry.AccessorAt(r.requestAccept)
+ // if requestAccept is empty
+ writer, ok := entityAccessRegistry.accessorAt(r.requestAccept)
if !ok {
// if not registered then fallback to the defaults (if set)
if DefaultResponseMimeType == MIME_JSON {
- return entityAccessRegistry.AccessorAt(MIME_JSON)
+ return entityAccessRegistry.accessorAt(MIME_JSON)
}
if DefaultResponseMimeType == MIME_XML {
- return entityAccessRegistry.AccessorAt(MIME_XML)
+ return entityAccessRegistry.accessorAt(MIME_XML)
+ }
+ // Fallback to whatever the route says it can produce.
+ // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+ for _, each := range r.routeProduces {
+ if w, ok := entityAccessRegistry.accessorAt(each); ok {
+ return w, true
+ }
}
if trace {
traceLogger.Printf("no registered EntityReaderWriter found for %s", r.requestAccept)
@@ -130,25 +130,25 @@ func (r *Response) WriteHeaderAndEntity(status int, value interface{}) error {
}
// WriteAsXml is a convenience method for writing a value in xml (requires Xml tags on the value)
-// It uses the standard encoding/xml package for marshalling the valuel ; not using a registered EntityReaderWriter.
+// It uses the standard encoding/xml package for marshalling the value ; not using a registered EntityReaderWriter.
func (r *Response) WriteAsXml(value interface{}) error {
return writeXML(r, http.StatusOK, MIME_XML, value)
}
// WriteHeaderAndXml is a convenience method for writing a status and value in xml (requires Xml tags on the value)
-// It uses the standard encoding/xml package for marshalling the valuel ; not using a registered EntityReaderWriter.
+// It uses the standard encoding/xml package for marshalling the value ; not using a registered EntityReaderWriter.
func (r *Response) WriteHeaderAndXml(status int, value interface{}) error {
return writeXML(r, status, MIME_XML, value)
}
// WriteAsJson is a convenience method for writing a value in json.
-// It uses the standard encoding/json package for marshalling the valuel ; not using a registered EntityReaderWriter.
+// It uses the standard encoding/json package for marshalling the value ; not using a registered EntityReaderWriter.
func (r *Response) WriteAsJson(value interface{}) error {
return writeJSON(r, http.StatusOK, MIME_JSON, value)
}
// WriteJson is a convenience method for writing a value in Json with a given Content-Type.
-// It uses the standard encoding/json package for marshalling the valuel ; not using a registered EntityReaderWriter.
+// It uses the standard encoding/json package for marshalling the value ; not using a registered EntityReaderWriter.
func (r *Response) WriteJson(value interface{}, contentType string) error {
return writeJSON(r, http.StatusOK, contentType, value)
}
@@ -184,6 +184,15 @@ func (r *Response) WriteErrorString(httpStatus int, errorReason string) error {
return nil
}
+// Flush implements http.Flusher interface, which sends any buffered data to the client.
+func (r *Response) Flush() {
+ if f, ok := r.ResponseWriter.(http.Flusher); ok {
+ f.Flush()
+ } else if trace {
+ traceLogger.Printf("ResponseWriter %v doesn't support Flush", r)
+ }
+}
+
// WriteHeader is overridden to remember the Status Code that has been written.
// Changes to the Header of the response have no effect after this.
func (r *Response) WriteHeader(httpStatus int) {
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/route.go b/vendor/github.com/emicklei/go-restful/route.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/route.go
rename to vendor/github.com/emicklei/go-restful/route.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go b/vendor/github.com/emicklei/go-restful/route_builder.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go
rename to vendor/github.com/emicklei/go-restful/route_builder.go
index b49b7c74d35e4c9a0c6eaad7573e38b2d89140bf..8bc1ab684621f4b905347b4507e778fe3688cfb2 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go
+++ b/vendor/github.com/emicklei/go-restful/route_builder.go
@@ -128,7 +128,7 @@ func (b *RouteBuilder) Param(parameter *Parameter) *RouteBuilder {
return b
}
-// Operation allows you to document what the acutal method/function call is of the Route.
+// Operation allows you to document what the actual method/function call is of the Route.
// Unless called, the operation name is derived from the RouteFunction set using To(..).
func (b *RouteBuilder) Operation(name string) *RouteBuilder {
b.operation = name
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/router.go b/vendor/github.com/emicklei/go-restful/router.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/router.go
rename to vendor/github.com/emicklei/go-restful/router.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/service_error.go b/vendor/github.com/emicklei/go-restful/service_error.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/service_error.go
rename to vendor/github.com/emicklei/go-restful/service_error.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/CHANGES.md b/vendor/github.com/emicklei/go-restful/swagger/CHANGES.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/CHANGES.md
rename to vendor/github.com/emicklei/go-restful/swagger/CHANGES.md
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/README.md b/vendor/github.com/emicklei/go-restful/swagger/README.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/README.md
rename to vendor/github.com/emicklei/go-restful/swagger/README.md
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/api_declaration_list.go b/vendor/github.com/emicklei/go-restful/swagger/api_declaration_list.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/api_declaration_list.go
rename to vendor/github.com/emicklei/go-restful/swagger/api_declaration_list.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/config.go b/vendor/github.com/emicklei/go-restful/swagger/config.go
similarity index 84%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/config.go
rename to vendor/github.com/emicklei/go-restful/swagger/config.go
index 944d988eefb390b7e4ef944f093859263d3840da..510d6fc133aa827935da51063d2b4eb9d679d848 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/config.go
+++ b/vendor/github.com/emicklei/go-restful/swagger/config.go
@@ -9,6 +9,8 @@ import (
// PostBuildDeclarationMapFunc can be used to modify the api declaration map.
type PostBuildDeclarationMapFunc func(apiDeclarationMap *ApiDeclarationList)
+type MapSchemaFormatFunc func(typeName string) string
+
type Config struct {
// url where the services are available, e.g. http://localhost:8080
// if left empty then the basePath of Swagger is taken from the actual request
@@ -31,4 +33,6 @@ type Config struct {
PostBuildHandler PostBuildDeclarationMapFunc
// Swagger global info struct
Info Info
+ // [optional] If set, model builder should call this handler to get addition typename-to-swagger-format-field convertion.
+ SchemaFormatHandler MapSchemaFormatFunc
}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_builder.go b/vendor/github.com/emicklei/go-restful/swagger/model_builder.go
similarity index 89%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_builder.go
rename to vendor/github.com/emicklei/go-restful/swagger/model_builder.go
index 3fbb20be26d20c8b19dd0ddb8f742a4b993b6c86..398e83049c44bb012f8411cd6fef904cfc1a6975 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_builder.go
+++ b/vendor/github.com/emicklei/go-restful/swagger/model_builder.go
@@ -14,6 +14,7 @@ type ModelBuildable interface {
type modelBuilder struct {
Models *ModelList
+ Config *Config
}
type documentable interface {
@@ -50,6 +51,14 @@ func (b modelBuilder) addModel(st reflect.Type, nameOverride string) *Model {
if b.isPrimitiveType(modelName) {
return nil
}
+ // golang encoding/json packages says array and slice values encode as
+ // JSON arrays, except that []byte encodes as a base64-encoded string.
+ // If we see a []byte here, treat it at as a primitive type (string)
+ // and deal with it in buildArrayTypeProperty.
+ if (st.Kind() == reflect.Slice || st.Kind() == reflect.Array) &&
+ st.Elem().Kind() == reflect.Uint8 {
+ return nil
+ }
// see if we already have visited this model
if _, ok := b.Models.At(modelName); ok {
return nil
@@ -178,8 +187,8 @@ func (b modelBuilder) buildProperty(field reflect.StructField, model *Model, mod
return jsonName, modelDescription, prop
case fieldKind == reflect.Map:
// if it's a map, it's unstructured, and swagger 1.2 can't handle it
- anyt := "any"
- prop.Type = &anyt
+ objectType := "object"
+ prop.Type = &objectType
return jsonName, modelDescription, prop
}
@@ -231,7 +240,7 @@ func (b modelBuilder) buildStructTypeProperty(field reflect.StructField, jsonNam
if field.Name == fieldType.Name() && field.Anonymous && !hasNamedJSONTag(field) {
// embedded struct
- sub := modelBuilder{new(ModelList)}
+ sub := modelBuilder{new(ModelList), b.Config}
sub.addModel(fieldType, "")
subKey := sub.keyFrom(fieldType)
// merge properties from sub
@@ -275,11 +284,17 @@ func (b modelBuilder) buildArrayTypeProperty(field reflect.StructField, jsonName
return jsonName, prop
}
fieldType := field.Type
+ if fieldType.Elem().Kind() == reflect.Uint8 {
+ stringt := "string"
+ prop.Type = &stringt
+ return jsonName, prop
+ }
var pType = "array"
prop.Type = &pType
+ isPrimitive := b.isPrimitiveType(fieldType.Elem().Name())
elemTypeName := b.getElementTypeName(modelName, jsonName, fieldType.Elem())
prop.Items = new(Item)
- if b.isPrimitiveType(elemTypeName) {
+ if isPrimitive {
mapped := b.jsonSchemaType(elemTypeName)
prop.Items.Type = &mapped
} else {
@@ -289,7 +304,9 @@ func (b modelBuilder) buildArrayTypeProperty(field reflect.StructField, jsonName
if fieldType.Elem().Kind() == reflect.Ptr {
fieldType = fieldType.Elem()
}
- b.addModel(fieldType.Elem(), elemTypeName)
+ if !isPrimitive {
+ b.addModel(fieldType.Elem(), elemTypeName)
+ }
return jsonName, prop
}
@@ -305,10 +322,18 @@ func (b modelBuilder) buildPointerTypeProperty(field reflect.StructField, jsonNa
if fieldType.Elem().Kind() == reflect.Slice || fieldType.Elem().Kind() == reflect.Array {
var pType = "array"
prop.Type = &pType
+ isPrimitive := b.isPrimitiveType(fieldType.Elem().Elem().Name())
elemName := b.getElementTypeName(modelName, jsonName, fieldType.Elem().Elem())
- prop.Items = &Item{Ref: &elemName}
- // add|overwrite model for element type
- b.addModel(fieldType.Elem().Elem(), elemName)
+ if isPrimitive {
+ primName := b.jsonSchemaType(elemName)
+ prop.Items = &Item{Ref: &primName}
+ } else {
+ prop.Items = &Item{Ref: &elemName}
+ }
+ if !isPrimitive {
+ // add|overwrite model for element type
+ b.addModel(fieldType.Elem().Elem(), elemName)
+ }
} else {
// non-array, pointer type
var pType = b.jsonSchemaType(fieldType.String()[1:]) // no star, include pkg path
@@ -335,9 +360,6 @@ func (b modelBuilder) getElementTypeName(modelName, jsonName string, t reflect.T
if t.Name() == "" {
return modelName + "." + jsonName
}
- if b.isPrimitiveType(t.Name()) {
- return b.jsonSchemaType(t.Name())
- }
return b.keyFrom(t)
}
@@ -352,6 +374,9 @@ func (b modelBuilder) keyFrom(st reflect.Type) string {
// see also https://golang.org/ref/spec#Numeric_types
func (b modelBuilder) isPrimitiveType(modelName string) bool {
+ if len(modelName) == 0 {
+ return false
+ }
return strings.Contains("uint uint8 uint16 uint32 uint64 int int8 int16 int32 int64 float32 float64 bool string byte rune time.Time", modelName)
}
@@ -399,6 +424,11 @@ func (b modelBuilder) jsonSchemaType(modelName string) string {
}
func (b modelBuilder) jsonSchemaFormat(modelName string) string {
+ if b.Config != nil && b.Config.SchemaFormatHandler != nil {
+ if mapped := b.Config.SchemaFormatHandler(modelName); mapped != "" {
+ return mapped
+ }
+ }
schemaMap := map[string]string{
"int": "int32",
"int32": "int32",
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_list.go b/vendor/github.com/emicklei/go-restful/swagger/model_list.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_list.go
rename to vendor/github.com/emicklei/go-restful/swagger/model_list.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_property_ext.go b/vendor/github.com/emicklei/go-restful/swagger/model_property_ext.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_property_ext.go
rename to vendor/github.com/emicklei/go-restful/swagger/model_property_ext.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_property_list.go b/vendor/github.com/emicklei/go-restful/swagger/model_property_list.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/model_property_list.go
rename to vendor/github.com/emicklei/go-restful/swagger/model_property_list.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/ordered_route_map.go b/vendor/github.com/emicklei/go-restful/swagger/ordered_route_map.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/ordered_route_map.go
rename to vendor/github.com/emicklei/go-restful/swagger/ordered_route_map.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger.go b/vendor/github.com/emicklei/go-restful/swagger/swagger.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger.go
rename to vendor/github.com/emicklei/go-restful/swagger/swagger.go
index 967b6711e8b87e82c14cd32ad8fd9de716f2d401..9c40833e7da98b0b3aa8a8bc99f15d00ad187c45 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger.go
+++ b/vendor/github.com/emicklei/go-restful/swagger/swagger.go
@@ -118,6 +118,7 @@ type ApiDeclaration struct {
ApiVersion string `json:"apiVersion"`
BasePath string `json:"basePath"`
ResourcePath string `json:"resourcePath"` // must start with /
+ Info Info `json:"info"`
Apis []Api `json:"apis,omitempty"`
Models ModelList `json:"models,omitempty"`
Produces []string `json:"produces,omitempty"`
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger_builder.go b/vendor/github.com/emicklei/go-restful/swagger/swagger_builder.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger_builder.go
rename to vendor/github.com/emicklei/go-restful/swagger/swagger_builder.go
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger_webservice.go b/vendor/github.com/emicklei/go-restful/swagger/swagger_webservice.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger_webservice.go
rename to vendor/github.com/emicklei/go-restful/swagger/swagger_webservice.go
index 8dc3d5f9ea62cb9c073badfa83263479158fa9cd..58dd6259022e62a5536d3cb1f36904cd7f6c408e 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/swagger/swagger_webservice.go
+++ b/vendor/github.com/emicklei/go-restful/swagger/swagger_webservice.go
@@ -241,7 +241,7 @@ func (sws SwaggerService) composeDeclaration(ws *restful.WebService, pathPrefix
DataTypeFields: DataTypeFields{Type: &voidString},
Parameters: []Parameter{},
Nickname: route.Operation,
- ResponseMessages: composeResponseMessages(route, &decl)}
+ ResponseMessages: composeResponseMessages(route, &decl, &sws.config)}
operation.Consumes = route.Consumes
operation.Produces = route.Produces
@@ -271,7 +271,7 @@ func withoutWildcard(path string) string {
}
// composeResponseMessages takes the ResponseErrors (if any) and creates ResponseMessages from them.
-func composeResponseMessages(route restful.Route, decl *ApiDeclaration) (messages []ResponseMessage) {
+func composeResponseMessages(route restful.Route, decl *ApiDeclaration, config *Config) (messages []ResponseMessage) {
if route.ResponseErrors == nil {
return messages
}
@@ -294,7 +294,7 @@ func composeResponseMessages(route restful.Route, decl *ApiDeclaration) (message
if isCollection {
modelName = "array[" + modelName + "]"
}
- modelBuilder{&decl.Models}.addModel(st, "")
+ modelBuilder{Models: &decl.Models, Config: config}.addModel(st, "")
// reference the model
message.ResponseModel = modelName
}
@@ -332,11 +332,11 @@ func detectCollectionType(st reflect.Type) (bool, reflect.Type) {
// addModelFromSample creates and adds (or overwrites) a Model from a sample resource
func (sws SwaggerService) addModelFromSampleTo(operation *Operation, isResponse bool, sample interface{}, models *ModelList) {
if isResponse {
- type_, items := asDataType(sample)
+ type_, items := asDataType(sample, &sws.config)
operation.Type = type_
operation.Items = items
}
- modelBuilder{models}.addModelFrom(sample)
+ modelBuilder{Models: models, Config: &sws.config}.addModelFrom(sample)
}
func asSwaggerParameter(param restful.ParameterData) Parameter {
@@ -411,7 +411,7 @@ func asParamType(kind int) string {
return ""
}
-func asDataType(any interface{}) (*string, *Item) {
+func asDataType(any interface{}, config *Config) (*string, *Item) {
// If it's not a collection, return the suggested model name
st := reflect.TypeOf(any)
isCollection, st := detectCollectionType(st)
@@ -424,7 +424,7 @@ func asDataType(any interface{}) (*string, *Item) {
// XXX: This is not very elegant
// We create an Item object referring to the given model
models := ModelList{}
- mb := modelBuilder{&models}
+ mb := modelBuilder{Models: &models, Config: config}
mb.addModelFrom(any)
elemTypeName := mb.getElementTypeName(modelName, "", st)
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go b/vendor/github.com/emicklei/go-restful/web_service.go
similarity index 94%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go
rename to vendor/github.com/emicklei/go-restful/web_service.go
index e89be70097c831728aab201ea9c869da178a93b4..2a51004f802e625e382f335faba33969c9443706 100644
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go
+++ b/vendor/github.com/emicklei/go-restful/web_service.go
@@ -1,7 +1,7 @@
package restful
import (
- "fmt"
+ "errors"
"os"
"sync"
@@ -36,9 +36,6 @@ func (w *WebService) SetDynamicRoutes(enable bool) {
// compilePathExpression ensures that the path is compiled into a RegEx for those routers that need it.
func (w *WebService) compilePathExpression() {
- if len(w.rootPath) == 0 {
- w.Path("/") // lazy initialize path
- }
compiled, err := newPathExpression(w.rootPath)
if err != nil {
log.Printf("[restful] invalid path:%s because:%v", w.rootPath, err)
@@ -54,12 +51,15 @@ func (w *WebService) ApiVersion(apiVersion string) *WebService {
}
// Version returns the API version for documentation purposes.
-func (w WebService) Version() string { return w.apiVersion }
+func (w *WebService) Version() string { return w.apiVersion }
// Path specifies the root URL template path of the WebService.
// All Routes will be relative to this path.
func (w *WebService) Path(root string) *WebService {
w.rootPath = root
+ if len(w.rootPath) == 0 {
+ w.rootPath = "/"
+ }
w.compilePathExpression()
return w
}
@@ -155,15 +155,20 @@ func (w *WebService) Route(builder *RouteBuilder) *WebService {
// RemoveRoute removes the specified route, looks for something that matches 'path' and 'method'
func (w *WebService) RemoveRoute(path, method string) error {
if !w.dynamicRoutes {
- return fmt.Errorf("dynamic routes are not enabled.")
+ return errors.New("dynamic routes are not enabled.")
}
w.routesLock.Lock()
defer w.routesLock.Unlock()
+ newRoutes := make([]Route, (len(w.routes) - 1))
+ current := 0
for ix := range w.routes {
if w.routes[ix].Method == method && w.routes[ix].Path == path {
- w.routes = append(w.routes[:ix], w.routes[ix+1:]...)
+ continue
}
+ newRoutes[current] = w.routes[ix]
+ current = current + 1
}
+ w.routes = newRoutes
return nil
}
@@ -187,7 +192,7 @@ func (w *WebService) Consumes(accepts ...string) *WebService {
}
// Routes returns the Routes associated with this WebService
-func (w WebService) Routes() []Route {
+func (w *WebService) Routes() []Route {
if !w.dynamicRoutes {
return w.routes
}
@@ -202,12 +207,12 @@ func (w WebService) Routes() []Route {
}
// RootPath returns the RootPath associated with this WebService. Default "/"
-func (w WebService) RootPath() string {
+func (w *WebService) RootPath() string {
return w.rootPath
}
// PathParameters return the path parameter names for (shared amoung its Routes)
-func (w WebService) PathParameters() []*Parameter {
+func (w *WebService) PathParameters() []*Parameter {
return w.pathParameters
}
@@ -224,7 +229,7 @@ func (w *WebService) Doc(plainText string) *WebService {
}
// Documentation returns it.
-func (w WebService) Documentation() string {
+func (w *WebService) Documentation() string {
return w.documentation
}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service_container.go b/vendor/github.com/emicklei/go-restful/web_service_container.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/emicklei/go-restful/web_service_container.go
rename to vendor/github.com/emicklei/go-restful/web_service_container.go
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore b/vendor/github.com/ghodss/yaml/.gitignore
similarity index 100%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore
rename to vendor/github.com/ghodss/yaml/.gitignore
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/.travis.yml b/vendor/github.com/ghodss/yaml/.travis.yml
similarity index 100%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/.travis.yml
rename to vendor/github.com/ghodss/yaml/.travis.yml
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE b/vendor/github.com/ghodss/yaml/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE
rename to vendor/github.com/ghodss/yaml/LICENSE
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/README.md b/vendor/github.com/ghodss/yaml/README.md
similarity index 58%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/README.md
rename to vendor/github.com/ghodss/yaml/README.md
index f8f7e369549c4ba1ad53170198752759ad9b6254..628497361d2780c3262d6ad411150872fe44696e 100644
--- a/Godeps/_workspace/src/github.com/ghodss/yaml/README.md
+++ b/vendor/github.com/ghodss/yaml/README.md
@@ -4,17 +4,17 @@
## Introduction
-A wrapper around [go-yaml](https://github.com/go-yaml/yaml) designed to enable a better way of handling YAML when marshaling to and from structs.
+A wrapper around [candiedyaml](https://github.com/cloudfoundry-incubator/candiedyaml) designed to enable a better way of handling YAML when marshaling to and from structs.
-In short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).
+In short, this library first converts YAML to JSON using candiedyaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike candiedyaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).
## Compatibility
-This package uses [go-yaml v2](https://github.com/go-yaml/yaml) and therefore supports [everything go-yaml supports](https://github.com/go-yaml/yaml#compatibility).
+This package uses [candiedyaml](https://github.com/cloudfoundry-incubator/candiedyaml) and therefore supports [everything candiedyaml supports](https://github.com/cloudfoundry-incubator/candiedyaml#candiedyaml).
## Caveats
-**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
+**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, candiedyaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
```
BAD:
@@ -44,6 +44,8 @@ import "github.com/ghodss/yaml"
Usage is very similar to the JSON library:
```go
+package main
+
import (
"fmt"
@@ -52,7 +54,7 @@ import (
type Person struct {
Name string `json:"name"` // Affects YAML field names too.
- Age int `json:"name"`
+ Age int `json:"age"`
}
func main() {
@@ -65,13 +67,13 @@ func main() {
}
fmt.Println(string(y))
/* Output:
- name: John
age: 30
+ name: John
*/
// Unmarshal the YAML back into a Person struct.
var p2 Person
- err := yaml.Unmarshal(y, &p2)
+ err = yaml.Unmarshal(y, &p2)
if err != nil {
fmt.Printf("err: %v\n", err)
return
@@ -86,6 +88,8 @@ func main() {
`yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available:
```go
+package main
+
import (
"fmt"
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/fields.go b/vendor/github.com/ghodss/yaml/fields.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/fields.go
rename to vendor/github.com/ghodss/yaml/fields.go
diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go b/vendor/github.com/ghodss/yaml/yaml.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go
rename to vendor/github.com/ghodss/yaml/yaml.go
index c02beacb9a41af2274c5e0f6a6c8d34c124882fb..0bb015b44c9ab2524ba26eb994a3dcf35068aaf6 100644
--- a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go
+++ b/vendor/github.com/ghodss/yaml/yaml.go
@@ -7,7 +7,7 @@ import (
"reflect"
"strconv"
- "gopkg.in/yaml.v2"
+ yaml "github.com/cloudfoundry-incubator/candiedyaml"
)
// Marshals the object into JSON then converts JSON to YAML and returns the
@@ -15,12 +15,12 @@ import (
func Marshal(o interface{}) ([]byte, error) {
j, err := json.Marshal(o)
if err != nil {
- return nil, fmt.Errorf("error marshaling into JSON: ", err)
+ return nil, fmt.Errorf("error marshaling into JSON: %v", err)
}
y, err := JSONToYAML(j)
if err != nil {
- return nil, fmt.Errorf("error converting JSON to YAML: ", err)
+ return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
}
return y, nil
@@ -48,7 +48,7 @@ func JSONToYAML(j []byte) ([]byte, error) {
var jsonObj interface{}
// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
// Go JSON library doesn't try to pick the right number type (int, float,
- // etc.) when unmarshling to interface{}, it just picks float64
+ // etc.) when unmarshalling to interface{}, it just picks float64
// universally. go-yaml does go through the effort of picking the right
// number type, so we can preserve number type throughout this process.
err := yaml.Unmarshal(j, &jsonObj)
diff --git a/vendor/github.com/gogo/protobuf/LICENSE b/vendor/github.com/gogo/protobuf/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..7be0cc7b62cf0c723fbb95bfc2e82ebdab213203
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/LICENSE
@@ -0,0 +1,36 @@
+Protocol Buffers for Go with Gadgets
+
+Copyright (c) 2013, The GoGo Authors. All rights reserved.
+http://github.com/gogo/protobuf
+
+Go support for Protocol Buffers - Google's data interchange format
+
+Copyright 2010 The Go Authors. All rights reserved.
+https://github.com/golang/protobuf
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/vendor/github.com/gogo/protobuf/proto/Makefile b/vendor/github.com/gogo/protobuf/proto/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..23a6b173440885c96adfeb78ba340f56944ecd37
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/Makefile
@@ -0,0 +1,43 @@
+# Go support for Protocol Buffers - Google's data interchange format
+#
+# Copyright 2010 The Go Authors. All rights reserved.
+# https://github.com/golang/protobuf
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+# * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+install:
+ go install
+
+test: install generate-test-pbs
+ go test
+
+
+generate-test-pbs:
+ make install
+ make -C testdata
+ protoc-min-version --version="3.0.0" --proto_path=.:../../../../ --gogo_out=. proto3_proto/proto3.proto
+ make
diff --git a/vendor/github.com/gogo/protobuf/proto/clone.go b/vendor/github.com/gogo/protobuf/proto/clone.go
new file mode 100644
index 0000000000000000000000000000000000000000..5d4cba4b51c6ceaa994a03a512aa46a9755a9def
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/clone.go
@@ -0,0 +1,234 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer deep copy and merge.
+// TODO: RawMessage.
+
+package proto
+
+import (
+ "log"
+ "reflect"
+ "strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(pb Message) Message {
+ in := reflect.ValueOf(pb)
+ if in.IsNil() {
+ return pb
+ }
+
+ out := reflect.New(in.Type().Elem())
+ // out is empty so a merge is a deep copy.
+ mergeStruct(out.Elem(), in.Elem())
+ return out.Interface().(Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+ in := reflect.ValueOf(src)
+ out := reflect.ValueOf(dst)
+ if out.IsNil() {
+ panic("proto: nil destination")
+ }
+ if in.Type() != out.Type() {
+ // Explicit test prior to mergeStruct so that mistyped nils will fail
+ panic("proto: type mismatch")
+ }
+ if in.IsNil() {
+ // Merging nil into non-nil is a quiet no-op
+ return
+ }
+ mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+ sprop := GetProperties(in.Type())
+ for i := 0; i < in.NumField(); i++ {
+ f := in.Type().Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
+ }
+
+ if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {
+ emOut := out.Addr().Interface().(extensionsBytes)
+ bIn := emIn.GetExtensions()
+ bOut := emOut.GetExtensions()
+ *bOut = append(*bOut, *bIn...)
+ } else if emIn, ok := extendable(in.Addr().Interface()); ok {
+ emOut, _ := extendable(out.Addr().Interface())
+ mIn, muIn := emIn.extensionsRead()
+ if mIn != nil {
+ mOut := emOut.extensionsWrite()
+ muIn.Lock()
+ mergeExtension(mOut, mIn)
+ muIn.Unlock()
+ }
+ }
+
+ uf := in.FieldByName("XXX_unrecognized")
+ if !uf.IsValid() {
+ return
+ }
+ uin := uf.Bytes()
+ if len(uin) > 0 {
+ out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+ }
+}
+
+// mergeAny performs a merge between two values of the same type.
+// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
+// prop is set if this is a struct field (it may be nil).
+func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
+ if in.Type() == protoMessageType {
+ if !in.IsNil() {
+ if out.IsNil() {
+ out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+ } else {
+ Merge(out.Interface().(Message), in.Interface().(Message))
+ }
+ }
+ return
+ }
+ switch in.Kind() {
+ case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+ reflect.String, reflect.Uint32, reflect.Uint64:
+ if !viaPtr && isProto3Zero(in) {
+ return
+ }
+ out.Set(in)
+ case reflect.Interface:
+ // Probably a oneof field; copy non-nil values.
+ if in.IsNil() {
+ return
+ }
+ // Allocate destination if it is not set, or set to a different type.
+ // Otherwise we will merge as normal.
+ if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
+ out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+ }
+ mergeAny(out.Elem(), in.Elem(), false, nil)
+ case reflect.Map:
+ if in.Len() == 0 {
+ return
+ }
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(in.Type()))
+ }
+ // For maps with value types of *T or []byte we need to deep copy each value.
+ elemKind := in.Type().Elem().Kind()
+ for _, key := range in.MapKeys() {
+ var val reflect.Value
+ switch elemKind {
+ case reflect.Ptr:
+ val = reflect.New(in.Type().Elem().Elem())
+ mergeAny(val, in.MapIndex(key), false, nil)
+ case reflect.Slice:
+ val = in.MapIndex(key)
+ val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+ default:
+ val = in.MapIndex(key)
+ }
+ out.SetMapIndex(key, val)
+ }
+ case reflect.Ptr:
+ if in.IsNil() {
+ return
+ }
+ if out.IsNil() {
+ out.Set(reflect.New(in.Elem().Type()))
+ }
+ mergeAny(out.Elem(), in.Elem(), true, nil)
+ case reflect.Slice:
+ if in.IsNil() {
+ return
+ }
+ if in.Type().Elem().Kind() == reflect.Uint8 {
+ // []byte is a scalar bytes field, not a repeated field.
+
+ // Edge case: if this is in a proto3 message, a zero length
+ // bytes field is considered the zero value, and should not
+ // be merged.
+ if prop != nil && prop.proto3 && in.Len() == 0 {
+ return
+ }
+
+ // Make a deep copy.
+ // Append to []byte{} instead of []byte(nil) so that we never end up
+ // with a nil result.
+ out.SetBytes(append([]byte{}, in.Bytes()...))
+ return
+ }
+ n := in.Len()
+ if out.IsNil() {
+ out.Set(reflect.MakeSlice(in.Type(), 0, n))
+ }
+ switch in.Type().Elem().Kind() {
+ case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+ reflect.String, reflect.Uint32, reflect.Uint64:
+ out.Set(reflect.AppendSlice(out, in))
+ default:
+ for i := 0; i < n; i++ {
+ x := reflect.Indirect(reflect.New(in.Type().Elem()))
+ mergeAny(x, in.Index(i), false, nil)
+ out.Set(reflect.Append(out, x))
+ }
+ }
+ case reflect.Struct:
+ mergeStruct(out, in)
+ default:
+ // unknown type, so not a protocol buffer
+ log.Printf("proto: don't know how to copy %v", in)
+ }
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+ for extNum, eIn := range in {
+ eOut := Extension{desc: eIn.desc}
+ if eIn.value != nil {
+ v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+ mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
+ eOut.value = v.Interface()
+ }
+ if eIn.enc != nil {
+ eOut.enc = make([]byte, len(eIn.enc))
+ copy(eOut.enc, eIn.enc)
+ }
+
+ out[extNum] = eOut
+ }
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode.go b/vendor/github.com/gogo/protobuf/proto/decode.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d6634cc085bae0a1bb1b408cfb9706ee9e11096
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode.go
@@ -0,0 +1,882 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// ErrInternalBadWireType is returned by generated code when an incorrect
+// wire type is encountered. It does not get returned to user code.
+var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+
+// The fundamental decoders that interpret bytes on the wire.
+// Those that take integer types all return uint64 and are
+// therefore of type valueDecoder.
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+ // x, n already 0
+ for shift := uint(0); shift < 64; shift += 7 {
+ if n >= len(buf) {
+ return 0, 0
+ }
+ b := uint64(buf[n])
+ n++
+ x |= (b & 0x7F) << shift
+ if (b & 0x80) == 0 {
+ return x, n
+ }
+ }
+
+ // The number is too large to represent in a 64-bit value.
+ return 0, 0
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+ // x, err already 0
+
+ i := p.index
+ l := len(p.buf)
+
+ for shift := uint(0); shift < 64; shift += 7 {
+ if i >= l {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ b := p.buf[i]
+ i++
+ x |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ p.index = i
+ return
+ }
+ }
+
+ // The number is too large to represent in a 64-bit value.
+ err = errOverflow
+ return
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+ // x, err already 0
+ i := p.index + 8
+ if i < 0 || i > len(p.buf) {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ p.index = i
+
+ x = uint64(p.buf[i-8])
+ x |= uint64(p.buf[i-7]) << 8
+ x |= uint64(p.buf[i-6]) << 16
+ x |= uint64(p.buf[i-5]) << 24
+ x |= uint64(p.buf[i-4]) << 32
+ x |= uint64(p.buf[i-3]) << 40
+ x |= uint64(p.buf[i-2]) << 48
+ x |= uint64(p.buf[i-1]) << 56
+ return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+ // x, err already 0
+ i := p.index + 4
+ if i < 0 || i > len(p.buf) {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ p.index = i
+
+ x = uint64(p.buf[i-4])
+ x |= uint64(p.buf[i-3]) << 8
+ x |= uint64(p.buf[i-2]) << 16
+ x |= uint64(p.buf[i-1]) << 24
+ return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+ x, err = p.DecodeVarint()
+ if err != nil {
+ return
+ }
+ x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+ return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+ x, err = p.DecodeVarint()
+ if err != nil {
+ return
+ }
+ x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+ return
+}
+
+// These are not ValueDecoders: they produce an array of bytes or a string.
+// bytes, embedded messages
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+ n, err := p.DecodeVarint()
+ if err != nil {
+ return nil, err
+ }
+
+ nb := int(n)
+ if nb < 0 {
+ return nil, fmt.Errorf("proto: bad byte length %d", nb)
+ }
+ end := p.index + nb
+ if end < p.index || end > len(p.buf) {
+ return nil, io.ErrUnexpectedEOF
+ }
+
+ if !alloc {
+ // todo: check if can get more uses of alloc=false
+ buf = p.buf[p.index:end]
+ p.index += nb
+ return
+ }
+
+ buf = make([]byte, nb)
+ copy(buf, p.buf[p.index:])
+ p.index += nb
+ return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+ buf, err := p.DecodeRawBytes(false)
+ if err != nil {
+ return
+ }
+ return string(buf), nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+// If the protocol buffer has extensions, and the field matches, add it as an extension.
+// Otherwise, if the XXX_unrecognized field exists, append the skipped data there.
+func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error {
+ oi := o.index
+
+ err := o.skip(t, tag, wire)
+ if err != nil {
+ return err
+ }
+
+ if !unrecField.IsValid() {
+ return nil
+ }
+
+ ptr := structPointer_Bytes(base, unrecField)
+
+ // Add the skipped field to struct field
+ obuf := o.buf
+
+ o.buf = *ptr
+ o.EncodeVarint(uint64(tag<<3 | wire))
+ *ptr = append(o.buf, obuf[oi:o.index]...)
+
+ o.buf = obuf
+
+ return nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+func (o *Buffer) skip(t reflect.Type, tag, wire int) error {
+
+ var u uint64
+ var err error
+
+ switch wire {
+ case WireVarint:
+ _, err = o.DecodeVarint()
+ case WireFixed64:
+ _, err = o.DecodeFixed64()
+ case WireBytes:
+ _, err = o.DecodeRawBytes(false)
+ case WireFixed32:
+ _, err = o.DecodeFixed32()
+ case WireStartGroup:
+ for {
+ u, err = o.DecodeVarint()
+ if err != nil {
+ break
+ }
+ fwire := int(u & 0x7)
+ if fwire == WireEndGroup {
+ break
+ }
+ ftag := int(u >> 3)
+ err = o.skip(t, ftag, fwire)
+ if err != nil {
+ break
+ }
+ }
+ default:
+ err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t)
+ }
+ return err
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves. The method should reset the receiver before
+// decoding starts. The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+type Unmarshaler interface {
+ Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb. If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+ pb.Reset()
+ return UnmarshalMerge(buf, pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb. If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+ // If the object can unmarshal itself, let it.
+ if u, ok := pb.(Unmarshaler); ok {
+ return u.Unmarshal(buf)
+ }
+ return NewBuffer(buf).Unmarshal(pb)
+}
+
+// DecodeMessage reads a count-delimited message from the Buffer.
+func (p *Buffer) DecodeMessage(pb Message) error {
+ enc, err := p.DecodeRawBytes(false)
+ if err != nil {
+ return err
+ }
+ return NewBuffer(enc).Unmarshal(pb)
+}
+
+// DecodeGroup reads a tag-delimited group from the Buffer.
+func (p *Buffer) DecodeGroup(pb Message) error {
+ typ, base, err := getbase(pb)
+ if err != nil {
+ return err
+ }
+ return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base)
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb. If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+func (p *Buffer) Unmarshal(pb Message) error {
+ // If the object can unmarshal itself, let it.
+ if u, ok := pb.(Unmarshaler); ok {
+ err := u.Unmarshal(p.buf[p.index:])
+ p.index = len(p.buf)
+ return err
+ }
+
+ typ, base, err := getbase(pb)
+ if err != nil {
+ return err
+ }
+
+ err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base)
+
+ if collectStats {
+ stats.Decode++
+ }
+
+ return err
+}
+
+// unmarshalType does the work of unmarshaling a structure.
+func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error {
+ var state errorState
+ required, reqFields := prop.reqCount, uint64(0)
+
+ var err error
+ for err == nil && o.index < len(o.buf) {
+ oi := o.index
+ var u uint64
+ u, err = o.DecodeVarint()
+ if err != nil {
+ break
+ }
+ wire := int(u & 0x7)
+ if wire == WireEndGroup {
+ if is_group {
+ if required > 0 {
+ // Not enough information to determine the exact field.
+ // (See below.)
+ return &RequiredNotSetError{"{Unknown}"}
+ }
+ return nil // input is satisfied
+ }
+ return fmt.Errorf("proto: %s: wiretype end group for non-group", st)
+ }
+ tag := int(u >> 3)
+ if tag <= 0 {
+ return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire)
+ }
+ fieldnum, ok := prop.decoderTags.get(tag)
+ if !ok {
+ // Maybe it's an extension?
+ if prop.extendable {
+ if e, eok := structPointer_Interface(base, st).(extensionsBytes); eok {
+ if isExtensionField(e, int32(tag)) {
+ if err = o.skip(st, tag, wire); err == nil {
+ ext := e.GetExtensions()
+ *ext = append(*ext, o.buf[oi:o.index]...)
+ }
+ continue
+ }
+ } else if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {
+ if err = o.skip(st, tag, wire); err == nil {
+ extmap := e.extensionsWrite()
+ ext := extmap[int32(tag)] // may be missing
+ ext.enc = append(ext.enc, o.buf[oi:o.index]...)
+ extmap[int32(tag)] = ext
+ }
+ continue
+ }
+ }
+ // Maybe it's a oneof?
+ if prop.oneofUnmarshaler != nil {
+ m := structPointer_Interface(base, st).(Message)
+ // First return value indicates whether tag is a oneof field.
+ ok, err = prop.oneofUnmarshaler(m, tag, wire, o)
+ if err == ErrInternalBadWireType {
+ // Map the error to something more descriptive.
+ // Do the formatting here to save generated code space.
+ err = fmt.Errorf("bad wiretype for oneof field in %T", m)
+ }
+ if ok {
+ continue
+ }
+ }
+ err = o.skipAndSave(st, tag, wire, base, prop.unrecField)
+ continue
+ }
+ p := prop.Prop[fieldnum]
+
+ if p.dec == nil {
+ fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name)
+ continue
+ }
+ dec := p.dec
+ if wire != WireStartGroup && wire != p.WireType {
+ if wire == WireBytes && p.packedDec != nil {
+ // a packable field
+ dec = p.packedDec
+ } else {
+ err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType)
+ continue
+ }
+ }
+ decErr := dec(o, p, base)
+ if decErr != nil && !state.shouldContinue(decErr, p) {
+ err = decErr
+ }
+ if err == nil && p.Required {
+ // Successfully decoded a required field.
+ if tag <= 64 {
+ // use bitmap for fields 1-64 to catch field reuse.
+ var mask uint64 = 1 << uint64(tag-1)
+ if reqFields&mask == 0 {
+ // new required field
+ reqFields |= mask
+ required--
+ }
+ } else {
+ // This is imprecise. It can be fooled by a required field
+ // with a tag > 64 that is encoded twice; that's very rare.
+ // A fully correct implementation would require allocating
+ // a data structure, which we would like to avoid.
+ required--
+ }
+ }
+ }
+ if err == nil {
+ if is_group {
+ return io.ErrUnexpectedEOF
+ }
+ if state.err != nil {
+ return state.err
+ }
+ if required > 0 {
+ // Not enough information to determine the exact field. If we use extra
+ // CPU, we could determine the field only if the missing required field
+ // has a tag <= 64 and we check reqFields.
+ return &RequiredNotSetError{"{Unknown}"}
+ }
+ }
+ return err
+}
+
+// Individual type decoders
+// For each,
+// u is the decoded value,
+// v is a pointer to the field (pointer) in the struct
+
+// Sizes of the pools to allocate inside the Buffer.
+// The goal is modest amortization and allocation
+// on at least 16-byte boundaries.
+const (
+ boolPoolSize = 16
+ uint32PoolSize = 8
+ uint64PoolSize = 4
+)
+
+// Decode a bool.
+func (o *Buffer) dec_bool(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ if len(o.bools) == 0 {
+ o.bools = make([]bool, boolPoolSize)
+ }
+ o.bools[0] = u != 0
+ *structPointer_Bool(base, p.field) = &o.bools[0]
+ o.bools = o.bools[1:]
+ return nil
+}
+
+func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ *structPointer_BoolVal(base, p.field) = u != 0
+ return nil
+}
+
+// Decode an int32.
+func (o *Buffer) dec_int32(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ word32_Set(structPointer_Word32(base, p.field), o, uint32(u))
+ return nil
+}
+
+func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u))
+ return nil
+}
+
+// Decode an int64.
+func (o *Buffer) dec_int64(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ word64_Set(structPointer_Word64(base, p.field), o, u)
+ return nil
+}
+
+func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ word64Val_Set(structPointer_Word64Val(base, p.field), o, u)
+ return nil
+}
+
+// Decode a string.
+func (o *Buffer) dec_string(p *Properties, base structPointer) error {
+ s, err := o.DecodeStringBytes()
+ if err != nil {
+ return err
+ }
+ *structPointer_String(base, p.field) = &s
+ return nil
+}
+
+func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error {
+ s, err := o.DecodeStringBytes()
+ if err != nil {
+ return err
+ }
+ *structPointer_StringVal(base, p.field) = s
+ return nil
+}
+
+// Decode a slice of bytes ([]byte).
+func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error {
+ b, err := o.DecodeRawBytes(true)
+ if err != nil {
+ return err
+ }
+ *structPointer_Bytes(base, p.field) = b
+ return nil
+}
+
+// Decode a slice of bools ([]bool).
+func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ v := structPointer_BoolSlice(base, p.field)
+ *v = append(*v, u != 0)
+ return nil
+}
+
+// Decode a slice of bools ([]bool) in packed format.
+func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error {
+ v := structPointer_BoolSlice(base, p.field)
+
+ nn, err := o.DecodeVarint()
+ if err != nil {
+ return err
+ }
+ nb := int(nn) // number of bytes of encoded bools
+ fin := o.index + nb
+ if fin < o.index {
+ return errOverflow
+ }
+
+ y := *v
+ for o.index < fin {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ y = append(y, u != 0)
+ }
+
+ *v = y
+ return nil
+}
+
+// Decode a slice of int32s ([]int32).
+func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ structPointer_Word32Slice(base, p.field).Append(uint32(u))
+ return nil
+}
+
+// Decode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error {
+ v := structPointer_Word32Slice(base, p.field)
+
+ nn, err := o.DecodeVarint()
+ if err != nil {
+ return err
+ }
+ nb := int(nn) // number of bytes of encoded int32s
+
+ fin := o.index + nb
+ if fin < o.index {
+ return errOverflow
+ }
+ for o.index < fin {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ v.Append(uint32(u))
+ }
+ return nil
+}
+
+// Decode a slice of int64s ([]int64).
+func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+
+ structPointer_Word64Slice(base, p.field).Append(u)
+ return nil
+}
+
+// Decode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error {
+ v := structPointer_Word64Slice(base, p.field)
+
+ nn, err := o.DecodeVarint()
+ if err != nil {
+ return err
+ }
+ nb := int(nn) // number of bytes of encoded int64s
+
+ fin := o.index + nb
+ if fin < o.index {
+ return errOverflow
+ }
+ for o.index < fin {
+ u, err := p.valDec(o)
+ if err != nil {
+ return err
+ }
+ v.Append(u)
+ }
+ return nil
+}
+
+// Decode a slice of strings ([]string).
+func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error {
+ s, err := o.DecodeStringBytes()
+ if err != nil {
+ return err
+ }
+ v := structPointer_StringSlice(base, p.field)
+ *v = append(*v, s)
+ return nil
+}
+
+// Decode a slice of slice of bytes ([][]byte).
+func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error {
+ b, err := o.DecodeRawBytes(true)
+ if err != nil {
+ return err
+ }
+ v := structPointer_BytesSlice(base, p.field)
+ *v = append(*v, b)
+ return nil
+}
+
+// Decode a map field.
+func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {
+ raw, err := o.DecodeRawBytes(false)
+ if err != nil {
+ return err
+ }
+ oi := o.index // index at the end of this map entry
+ o.index -= len(raw) // move buffer back to start of map entry
+
+ mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V
+ if mptr.Elem().IsNil() {
+ mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem()))
+ }
+ v := mptr.Elem() // map[K]V
+
+ // Prepare addressable doubly-indirect placeholders for the key and value types.
+ // See enc_new_map for why.
+ keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K
+ keybase := toStructPointer(keyptr.Addr()) // **K
+
+ var valbase structPointer
+ var valptr reflect.Value
+ switch p.mtype.Elem().Kind() {
+ case reflect.Slice:
+ // []byte
+ var dummy []byte
+ valptr = reflect.ValueOf(&dummy) // *[]byte
+ valbase = toStructPointer(valptr) // *[]byte
+ case reflect.Ptr:
+ // message; valptr is **Msg; need to allocate the intermediate pointer
+ valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+ valptr.Set(reflect.New(valptr.Type().Elem()))
+ valbase = toStructPointer(valptr)
+ default:
+ // everything else
+ valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+ valbase = toStructPointer(valptr.Addr()) // **V
+ }
+
+ // Decode.
+ // This parses a restricted wire format, namely the encoding of a message
+ // with two fields. See enc_new_map for the format.
+ for o.index < oi {
+ // tagcode for key and value properties are always a single byte
+ // because they have tags 1 and 2.
+ tagcode := o.buf[o.index]
+ o.index++
+ switch tagcode {
+ case p.mkeyprop.tagcode[0]:
+ if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil {
+ return err
+ }
+ case p.mvalprop.tagcode[0]:
+ if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil {
+ return err
+ }
+ default:
+ // TODO: Should we silently skip this instead?
+ return fmt.Errorf("proto: bad map data tag %d", raw[0])
+ }
+ }
+ keyelem, valelem := keyptr.Elem(), valptr.Elem()
+ if !keyelem.IsValid() {
+ keyelem = reflect.Zero(p.mtype.Key())
+ }
+ if !valelem.IsValid() {
+ valelem = reflect.Zero(p.mtype.Elem())
+ }
+
+ v.SetMapIndex(keyelem, valelem)
+ return nil
+}
+
+// Decode a group.
+func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error {
+ bas := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(bas) {
+ // allocate new nested message
+ bas = toStructPointer(reflect.New(p.stype))
+ structPointer_SetStructPointer(base, p.field, bas)
+ }
+ return o.unmarshalType(p.stype, p.sprop, true, bas)
+}
+
+// Decode an embedded message.
+func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) {
+ raw, e := o.DecodeRawBytes(false)
+ if e != nil {
+ return e
+ }
+
+ bas := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(bas) {
+ // allocate new nested message
+ bas = toStructPointer(reflect.New(p.stype))
+ structPointer_SetStructPointer(base, p.field, bas)
+ }
+
+ // If the object can unmarshal itself, let it.
+ if p.isUnmarshaler {
+ iv := structPointer_Interface(bas, p.stype)
+ return iv.(Unmarshaler).Unmarshal(raw)
+ }
+
+ obuf := o.buf
+ oi := o.index
+ o.buf = raw
+ o.index = 0
+
+ err = o.unmarshalType(p.stype, p.sprop, false, bas)
+ o.buf = obuf
+ o.index = oi
+
+ return err
+}
+
+// Decode a slice of embedded messages.
+func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error {
+ return o.dec_slice_struct(p, false, base)
+}
+
+// Decode a slice of embedded groups.
+func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error {
+ return o.dec_slice_struct(p, true, base)
+}
+
+// Decode a slice of structs ([]*struct).
+func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error {
+ v := reflect.New(p.stype)
+ bas := toStructPointer(v)
+ structPointer_StructPointerSlice(base, p.field).Append(bas)
+
+ if is_group {
+ err := o.unmarshalType(p.stype, p.sprop, is_group, bas)
+ return err
+ }
+
+ raw, err := o.DecodeRawBytes(false)
+ if err != nil {
+ return err
+ }
+
+ // If the object can unmarshal itself, let it.
+ if p.isUnmarshaler {
+ iv := v.Interface()
+ return iv.(Unmarshaler).Unmarshal(raw)
+ }
+
+ obuf := o.buf
+ oi := o.index
+ o.buf = raw
+ o.index = 0
+
+ err = o.unmarshalType(p.stype, p.sprop, is_group, bas)
+
+ o.buf = obuf
+ o.index = oi
+
+ return err
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode_gogo.go b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..ecc63873e4797d1b86dd9114100b61b13f429c33
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
@@ -0,0 +1,171 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "reflect"
+)
+
+// Decode a reference to a struct pointer.
+func (o *Buffer) dec_ref_struct_message(p *Properties, base structPointer) (err error) {
+ raw, e := o.DecodeRawBytes(false)
+ if e != nil {
+ return e
+ }
+
+ // If the object can unmarshal itself, let it.
+ if p.isUnmarshaler {
+ panic("not supported, since this is a pointer receiver")
+ }
+
+ obuf := o.buf
+ oi := o.index
+ o.buf = raw
+ o.index = 0
+
+ bas := structPointer_FieldPointer(base, p.field)
+
+ err = o.unmarshalType(p.stype, p.sprop, false, bas)
+ o.buf = obuf
+ o.index = oi
+
+ return err
+}
+
+// Decode a slice of references to struct pointers ([]struct).
+func (o *Buffer) dec_slice_ref_struct(p *Properties, is_group bool, base structPointer) error {
+ newBas := appendStructPointer(base, p.field, p.sstype)
+
+ if is_group {
+ panic("not supported, maybe in future, if requested.")
+ }
+
+ raw, err := o.DecodeRawBytes(false)
+ if err != nil {
+ return err
+ }
+
+ // If the object can unmarshal itself, let it.
+ if p.isUnmarshaler {
+ panic("not supported, since this is not a pointer receiver.")
+ }
+
+ obuf := o.buf
+ oi := o.index
+ o.buf = raw
+ o.index = 0
+
+ err = o.unmarshalType(p.stype, p.sprop, is_group, newBas)
+
+ o.buf = obuf
+ o.index = oi
+
+ return err
+}
+
+// Decode a slice of references to struct pointers.
+func (o *Buffer) dec_slice_ref_struct_message(p *Properties, base structPointer) error {
+ return o.dec_slice_ref_struct(p, false, base)
+}
+
+func setPtrCustomType(base structPointer, f field, v interface{}) {
+ if v == nil {
+ return
+ }
+ structPointer_SetStructPointer(base, f, structPointer(reflect.ValueOf(v).Pointer()))
+}
+
+func setCustomType(base structPointer, f field, value interface{}) {
+ if value == nil {
+ return
+ }
+ v := reflect.ValueOf(value).Elem()
+ t := reflect.TypeOf(value).Elem()
+ kind := t.Kind()
+ switch kind {
+ case reflect.Slice:
+ slice := reflect.MakeSlice(t, v.Len(), v.Cap())
+ reflect.Copy(slice, v)
+ oldHeader := structPointer_GetSliceHeader(base, f)
+ oldHeader.Data = slice.Pointer()
+ oldHeader.Len = v.Len()
+ oldHeader.Cap = v.Cap()
+ default:
+ size := reflect.TypeOf(value).Elem().Size()
+ structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), int(size))
+ }
+}
+
+func (o *Buffer) dec_custom_bytes(p *Properties, base structPointer) error {
+ b, err := o.DecodeRawBytes(true)
+ if err != nil {
+ return err
+ }
+ i := reflect.New(p.ctype.Elem()).Interface()
+ custom := (i).(Unmarshaler)
+ if err := custom.Unmarshal(b); err != nil {
+ return err
+ }
+ setPtrCustomType(base, p.field, custom)
+ return nil
+}
+
+func (o *Buffer) dec_custom_ref_bytes(p *Properties, base structPointer) error {
+ b, err := o.DecodeRawBytes(true)
+ if err != nil {
+ return err
+ }
+ i := reflect.New(p.ctype).Interface()
+ custom := (i).(Unmarshaler)
+ if err := custom.Unmarshal(b); err != nil {
+ return err
+ }
+ if custom != nil {
+ setCustomType(base, p.field, custom)
+ }
+ return nil
+}
+
+// Decode a slice of bytes ([]byte) into a slice of custom types.
+func (o *Buffer) dec_custom_slice_bytes(p *Properties, base structPointer) error {
+ b, err := o.DecodeRawBytes(true)
+ if err != nil {
+ return err
+ }
+ i := reflect.New(p.ctype.Elem()).Interface()
+ custom := (i).(Unmarshaler)
+ if err := custom.Unmarshal(b); err != nil {
+ return err
+ }
+ newBas := appendStructPointer(base, p.field, p.ctype)
+
+ setCustomType(newBas, 0, custom)
+
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/encode.go
rename to vendor/github.com/gogo/protobuf/proto/encode.go
index 231b07401a383f46a2dfa5f28d2a1ac32ff7af95..8c1b8fd1f6831579d821a8bce8d657d597f55fb0 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/encode.go
+++ b/vendor/github.com/gogo/protobuf/proto/encode.go
@@ -64,8 +64,16 @@ var (
// a struct with a repeated field containing a nil element.
errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+ // errOneofHasNil is the error returned if Marshal is called with
+ // a struct with a oneof field containing a nil element.
+ errOneofHasNil = errors.New("proto: oneof field has nil value")
+
// ErrNil is the error returned if Marshal is called with nil.
ErrNil = errors.New("proto: Marshal called with nil")
+
+ // ErrTooLarge is the error returned if Marshal is called with a
+ // message that encodes to >2GB.
+ ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
)
// The fundamental encoders that put bytes on the wire.
@@ -74,6 +82,10 @@ var (
const maxVarintBytes = 10 // maximum length of a varint
+// maxMarshalSize is the largest allowed size of an encoded protobuf,
+// since C++ and Java use signed int32s for the size.
+const maxMarshalSize = 1<<31 - 1
+
// EncodeVarint returns the varint encoding of x.
// This is the format for the
// int32, int64, uint32, uint64, bool, and enum
@@ -273,6 +285,9 @@ func (p *Buffer) Marshal(pb Message) error {
stats.Encode++
}
+ if len(p.buf) > maxMarshalSize {
+ return ErrTooLarge
+ }
return err
}
@@ -1058,10 +1073,25 @@ func size_slice_struct_group(p *Properties, base structPointer) (n int) {
// Encode an extension map.
func (o *Buffer) enc_map(p *Properties, base structPointer) error {
- v := *structPointer_ExtMap(base, p.field)
- if err := encodeExtensionMap(v); err != nil {
+ exts := structPointer_ExtMap(base, p.field)
+ if err := encodeExtensionsMap(*exts); err != nil {
+ return err
+ }
+
+ return o.enc_map_body(*exts)
+}
+
+func (o *Buffer) enc_exts(p *Properties, base structPointer) error {
+ exts := structPointer_Extensions(base, p.field)
+ if err := encodeExtensions(exts); err != nil {
return err
}
+ v, _ := exts.extensionsRead()
+
+ return o.enc_map_body(v)
+}
+
+func (o *Buffer) enc_map_body(v map[int32]Extension) error {
// Fast-path for common cases: zero or one extensions.
if len(v) <= 1 {
for _, e := range v {
@@ -1084,8 +1114,13 @@ func (o *Buffer) enc_map(p *Properties, base structPointer) error {
}
func size_map(p *Properties, base structPointer) int {
- v := *structPointer_ExtMap(base, p.field)
- return sizeExtensionMap(v)
+ v := structPointer_ExtMap(base, p.field)
+ return extensionsMapSize(*v)
+}
+
+func size_exts(p *Properties, base structPointer) int {
+ v := structPointer_Extensions(base, p.field)
+ return extensionsSize(v)
}
// Encode a map field.
@@ -1114,7 +1149,7 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
return err
}
- if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil {
+ if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {
return err
}
return nil
@@ -1124,11 +1159,6 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
for _, key := range v.MapKeys() {
val := v.MapIndex(key)
- // The only illegal map entry values are nil message pointers.
- if val.Kind() == reflect.Ptr && val.IsNil() {
- return errors.New("proto: map has nil element")
- }
-
keycopy.Set(key)
valcopy.Set(val)
@@ -1216,13 +1246,18 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
return err
}
}
+ if len(o.buf) > maxMarshalSize {
+ return ErrTooLarge
+ }
}
}
// Do oneof fields.
if prop.oneofMarshaler != nil {
m := structPointer_Interface(base, prop.stype).(Message)
- if err := prop.oneofMarshaler(m, o); err != nil {
+ if err := prop.oneofMarshaler(m, o); err == ErrNil {
+ return errOneofHasNil
+ } else if err != nil {
return err
}
}
@@ -1230,6 +1265,9 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
// Add unrecognized fields at the end.
if prop.unrecField.IsValid() {
v := *structPointer_Bytes(base, prop.unrecField)
+ if len(o.buf)+len(v) > maxMarshalSize {
+ return ErrTooLarge
+ }
if len(v) > 0 {
o.buf = append(o.buf, v...)
}
diff --git a/vendor/github.com/gogo/protobuf/proto/encode_gogo.go b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..66e7e16303bd40d26c096bfe4c6583be15bfe281
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
@@ -0,0 +1,354 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// http://github.com/golang/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "reflect"
+)
+
+func NewRequiredNotSetError(field string) *RequiredNotSetError {
+ return &RequiredNotSetError{field}
+}
+
+type Sizer interface {
+ Size() int
+}
+
+func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error {
+ s := *structPointer_Bytes(base, p.field)
+ if s == nil {
+ return ErrNil
+ }
+ o.buf = append(o.buf, s...)
+ return nil
+}
+
+func size_ext_slice_byte(p *Properties, base structPointer) (n int) {
+ s := *structPointer_Bytes(base, p.field)
+ if s == nil {
+ return 0
+ }
+ n += len(s)
+ return
+}
+
+// Encode a reference to bool pointer.
+func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error {
+ v := *structPointer_BoolVal(base, p.field)
+ x := 0
+ if v {
+ x = 1
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func size_ref_bool(p *Properties, base structPointer) int {
+ return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode a reference to int32 pointer.
+func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error {
+ v := structPointer_Word32Val(base, p.field)
+ x := int32(word32Val_Get(v))
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func size_ref_int32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32Val(base, p.field)
+ x := int32(word32Val_Get(v))
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error {
+ v := structPointer_Word32Val(base, p.field)
+ x := word32Val_Get(v)
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func size_ref_uint32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32Val(base, p.field)
+ x := word32Val_Get(v)
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+// Encode a reference to an int64 pointer.
+func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error {
+ v := structPointer_Word64Val(base, p.field)
+ x := word64Val_Get(v)
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, x)
+ return nil
+}
+
+func size_ref_int64(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word64Val(base, p.field)
+ x := word64Val_Get(v)
+ n += len(p.tagcode)
+ n += p.valSize(x)
+ return
+}
+
+// Encode a reference to a string pointer.
+func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error {
+ v := *structPointer_StringVal(base, p.field)
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeStringBytes(v)
+ return nil
+}
+
+func size_ref_string(p *Properties, base structPointer) (n int) {
+ v := *structPointer_StringVal(base, p.field)
+ n += len(p.tagcode)
+ n += sizeStringBytes(v)
+ return
+}
+
+// Encode a reference to a message struct.
+func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error {
+ var state errorState
+ structp := structPointer_GetRefStructPointer(base, p.field)
+ if structPointer_IsNil(structp) {
+ return ErrNil
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, err := m.Marshal()
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ return nil
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+//TODO this is only copied, please fix this
+func size_ref_struct_message(p *Properties, base structPointer) int {
+ structp := structPointer_GetRefStructPointer(base, p.field)
+ if structPointer_IsNil(structp) {
+ return 0
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, _ := m.Marshal()
+ n0 := len(p.tagcode)
+ n1 := sizeRawBytes(data)
+ return n0 + n1
+ }
+
+ n0 := len(p.tagcode)
+ n1 := size_struct(p.sprop, structp)
+ n2 := sizeVarint(uint64(n1)) // size of encoded length
+ return n0 + n1 + n2
+}
+
+// Encode a slice of references to message struct pointers ([]struct).
+func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error {
+ var state errorState
+ ss := structPointer_GetStructPointer(base, p.field)
+ ss1 := structPointer_GetRefStructPointer(ss, field(0))
+ size := p.stype.Size()
+ l := structPointer_Len(base, p.field)
+ for i := 0; i < l; i++ {
+ structp := structPointer_Add(ss1, field(uintptr(i)*size))
+ if structPointer_IsNil(structp) {
+ return errRepeatedHasNil
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, err := m.Marshal()
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ continue
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ err := o.enc_len_struct(p.sprop, structp, &state)
+ if err != nil && !state.shouldContinue(err, nil) {
+ if err == ErrNil {
+ return errRepeatedHasNil
+ }
+ return err
+ }
+
+ }
+ return state.err
+}
+
+//TODO this is only copied, please fix this
+func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) {
+ ss := structPointer_GetStructPointer(base, p.field)
+ ss1 := structPointer_GetRefStructPointer(ss, field(0))
+ size := p.stype.Size()
+ l := structPointer_Len(base, p.field)
+ n += l * len(p.tagcode)
+ for i := 0; i < l; i++ {
+ structp := structPointer_Add(ss1, field(uintptr(i)*size))
+ if structPointer_IsNil(structp) {
+ return // return the size up to this point
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, _ := m.Marshal()
+ n += len(p.tagcode)
+ n += sizeRawBytes(data)
+ continue
+ }
+
+ n0 := size_struct(p.sprop, structp)
+ n1 := sizeVarint(uint64(n0)) // size of encoded length
+ n += n0 + n1
+ }
+ return
+}
+
+func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error {
+ i := structPointer_InterfaceRef(base, p.field, p.ctype)
+ if i == nil {
+ return ErrNil
+ }
+ custom := i.(Marshaler)
+ data, err := custom.Marshal()
+ if err != nil {
+ return err
+ }
+ if data == nil {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ return nil
+}
+
+func size_custom_bytes(p *Properties, base structPointer) (n int) {
+ n += len(p.tagcode)
+ i := structPointer_InterfaceRef(base, p.field, p.ctype)
+ if i == nil {
+ return 0
+ }
+ custom := i.(Marshaler)
+ data, _ := custom.Marshal()
+ n += sizeRawBytes(data)
+ return
+}
+
+func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error {
+ custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler)
+ data, err := custom.Marshal()
+ if err != nil {
+ return err
+ }
+ if data == nil {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ return nil
+}
+
+func size_custom_ref_bytes(p *Properties, base structPointer) (n int) {
+ n += len(p.tagcode)
+ i := structPointer_InterfaceAt(base, p.field, p.ctype)
+ if i == nil {
+ return 0
+ }
+ custom := i.(Marshaler)
+ data, _ := custom.Marshal()
+ n += sizeRawBytes(data)
+ return
+}
+
+func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error {
+ inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+ if inter == nil {
+ return ErrNil
+ }
+ slice := reflect.ValueOf(inter)
+ l := slice.Len()
+ for i := 0; i < l; i++ {
+ v := slice.Index(i)
+ custom := v.Interface().(Marshaler)
+ data, err := custom.Marshal()
+ if err != nil {
+ return err
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ }
+ return nil
+}
+
+func size_custom_slice_bytes(p *Properties, base structPointer) (n int) {
+ inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+ if inter == nil {
+ return 0
+ }
+ slice := reflect.ValueOf(inter)
+ l := slice.Len()
+ n += l * len(p.tagcode)
+ for i := 0; i < l; i++ {
+ v := slice.Index(i)
+ custom := v.Interface().(Marshaler)
+ data, _ := custom.Marshal()
+ n += sizeRawBytes(data)
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/gogo/protobuf/proto/equal.go
similarity index 90%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/equal.go
rename to vendor/github.com/gogo/protobuf/proto/equal.go
index f5db1def3c2483e5fb7879bfe318dea69964147c..8b16f951c712703a03a14591510818da15557b01 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/equal.go
+++ b/vendor/github.com/gogo/protobuf/proto/equal.go
@@ -121,9 +121,16 @@ func equalStruct(v1, v2 reflect.Value) bool {
}
}
+ if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+ em2 := v2.FieldByName("XXX_InternalExtensions")
+ if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+ return false
+ }
+ }
+
if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
em2 := v2.FieldByName("XXX_extensions")
- if !equalExtensions(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+ if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
return false
}
}
@@ -184,6 +191,13 @@ func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
}
return true
case reflect.Ptr:
+ // Maps may have nil values in them, so check for nil.
+ if v1.IsNil() && v2.IsNil() {
+ return true
+ }
+ if v1.IsNil() != v2.IsNil() {
+ return false
+ }
return equalAny(v1.Elem(), v2.Elem(), prop)
case reflect.Slice:
if v1.Type().Elem().Kind() == reflect.Uint8 {
@@ -223,8 +237,14 @@ func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
}
// base is the struct type that the extensions are based on.
-// em1 and em2 are extension maps.
-func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool {
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+ em1, _ := x1.extensionsRead()
+ em2, _ := x2.extensionsRead()
+ return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
if len(em1) != len(em2) {
return false
}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions.go b/vendor/github.com/gogo/protobuf/proto/extensions.go
new file mode 100644
index 0000000000000000000000000000000000000000..f7384baa87956c4fe2c2b1788952c7f57f067055
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions.go
@@ -0,0 +1,689 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "sync"
+)
+
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
+var ErrMissingExtension = errors.New("proto: missing extension")
+
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+ Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
+type extendableProto interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ extensionsWrite() map[int32]Extension
+ extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ ExtensionMap() map[int32]Extension
+}
+
+type extensionsBytes interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ GetExtensions() *[]byte
+}
+
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+ extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+ return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+ return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock() {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, bool) {
+ if ep, ok := p.(extendableProto); ok {
+ return ep, ok
+ }
+ if ep, ok := p.(extendableProtoV1); ok {
+ return extensionAdapter{ep}, ok
+ }
+ return nil, false
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+ // The struct must be indirect so that if a user inadvertently copies a
+ // generated message and its embedded XXX_InternalExtensions, they
+ // avoid the mayhem of a copied mutex.
+ //
+ // The mutex serializes all logically read-only operations to p.extensionMap.
+ // It is up to the client to ensure that write operations to p.extensionMap are
+ // mutually exclusive with other accesses.
+ p *struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ }
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+ if e.p == nil {
+ e.p = new(struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ })
+ e.p.extensionMap = make(map[int32]Extension)
+ }
+ return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use. It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+ if e.p == nil {
+ return nil, nil
+ }
+ return e.p.extensionMap, &e.p.mu
+}
+
+type extensionRange interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+}
+
+var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
+var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()
+var extendableBytesType = reflect.TypeOf((*extensionsBytes)(nil)).Elem()
+var extensionRangeType = reflect.TypeOf((*extensionRange)(nil)).Elem()
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+ ExtendedType Message // nil pointer to the type that is being extended
+ ExtensionType interface{} // nil pointer to the extension type
+ Field int32 // field number
+ Name string // fully-qualified name of extension, for text formatting
+ Tag string // protobuf tag style
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+ t := reflect.TypeOf(ed.ExtensionType)
+ return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+ // When an extension is stored in a message using SetExtension
+ // only desc and value are set. When the message is marshaled
+ // enc will be set to the encoded form of the message.
+ //
+ // When a message is unmarshaled and contains extensions, each
+ // extension will have only enc set. When such an extension is
+ // accessed using GetExtension (or GetExtensions) desc and value
+ // will be set.
+ desc *ExtensionDesc
+ value interface{}
+ enc []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base Message, id int32, b []byte) {
+ if ebase, ok := base.(extensionsBytes); ok {
+ clearExtension(base, id)
+ ext := ebase.GetExtensions()
+ *ext = append(*ext, b...)
+ return
+ }
+ epb, ok := extendable(base)
+ if !ok {
+ return
+ }
+ extmap := epb.extensionsWrite()
+ extmap[id] = Extension{enc: b}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extensionRange, field int32) bool {
+ for _, er := range pb.ExtensionRangeArray() {
+ if er.Start <= field && field <= er.End {
+ return true
+ }
+ }
+ return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+ var pbi interface{} = pb
+ // Check the extended type.
+ if ea, ok := pbi.(extensionAdapter); ok {
+ pbi = ea.extendableProtoV1
+ }
+ if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
+ return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
+ }
+ // Check the range.
+ if !isExtensionField(pb, extension.Field) {
+ return errors.New("proto: bad extension number; not in declared ranges")
+ }
+ return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+ base reflect.Type
+ field int32
+}
+
+var extProp = struct {
+ sync.RWMutex
+ m map[extPropKey]*Properties
+}{
+ m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+ key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+ extProp.RLock()
+ if prop, ok := extProp.m[key]; ok {
+ extProp.RUnlock()
+ return prop
+ }
+ extProp.RUnlock()
+
+ extProp.Lock()
+ defer extProp.Unlock()
+ // Check again.
+ if prop, ok := extProp.m[key]; ok {
+ return prop
+ }
+
+ prop := new(Properties)
+ prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+ extProp.m[key] = prop
+ return prop
+}
+
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensions(e *XXX_InternalExtensions) error {
+ m, mu := e.extensionsRead()
+ if m == nil {
+ return nil // fast path
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ return encodeExtensionsMap(m)
+}
+
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensionsMap(m map[int32]Extension) error {
+ for k, e := range m {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ et := reflect.TypeOf(e.desc.ExtensionType)
+ props := extensionProperties(e.desc)
+
+ p := NewBuffer(nil)
+ // If e.value has type T, the encoder expects a *struct{ X T }.
+ // Pass a *T with a zero field and hope it all works out.
+ x := reflect.New(et)
+ x.Elem().Set(reflect.ValueOf(e.value))
+ if err := props.enc(p, props, toStructPointer(x)); err != nil {
+ return err
+ }
+ e.enc = p.buf
+ m[k] = e
+ }
+ return nil
+}
+
+func extensionsSize(e *XXX_InternalExtensions) (n int) {
+ m, mu := e.extensionsRead()
+ if m == nil {
+ return 0
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ return extensionsMapSize(m)
+}
+
+func extensionsMapSize(m map[int32]Extension) (n int) {
+ for _, e := range m {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ n += len(e.enc)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ et := reflect.TypeOf(e.desc.ExtensionType)
+ props := extensionProperties(e.desc)
+
+ // If e.value has type T, the encoder expects a *struct{ X T }.
+ // Pass a *T with a zero field and hope it all works out.
+ x := reflect.New(et)
+ x.Elem().Set(reflect.ValueOf(e.value))
+ n += props.size(props, toStructPointer(x))
+ }
+ return
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
+ if epb, doki := pb.(extensionsBytes); doki {
+ ext := epb.GetExtensions()
+ buf := *ext
+ o := 0
+ for o < len(buf) {
+ tag, n := DecodeVarint(buf[o:])
+ fieldNum := int32(tag >> 3)
+ if int32(fieldNum) == extension.Field {
+ return true
+ }
+ wireType := int(tag & 0x7)
+ o += n
+ l, err := size(buf[o:], wireType)
+ if err != nil {
+ return false
+ }
+ o += l
+ }
+ return false
+ }
+ // TODO: Check types, field numbers, etc.?
+ epb, ok := extendable(pb)
+ if !ok {
+ return false
+ }
+ extmap, mu := epb.extensionsRead()
+ if extmap == nil {
+ return false
+ }
+ mu.Lock()
+ _, ok = extmap[extension.Field]
+ mu.Unlock()
+ return ok
+}
+
+func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
+ ext := pb.GetExtensions()
+ for offset < len(*ext) {
+ tag, n1 := DecodeVarint((*ext)[offset:])
+ fieldNum := int32(tag >> 3)
+ wireType := int(tag & 0x7)
+ n2, err := size((*ext)[offset+n1:], wireType)
+ if err != nil {
+ panic(err)
+ }
+ newOffset := offset + n1 + n2
+ if fieldNum == theFieldNum {
+ *ext = append((*ext)[:offset], (*ext)[newOffset:]...)
+ return offset
+ }
+ offset = newOffset
+ }
+ return -1
+}
+
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+ clearExtension(pb, extension.Field)
+}
+
+func clearExtension(pb Message, fieldNum int32) {
+ if epb, doki := pb.(extensionsBytes); doki {
+ offset := 0
+ for offset != -1 {
+ offset = deleteExtension(epb, fieldNum, offset)
+ }
+ return
+ }
+ epb, ok := extendable(pb)
+ if !ok {
+ return
+ }
+ // TODO: Check types, field numbers, etc.?
+ extmap := epb.extensionsWrite()
+ delete(extmap, fieldNum)
+}
+
+// GetExtension parses and returns the given extension of pb.
+// If the extension is not present and has no default value it returns ErrMissingExtension.
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+ if epb, doki := pb.(extensionsBytes); doki {
+ ext := epb.GetExtensions()
+ o := 0
+ for o < len(*ext) {
+ tag, n := DecodeVarint((*ext)[o:])
+ fieldNum := int32(tag >> 3)
+ wireType := int(tag & 0x7)
+ l, err := size((*ext)[o+n:], wireType)
+ if err != nil {
+ return nil, err
+ }
+ if int32(fieldNum) == extension.Field {
+ v, err := decodeExtension((*ext)[o:o+n+l], extension)
+ if err != nil {
+ return nil, err
+ }
+ return v, nil
+ }
+ o += n + l
+ }
+ return defaultExtensionValue(extension)
+ }
+ epb, ok := extendable(pb)
+ if !ok {
+ return nil, errors.New("proto: not an extendable proto")
+ }
+ if err := checkExtensionTypes(epb, extension); err != nil {
+ return nil, err
+ }
+
+ emap, mu := epb.extensionsRead()
+ if emap == nil {
+ return defaultExtensionValue(extension)
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ e, ok := emap[extension.Field]
+ if !ok {
+ // defaultExtensionValue returns the default value or
+ // ErrMissingExtension if there is no default.
+ return defaultExtensionValue(extension)
+ }
+
+ if e.value != nil {
+ // Already decoded. Check the descriptor, though.
+ if e.desc != extension {
+ // This shouldn't happen. If it does, it means that
+ // GetExtension was called twice with two different
+ // descriptors with the same field number.
+ return nil, errors.New("proto: descriptor conflict")
+ }
+ return e.value, nil
+ }
+
+ v, err := decodeExtension(e.enc, extension)
+ if err != nil {
+ return nil, err
+ }
+
+ // Remember the decoded version and drop the encoded version.
+ // That way it is safe to mutate what we return.
+ e.value = v
+ e.desc = extension
+ e.enc = nil
+ emap[extension.Field] = e
+ return e.value, nil
+}
+
+// defaultExtensionValue returns the default value for extension.
+// If no default for an extension is defined ErrMissingExtension is returned.
+func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
+ t := reflect.TypeOf(extension.ExtensionType)
+ props := extensionProperties(extension)
+
+ sf, _, err := fieldDefault(t, props)
+ if err != nil {
+ return nil, err
+ }
+
+ if sf == nil || sf.value == nil {
+ // There is no default value.
+ return nil, ErrMissingExtension
+ }
+
+ if t.Kind() != reflect.Ptr {
+ // We do not need to return a Ptr, we can directly return sf.value.
+ return sf.value, nil
+ }
+
+ // We need to return an interface{} that is a pointer to sf.value.
+ value := reflect.New(t).Elem()
+ value.Set(reflect.New(value.Type().Elem()))
+ if sf.kind == reflect.Int32 {
+ // We may have an int32 or an enum, but the underlying data is int32.
+ // Since we can't set an int32 into a non int32 reflect.value directly
+ // set it as a int32.
+ value.Elem().SetInt(int64(sf.value.(int32)))
+ } else {
+ value.Elem().Set(reflect.ValueOf(sf.value))
+ }
+ return value.Interface(), nil
+}
+
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+ o := NewBuffer(b)
+
+ t := reflect.TypeOf(extension.ExtensionType)
+
+ props := extensionProperties(extension)
+
+ // t is a pointer to a struct, pointer to basic type or a slice.
+ // Allocate a "field" to store the pointer/slice itself; the
+ // pointer/slice will be stored here. We pass
+ // the address of this field to props.dec.
+ // This passes a zero field and a *t and lets props.dec
+ // interpret it as a *struct{ x t }.
+ value := reflect.New(t).Elem()
+
+ for {
+ // Discard wire type and field number varint. It isn't needed.
+ if _, err := o.DecodeVarint(); err != nil {
+ return nil, err
+ }
+
+ if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil {
+ return nil, err
+ }
+
+ if o.index >= len(o.buf) {
+ break
+ }
+ }
+ return value.Interface(), nil
+}
+
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+ extensions = make([]interface{}, len(es))
+ for i, e := range es {
+ extensions[i], err = GetExtension(pb, e)
+ if err == ErrMissingExtension {
+ err = nil
+ }
+ if err != nil {
+ return
+ }
+ }
+ return
+}
+
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+ epb, ok := extendable(pb)
+ if !ok {
+ return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)
+ }
+ registeredExtensions := RegisteredExtensions(pb)
+
+ emap, mu := epb.extensionsRead()
+ mu.Lock()
+ defer mu.Unlock()
+ extensions := make([]*ExtensionDesc, 0, len(emap))
+ for extid, e := range emap {
+ desc := e.desc
+ if desc == nil {
+ desc = registeredExtensions[extid]
+ if desc == nil {
+ desc = &ExtensionDesc{Field: extid}
+ }
+ }
+
+ extensions = append(extensions, desc)
+ }
+ return extensions, nil
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+ if epb, doki := pb.(extensionsBytes); doki {
+ ClearExtension(pb, extension)
+ ext := epb.GetExtensions()
+ et := reflect.TypeOf(extension.ExtensionType)
+ props := extensionProperties(extension)
+ p := NewBuffer(nil)
+ x := reflect.New(et)
+ x.Elem().Set(reflect.ValueOf(value))
+ if err := props.enc(p, props, toStructPointer(x)); err != nil {
+ return err
+ }
+ *ext = append(*ext, p.buf...)
+ return nil
+ }
+ epb, ok := extendable(pb)
+ if !ok {
+ return errors.New("proto: not an extendable proto")
+ }
+ if err := checkExtensionTypes(epb, extension); err != nil {
+ return err
+ }
+ typ := reflect.TypeOf(extension.ExtensionType)
+ if typ != reflect.TypeOf(value) {
+ return errors.New("proto: bad extension value type")
+ }
+ // nil extension values need to be caught early, because the
+ // encoder can't distinguish an ErrNil due to a nil extension
+ // from an ErrNil due to a missing field. Extensions are
+ // always optional, so the encoder would just swallow the error
+ // and drop all the extensions from the encoded message.
+ if reflect.ValueOf(value).IsNil() {
+ return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+ }
+
+ extmap := epb.extensionsWrite()
+ extmap[extension.Field] = Extension{desc: extension, value: value}
+ return nil
+}
+
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+ if epb, doki := pb.(extensionsBytes); doki {
+ ext := epb.GetExtensions()
+ *ext = []byte{}
+ return
+ }
+ epb, ok := extendable(pb)
+ if !ok {
+ return
+ }
+ m := epb.extensionsWrite()
+ for k := range m {
+ delete(m, k)
+ }
+}
+
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
+
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+ st := reflect.TypeOf(desc.ExtendedType).Elem()
+ m := extensionMaps[st]
+ if m == nil {
+ m = make(map[int32]*ExtensionDesc)
+ extensionMaps[st] = m
+ }
+ if _, ok := m[desc.Field]; ok {
+ panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+ }
+ m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+ return extensionMaps[reflect.TypeOf(pb).Elem()]
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea6478f009d7faed2ac3c82cf9a17b2bbf2165e6
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
@@ -0,0 +1,294 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+ "sort"
+ "strings"
+ "sync"
+)
+
+func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool {
+ if reflect.ValueOf(pb).IsNil() {
+ return ifnotset
+ }
+ value, err := GetExtension(pb, extension)
+ if err != nil {
+ return ifnotset
+ }
+ if value == nil {
+ return ifnotset
+ }
+ if value.(*bool) == nil {
+ return ifnotset
+ }
+ return *(value.(*bool))
+}
+
+func (this *Extension) Equal(that *Extension) bool {
+ return bytes.Equal(this.enc, that.enc)
+}
+
+func (this *Extension) Compare(that *Extension) int {
+ return bytes.Compare(this.enc, that.enc)
+}
+
+func SizeOfInternalExtension(m extendableProto) (n int) {
+ return SizeOfExtensionMap(m.extensionsWrite())
+}
+
+func SizeOfExtensionMap(m map[int32]Extension) (n int) {
+ return extensionsMapSize(m)
+}
+
+type sortableMapElem struct {
+ field int32
+ ext Extension
+}
+
+func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions {
+ s := make(sortableExtensions, 0, len(m))
+ for k, v := range m {
+ s = append(s, &sortableMapElem{field: k, ext: v})
+ }
+ return s
+}
+
+type sortableExtensions []*sortableMapElem
+
+func (this sortableExtensions) Len() int { return len(this) }
+
+func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] }
+
+func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field }
+
+func (this sortableExtensions) String() string {
+ sort.Sort(this)
+ ss := make([]string, len(this))
+ for i := range this {
+ ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext)
+ }
+ return "map[" + strings.Join(ss, ",") + "]"
+}
+
+func StringFromInternalExtension(m extendableProto) string {
+ return StringFromExtensionsMap(m.extensionsWrite())
+}
+
+func StringFromExtensionsMap(m map[int32]Extension) string {
+ return newSortableExtensionsFromMap(m).String()
+}
+
+func StringFromExtensionsBytes(ext []byte) string {
+ m, err := BytesToExtensionsMap(ext)
+ if err != nil {
+ panic(err)
+ }
+ return StringFromExtensionsMap(m)
+}
+
+func EncodeInternalExtension(m extendableProto, data []byte) (n int, err error) {
+ return EncodeExtensionMap(m.extensionsWrite(), data)
+}
+
+func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) {
+ if err := encodeExtensionsMap(m); err != nil {
+ return 0, err
+ }
+ keys := make([]int, 0, len(m))
+ for k := range m {
+ keys = append(keys, int(k))
+ }
+ sort.Ints(keys)
+ for _, k := range keys {
+ n += copy(data[n:], m[int32(k)].enc)
+ }
+ return n, nil
+}
+
+func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) {
+ if m[id].value == nil || m[id].desc == nil {
+ return m[id].enc, nil
+ }
+ if err := encodeExtensionsMap(m); err != nil {
+ return nil, err
+ }
+ return m[id].enc, nil
+}
+
+func size(buf []byte, wire int) (int, error) {
+ switch wire {
+ case WireVarint:
+ _, n := DecodeVarint(buf)
+ return n, nil
+ case WireFixed64:
+ return 8, nil
+ case WireBytes:
+ v, n := DecodeVarint(buf)
+ return int(v) + n, nil
+ case WireFixed32:
+ return 4, nil
+ case WireStartGroup:
+ offset := 0
+ for {
+ u, n := DecodeVarint(buf[offset:])
+ fwire := int(u & 0x7)
+ offset += n
+ if fwire == WireEndGroup {
+ return offset, nil
+ }
+ s, err := size(buf[offset:], wire)
+ if err != nil {
+ return 0, err
+ }
+ offset += s
+ }
+ }
+ return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire)
+}
+
+func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) {
+ m := make(map[int32]Extension)
+ i := 0
+ for i < len(buf) {
+ tag, n := DecodeVarint(buf[i:])
+ if n <= 0 {
+ return nil, fmt.Errorf("unable to decode varint")
+ }
+ fieldNum := int32(tag >> 3)
+ wireType := int(tag & 0x7)
+ l, err := size(buf[i+n:], wireType)
+ if err != nil {
+ return nil, err
+ }
+ end := i + int(l) + n
+ m[int32(fieldNum)] = Extension{enc: buf[i:end]}
+ i = end
+ }
+ return m, nil
+}
+
+func NewExtension(e []byte) Extension {
+ ee := Extension{enc: make([]byte, len(e))}
+ copy(ee.enc, e)
+ return ee
+}
+
+func AppendExtension(e Message, tag int32, buf []byte) {
+ if ee, eok := e.(extensionsBytes); eok {
+ ext := ee.GetExtensions()
+ *ext = append(*ext, buf...)
+ return
+ }
+ if ee, eok := e.(extendableProto); eok {
+ m := ee.extensionsWrite()
+ ext := m[int32(tag)] // may be missing
+ ext.enc = append(ext.enc, buf...)
+ m[int32(tag)] = ext
+ }
+}
+
+func encodeExtension(e *Extension) error {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ return nil
+ }
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ et := reflect.TypeOf(e.desc.ExtensionType)
+ props := extensionProperties(e.desc)
+
+ p := NewBuffer(nil)
+ // If e.value has type T, the encoder expects a *struct{ X T }.
+ // Pass a *T with a zero field and hope it all works out.
+ x := reflect.New(et)
+ x.Elem().Set(reflect.ValueOf(e.value))
+ if err := props.enc(p, props, toStructPointer(x)); err != nil {
+ return err
+ }
+ e.enc = p.buf
+ return nil
+}
+
+func (this Extension) GoString() string {
+ if this.enc == nil {
+ if err := encodeExtension(&this); err != nil {
+ panic(err)
+ }
+ }
+ return fmt.Sprintf("proto.NewExtension(%#v)", this.enc)
+}
+
+func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error {
+ typ := reflect.TypeOf(pb).Elem()
+ ext, ok := extensionMaps[typ]
+ if !ok {
+ return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+ }
+ desc, ok := ext[fieldNum]
+ if !ok {
+ return errors.New("proto: bad extension number; not in declared ranges")
+ }
+ return SetExtension(pb, desc, value)
+}
+
+func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error) {
+ typ := reflect.TypeOf(pb).Elem()
+ ext, ok := extensionMaps[typ]
+ if !ok {
+ return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+ }
+ desc, ok := ext[fieldNum]
+ if !ok {
+ return nil, fmt.Errorf("unregistered field number %d", fieldNum)
+ }
+ return GetExtension(pb, desc)
+}
+
+func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions {
+ x := &XXX_InternalExtensions{
+ p: new(struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ }),
+ }
+ x.p.extensionMap = m
+ return *x
+}
+
+func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension {
+ pb := extendable.(extendableProto)
+ return pb.extensionsWrite()
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go
new file mode 100644
index 0000000000000000000000000000000000000000..2c30d7095144faf28823740fb4e6f46143d08cbb
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib.go
@@ -0,0 +1,898 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package proto converts data structures to and from the wire format of
+protocol buffers. It works in concert with the Go source code generated
+for .proto files by the protocol compiler.
+
+A summary of the properties of the protocol buffer interface
+for a protocol buffer variable v:
+
+ - Names are turned from camel_case to CamelCase for export.
+ - There are no methods on v to set fields; just treat
+ them as structure fields.
+ - There are getters that return a field's value if set,
+ and return the field's default value if unset.
+ The getters work even if the receiver is a nil message.
+ - The zero value for a struct is its correct initialization state.
+ All desired fields must be set before marshaling.
+ - A Reset() method will restore a protobuf struct to its zero state.
+ - Non-repeated fields are pointers to the values; nil means unset.
+ That is, optional or required field int32 f becomes F *int32.
+ - Repeated fields are slices.
+ - Helper functions are available to aid the setting of fields.
+ msg.Foo = proto.String("hello") // set field
+ - Constants are defined to hold the default values of all fields that
+ have them. They have the form Default_StructName_FieldName.
+ Because the getter methods handle defaulted values,
+ direct use of these constants should be rare.
+ - Enums are given type names and maps from names to values.
+ Enum values are prefixed by the enclosing message's name, or by the
+ enum's type name if it is a top-level enum. Enum types have a String
+ method, and a Enum method to assist in message construction.
+ - Nested messages, groups and enums have type names prefixed with the name of
+ the surrounding message type.
+ - Extensions are given descriptor names that start with E_,
+ followed by an underscore-delimited list of the nested messages
+ that contain it (if any) followed by the CamelCased name of the
+ extension field itself. HasExtension, ClearExtension, GetExtension
+ and SetExtension are functions for manipulating extensions.
+ - Oneof field sets are given a single field in their message,
+ with distinguished wrapper types for each possible field value.
+ - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+When the .proto file specifies `syntax="proto3"`, there are some differences:
+
+ - Non-repeated fields of non-message type are values instead of pointers.
+ - Getters are only generated for message and oneof fields.
+ - Enum types do not get an Enum method.
+
+The simplest way to describe this is to see an example.
+Given file test.proto, containing
+
+ package example;
+
+ enum FOO { X = 17; }
+
+ message Test {
+ required string label = 1;
+ optional int32 type = 2 [default=77];
+ repeated int64 reps = 3;
+ optional group OptionalGroup = 4 {
+ required string RequiredField = 5;
+ }
+ oneof union {
+ int32 number = 6;
+ string name = 7;
+ }
+ }
+
+The resulting file, test.pb.go, is:
+
+ package example
+
+ import proto "github.com/gogo/protobuf/proto"
+ import math "math"
+
+ type FOO int32
+ const (
+ FOO_X FOO = 17
+ )
+ var FOO_name = map[int32]string{
+ 17: "X",
+ }
+ var FOO_value = map[string]int32{
+ "X": 17,
+ }
+
+ func (x FOO) Enum() *FOO {
+ p := new(FOO)
+ *p = x
+ return p
+ }
+ func (x FOO) String() string {
+ return proto.EnumName(FOO_name, int32(x))
+ }
+ func (x *FOO) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+ if err != nil {
+ return err
+ }
+ *x = FOO(value)
+ return nil
+ }
+
+ type Test struct {
+ Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+ Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+ Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+ Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+ // Types that are valid to be assigned to Union:
+ // *Test_Number
+ // *Test_Name
+ Union isTest_Union `protobuf_oneof:"union"`
+ XXX_unrecognized []byte `json:"-"`
+ }
+ func (m *Test) Reset() { *m = Test{} }
+ func (m *Test) String() string { return proto.CompactTextString(m) }
+ func (*Test) ProtoMessage() {}
+
+ type isTest_Union interface {
+ isTest_Union()
+ }
+
+ type Test_Number struct {
+ Number int32 `protobuf:"varint,6,opt,name=number"`
+ }
+ type Test_Name struct {
+ Name string `protobuf:"bytes,7,opt,name=name"`
+ }
+
+ func (*Test_Number) isTest_Union() {}
+ func (*Test_Name) isTest_Union() {}
+
+ func (m *Test) GetUnion() isTest_Union {
+ if m != nil {
+ return m.Union
+ }
+ return nil
+ }
+ const Default_Test_Type int32 = 77
+
+ func (m *Test) GetLabel() string {
+ if m != nil && m.Label != nil {
+ return *m.Label
+ }
+ return ""
+ }
+
+ func (m *Test) GetType() int32 {
+ if m != nil && m.Type != nil {
+ return *m.Type
+ }
+ return Default_Test_Type
+ }
+
+ func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+ if m != nil {
+ return m.Optionalgroup
+ }
+ return nil
+ }
+
+ type Test_OptionalGroup struct {
+ RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+ }
+ func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} }
+ func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+ func (m *Test_OptionalGroup) GetRequiredField() string {
+ if m != nil && m.RequiredField != nil {
+ return *m.RequiredField
+ }
+ return ""
+ }
+
+ func (m *Test) GetNumber() int32 {
+ if x, ok := m.GetUnion().(*Test_Number); ok {
+ return x.Number
+ }
+ return 0
+ }
+
+ func (m *Test) GetName() string {
+ if x, ok := m.GetUnion().(*Test_Name); ok {
+ return x.Name
+ }
+ return ""
+ }
+
+ func init() {
+ proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+ }
+
+To create and play with a Test object:
+
+ package main
+
+ import (
+ "log"
+
+ "github.com/gogo/protobuf/proto"
+ pb "./example.pb"
+ )
+
+ func main() {
+ test := &pb.Test{
+ Label: proto.String("hello"),
+ Type: proto.Int32(17),
+ Reps: []int64{1, 2, 3},
+ Optionalgroup: &pb.Test_OptionalGroup{
+ RequiredField: proto.String("good bye"),
+ },
+ Union: &pb.Test_Name{"fred"},
+ }
+ data, err := proto.Marshal(test)
+ if err != nil {
+ log.Fatal("marshaling error: ", err)
+ }
+ newTest := &pb.Test{}
+ err = proto.Unmarshal(data, newTest)
+ if err != nil {
+ log.Fatal("unmarshaling error: ", err)
+ }
+ // Now test and newTest contain the same data.
+ if test.GetLabel() != newTest.GetLabel() {
+ log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+ }
+ // Use a type switch to determine which oneof was set.
+ switch u := test.Union.(type) {
+ case *pb.Test_Number: // u.Number contains the number.
+ case *pb.Test_Name: // u.Name contains the string.
+ }
+ // etc.
+ }
+*/
+package proto
+
+import (
+ "encoding/json"
+ "fmt"
+ "log"
+ "reflect"
+ "sort"
+ "strconv"
+ "sync"
+)
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+ Reset()
+ String() string
+ ProtoMessage()
+}
+
+// Stats records allocation details about the protocol buffer encoders
+// and decoders. Useful for tuning the library itself.
+type Stats struct {
+ Emalloc uint64 // mallocs in encode
+ Dmalloc uint64 // mallocs in decode
+ Encode uint64 // number of encodes
+ Decode uint64 // number of decodes
+ Chit uint64 // number of cache hits
+ Cmiss uint64 // number of cache misses
+ Size uint64 // number of sizes
+}
+
+// Set to true to enable stats collection.
+const collectStats = false
+
+var stats Stats
+
+// GetStats returns a copy of the global Stats structure.
+func GetStats() Stats { return stats }
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers. It may be reused between invocations to
+// reduce memory usage. It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+ buf []byte // encode/decode byte stream
+ index int // write point
+
+ // pools of basic types to amortize allocation.
+ bools []bool
+ uint32s []uint32
+ uint64s []uint64
+
+ // extra pools, only used with pointer_reflect.go
+ int32s []int32
+ int64s []int64
+ float32s []float32
+ float64s []float64
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+ return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+ p.buf = p.buf[0:0] // for reading/writing
+ p.index = 0 // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+ p.buf = s
+ p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+ return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+ return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+ p := new(int32)
+ *p = int32(v)
+ return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+ return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+ return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+ return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+ return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+ return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+ return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name. Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+ s, ok := m[v]
+ if ok {
+ return s
+ }
+ return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+ if data[0] == '"' {
+ // New style: enums are strings.
+ var repr string
+ if err := json.Unmarshal(data, &repr); err != nil {
+ return -1, err
+ }
+ val, ok := m[repr]
+ if !ok {
+ return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+ }
+ return val, nil
+ }
+ // Old style: enums are ints.
+ var val int32
+ if err := json.Unmarshal(data, &val); err != nil {
+ return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+ }
+ return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (p *Buffer) DebugPrint(s string, b []byte) {
+ var u uint64
+
+ obuf := p.buf
+ sindex := p.index
+ p.buf = b
+ p.index = 0
+ depth := 0
+
+ fmt.Printf("\n--- %s ---\n", s)
+
+out:
+ for {
+ for i := 0; i < depth; i++ {
+ fmt.Print(" ")
+ }
+
+ index := p.index
+ if index == len(p.buf) {
+ break
+ }
+
+ op, err := p.DecodeVarint()
+ if err != nil {
+ fmt.Printf("%3d: fetching op err %v\n", index, err)
+ break out
+ }
+ tag := op >> 3
+ wire := op & 7
+
+ switch wire {
+ default:
+ fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+ index, tag, wire)
+ break out
+
+ case WireBytes:
+ var r []byte
+
+ r, err = p.DecodeRawBytes(false)
+ if err != nil {
+ break out
+ }
+ fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+ if len(r) <= 6 {
+ for i := 0; i < len(r); i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ } else {
+ for i := 0; i < 3; i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ fmt.Printf(" ..")
+ for i := len(r) - 3; i < len(r); i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ }
+ fmt.Printf("\n")
+
+ case WireFixed32:
+ u, err = p.DecodeFixed32()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+ case WireFixed64:
+ u, err = p.DecodeFixed64()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+
+ case WireVarint:
+ u, err = p.DecodeVarint()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+ case WireStartGroup:
+ fmt.Printf("%3d: t=%3d start\n", index, tag)
+ depth++
+
+ case WireEndGroup:
+ depth--
+ fmt.Printf("%3d: t=%3d end\n", index, tag)
+ }
+ }
+
+ if depth != 0 {
+ fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
+ }
+ fmt.Printf("\n")
+
+ p.buf = obuf
+ p.index = sindex
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+ setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a pointer to a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+ v = v.Elem()
+
+ defaultMu.RLock()
+ dm, ok := defaults[v.Type()]
+ defaultMu.RUnlock()
+ if !ok {
+ dm = buildDefaultMessage(v.Type())
+ defaultMu.Lock()
+ defaults[v.Type()] = dm
+ defaultMu.Unlock()
+ }
+
+ for _, sf := range dm.scalars {
+ f := v.Field(sf.index)
+ if !f.IsNil() {
+ // field already set
+ continue
+ }
+ dv := sf.value
+ if dv == nil && !zeros {
+ // no explicit default, and don't want to set zeros
+ continue
+ }
+ fptr := f.Addr().Interface() // **T
+ // TODO: Consider batching the allocations we do here.
+ switch sf.kind {
+ case reflect.Bool:
+ b := new(bool)
+ if dv != nil {
+ *b = dv.(bool)
+ }
+ *(fptr.(**bool)) = b
+ case reflect.Float32:
+ f := new(float32)
+ if dv != nil {
+ *f = dv.(float32)
+ }
+ *(fptr.(**float32)) = f
+ case reflect.Float64:
+ f := new(float64)
+ if dv != nil {
+ *f = dv.(float64)
+ }
+ *(fptr.(**float64)) = f
+ case reflect.Int32:
+ // might be an enum
+ if ft := f.Type(); ft != int32PtrType {
+ // enum
+ f.Set(reflect.New(ft.Elem()))
+ if dv != nil {
+ f.Elem().SetInt(int64(dv.(int32)))
+ }
+ } else {
+ // int32 field
+ i := new(int32)
+ if dv != nil {
+ *i = dv.(int32)
+ }
+ *(fptr.(**int32)) = i
+ }
+ case reflect.Int64:
+ i := new(int64)
+ if dv != nil {
+ *i = dv.(int64)
+ }
+ *(fptr.(**int64)) = i
+ case reflect.String:
+ s := new(string)
+ if dv != nil {
+ *s = dv.(string)
+ }
+ *(fptr.(**string)) = s
+ case reflect.Uint8:
+ // exceptional case: []byte
+ var b []byte
+ if dv != nil {
+ db := dv.([]byte)
+ b = make([]byte, len(db))
+ copy(b, db)
+ } else {
+ b = []byte{}
+ }
+ *(fptr.(*[]byte)) = b
+ case reflect.Uint32:
+ u := new(uint32)
+ if dv != nil {
+ *u = dv.(uint32)
+ }
+ *(fptr.(**uint32)) = u
+ case reflect.Uint64:
+ u := new(uint64)
+ if dv != nil {
+ *u = dv.(uint64)
+ }
+ *(fptr.(**uint64)) = u
+ default:
+ log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+ }
+ }
+
+ for _, ni := range dm.nested {
+ f := v.Field(ni)
+ // f is *T or []*T or map[T]*T
+ switch f.Kind() {
+ case reflect.Ptr:
+ if f.IsNil() {
+ continue
+ }
+ setDefaults(f, recur, zeros)
+
+ case reflect.Slice:
+ for i := 0; i < f.Len(); i++ {
+ e := f.Index(i)
+ if e.IsNil() {
+ continue
+ }
+ setDefaults(e, recur, zeros)
+ }
+
+ case reflect.Map:
+ for _, k := range f.MapKeys() {
+ e := f.MapIndex(k)
+ if e.IsNil() {
+ continue
+ }
+ setDefaults(e, recur, zeros)
+ }
+ }
+ }
+}
+
+var (
+ // defaults maps a protocol buffer struct type to a slice of the fields,
+ // with its scalar fields set to their proto-declared non-zero default values.
+ defaultMu sync.RWMutex
+ defaults = make(map[reflect.Type]defaultMessage)
+
+ int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+ scalars []scalarField
+ nested []int // struct field index of nested messages
+}
+
+type scalarField struct {
+ index int // struct field index
+ kind reflect.Kind // element type (the T in *T or []T)
+ value interface{} // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+ sprop := GetProperties(t)
+ for _, prop := range sprop.Prop {
+ fi, ok := sprop.decoderTags.get(prop.Tag)
+ if !ok {
+ // XXX_unrecognized
+ continue
+ }
+ ft := t.Field(fi).Type
+
+ sf, nested, err := fieldDefault(ft, prop)
+ switch {
+ case err != nil:
+ log.Print(err)
+ case nested:
+ dm.nested = append(dm.nested, fi)
+ case sf != nil:
+ sf.index = fi
+ dm.scalars = append(dm.scalars, *sf)
+ }
+ }
+
+ return dm
+}
+
+// fieldDefault returns the scalarField for field type ft.
+// sf will be nil if the field can not have a default.
+// nestedMessage will be true if this is a nested message.
+// Note that sf.index is not set on return.
+func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
+ var canHaveDefault bool
+ switch ft.Kind() {
+ case reflect.Ptr:
+ if ft.Elem().Kind() == reflect.Struct {
+ nestedMessage = true
+ } else {
+ canHaveDefault = true // proto2 scalar field
+ }
+
+ case reflect.Slice:
+ switch ft.Elem().Kind() {
+ case reflect.Ptr:
+ nestedMessage = true // repeated message
+ case reflect.Uint8:
+ canHaveDefault = true // bytes field
+ }
+
+ case reflect.Map:
+ if ft.Elem().Kind() == reflect.Ptr {
+ nestedMessage = true // map with message values
+ }
+ }
+
+ if !canHaveDefault {
+ if nestedMessage {
+ return nil, true, nil
+ }
+ return nil, false, nil
+ }
+
+ // We now know that ft is a pointer or slice.
+ sf = &scalarField{kind: ft.Elem().Kind()}
+
+ // scalar fields without defaults
+ if !prop.HasDefault {
+ return sf, false, nil
+ }
+
+ // a scalar field: either *T or []byte
+ switch ft.Elem().Kind() {
+ case reflect.Bool:
+ x, err := strconv.ParseBool(prop.Default)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.Float32:
+ x, err := strconv.ParseFloat(prop.Default, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
+ }
+ sf.value = float32(x)
+ case reflect.Float64:
+ x, err := strconv.ParseFloat(prop.Default, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.Int32:
+ x, err := strconv.ParseInt(prop.Default, 10, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
+ }
+ sf.value = int32(x)
+ case reflect.Int64:
+ x, err := strconv.ParseInt(prop.Default, 10, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.String:
+ sf.value = prop.Default
+ case reflect.Uint8:
+ // []byte (not *uint8)
+ sf.value = []byte(prop.Default)
+ case reflect.Uint32:
+ x, err := strconv.ParseUint(prop.Default, 10, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
+ }
+ sf.value = uint32(x)
+ case reflect.Uint64:
+ x, err := strconv.ParseUint(prop.Default, 10, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ default:
+ return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
+ }
+
+ return sf, false, nil
+}
+
+// Map fields may have key types of non-float scalars, strings and enums.
+// The easiest way to sort them in some deterministic order is to use fmt.
+// If this turns out to be inefficient we can always consider other options,
+// such as doing a Schwartzian transform.
+
+func mapKeys(vs []reflect.Value) sort.Interface {
+ s := mapKeySorter{
+ vs: vs,
+ // default Less function: textual comparison
+ less: func(a, b reflect.Value) bool {
+ return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())
+ },
+ }
+
+ // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps;
+ // numeric keys are sorted numerically.
+ if len(vs) == 0 {
+ return s
+ }
+ switch vs[0].Kind() {
+ case reflect.Int32, reflect.Int64:
+ s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+ case reflect.Uint32, reflect.Uint64:
+ s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+ }
+
+ return s
+}
+
+type mapKeySorter struct {
+ vs []reflect.Value
+ less func(a, b reflect.Value) bool
+}
+
+func (s mapKeySorter) Len() int { return len(s.vs) }
+func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
+func (s mapKeySorter) Less(i, j int) bool {
+ return s.less(s.vs[i], s.vs[j])
+}
+
+// isProto3Zero reports whether v is a zero proto3 value.
+func isProto3Zero(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint32, reflect.Uint64:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.String:
+ return v.String() == ""
+ }
+ return false
+}
+
+// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion2 = true
+
+// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion1 = true
diff --git a/vendor/github.com/gogo/protobuf/proto/lib_gogo.go b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b4f7c909e6ba42eecbbea6300bfbbfd4f70708c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
@@ -0,0 +1,42 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "encoding/json"
+ "strconv"
+)
+
+func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) {
+ s, ok := m[value]
+ if !ok {
+ s = strconv.Itoa(int(value))
+ }
+ return json.Marshal(s)
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/gogo/protobuf/proto/message_set.go
similarity index 88%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/message_set.go
rename to vendor/github.com/gogo/protobuf/proto/message_set.go
index e25e01e637483854ff51d528627d83065d525827..fd982decd66e4846031a72a785470be20afe99a5 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/message_set.go
+++ b/vendor/github.com/gogo/protobuf/proto/message_set.go
@@ -149,9 +149,21 @@ func skipVarint(buf []byte) []byte {
// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSet(m map[int32]Extension) ([]byte, error) {
- if err := encodeExtensionMap(m); err != nil {
- return nil, err
+func MarshalMessageSet(exts interface{}) ([]byte, error) {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ if err := encodeExtensions(exts); err != nil {
+ return nil, err
+ }
+ m, _ = exts.extensionsRead()
+ case map[int32]Extension:
+ if err := encodeExtensionsMap(exts); err != nil {
+ return nil, err
+ }
+ m = exts
+ default:
+ return nil, errors.New("proto: not an extension map")
}
// Sort extension IDs to provide a deterministic encoding.
@@ -178,7 +190,17 @@ func MarshalMessageSet(m map[int32]Extension) ([]byte, error) {
// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error {
+func UnmarshalMessageSet(buf []byte, exts interface{}) error {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ m = exts.extensionsWrite()
+ case map[int32]Extension:
+ m = exts
+ default:
+ return errors.New("proto: not an extension map")
+ }
+
ms := new(messageSet)
if err := Unmarshal(buf, ms); err != nil {
return err
@@ -209,7 +231,16 @@ func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error {
// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) {
+func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ m, _ = exts.extensionsRead()
+ case map[int32]Extension:
+ m = exts
+ default:
+ return nil, errors.New("proto: not an extension map")
+ }
var b bytes.Buffer
b.WriteByte('{')
@@ -252,7 +283,7 @@ func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) {
// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSetJSON(buf []byte, m map[int32]Extension) error {
+func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
// Common-case fast path.
if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
return nil
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_reflect.go
rename to vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
index 749919d250a1acffc5588a004501ee6b829d9059..fb512e2e16dce05683722f810c279367bdc68fe9 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_reflect.go
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
@@ -29,7 +29,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// +build appengine
+// +build appengine js
// This file contains an implementation of proto field accesses using package reflect.
// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
@@ -139,6 +139,11 @@ func structPointer_StringSlice(p structPointer, f field) *[]string {
return structPointer_ifield(p, f).(*[]string)
}
+// Extensions returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+ return structPointer_ifield(p, f).(*XXX_InternalExtensions)
+}
+
// ExtMap returns the address of an extension map field in the struct.
func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
return structPointer_ifield(p, f).(*map[int32]Extension)
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_unsafe.go
rename to vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
index e9be0fe92ee708ad56688e024dadb2b21821be8c..6b5567d47cd396b25370f8c06bad3b851776658f 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
@@ -29,7 +29,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// +build !appengine
+// +build !appengine,!js
// This file contains the implementation of the proto field accesses using package unsafe.
@@ -126,6 +126,10 @@ func structPointer_StringSlice(p structPointer, f field) *[]string {
}
// ExtMap returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+ return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))
}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..132ea4dfd927a48187c8beb086ca14e3dd91a1a9
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
@@ -0,0 +1,110 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+ "reflect"
+ "unsafe"
+)
+
+func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} {
+ point := unsafe.Pointer(uintptr(p) + uintptr(f))
+ r := reflect.NewAt(t, point)
+ return r.Interface()
+}
+
+func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} {
+ point := unsafe.Pointer(uintptr(p) + uintptr(f))
+ r := reflect.NewAt(t, point)
+ if r.Elem().IsNil() {
+ return nil
+ }
+ return r.Elem().Interface()
+}
+
+func copyUintPtr(oldptr, newptr uintptr, size int) {
+ oldbytes := make([]byte, 0)
+ oldslice := (*reflect.SliceHeader)(unsafe.Pointer(&oldbytes))
+ oldslice.Data = oldptr
+ oldslice.Len = size
+ oldslice.Cap = size
+ newbytes := make([]byte, 0)
+ newslice := (*reflect.SliceHeader)(unsafe.Pointer(&newbytes))
+ newslice.Data = newptr
+ newslice.Len = size
+ newslice.Cap = size
+ copy(newbytes, oldbytes)
+}
+
+func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) {
+ copyUintPtr(uintptr(oldptr), uintptr(newptr), size)
+}
+
+func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer {
+ size := typ.Elem().Size()
+ oldHeader := structPointer_GetSliceHeader(base, f)
+ newLen := oldHeader.Len + 1
+ slice := reflect.MakeSlice(typ, newLen, newLen)
+ bas := toStructPointer(slice)
+ for i := 0; i < oldHeader.Len; i++ {
+ newElemptr := uintptr(bas) + uintptr(i)*size
+ oldElemptr := oldHeader.Data + uintptr(i)*size
+ copyUintPtr(oldElemptr, newElemptr, int(size))
+ }
+
+ oldHeader.Data = uintptr(bas)
+ oldHeader.Len = newLen
+ oldHeader.Cap = newLen
+
+ return structPointer(unsafe.Pointer(uintptr(unsafe.Pointer(bas)) + uintptr(uintptr(newLen-1)*size)))
+}
+
+func structPointer_FieldPointer(p structPointer, f field) structPointer {
+ return structPointer(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_GetRefStructPointer(p structPointer, f field) structPointer {
+ return structPointer((*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader {
+ return (*reflect.SliceHeader)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_Add(p structPointer, size field) structPointer {
+ return structPointer(unsafe.Pointer(uintptr(p) + uintptr(size)))
+}
+
+func structPointer_Len(p structPointer, f field) int {
+ return len(*(*[]interface{})(unsafe.Pointer(structPointer_GetRefStructPointer(p, f))))
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go
new file mode 100644
index 0000000000000000000000000000000000000000..3e4cad038132abe1c5ac7025779a60cd37d1cfa8
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties.go
@@ -0,0 +1,940 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+ "fmt"
+ "log"
+ "os"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+ WireVarint = 0
+ WireFixed64 = 1
+ WireBytes = 2
+ WireStartGroup = 3
+ WireEndGroup = 4
+ WireFixed32 = 5
+)
+
+const startSize = 10 // initial slice/string sizes
+
+// Encoders are defined in encode.go
+// An encoder outputs the full representation of a field, including its
+// tag and encoder type.
+type encoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueEncoder encodes a single integer in a particular encoding.
+type valueEncoder func(o *Buffer, x uint64) error
+
+// Sizers are defined in encode.go
+// A sizer returns the encoded size of a field, including its tag and encoder
+// type.
+type sizer func(prop *Properties, base structPointer) int
+
+// A valueSizer returns the encoded size of a single integer in a particular
+// encoding.
+type valueSizer func(x uint64) int
+
+// Decoders are defined in decode.go
+// A decoder creates a value from its wire representation.
+// Unrecognized subelements are saved in unrec.
+type decoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueDecoder decodes a single integer in a particular encoding.
+type valueDecoder func(o *Buffer) (x uint64, err error)
+
+// A oneofMarshaler does the marshaling for all oneof fields in a message.
+type oneofMarshaler func(Message, *Buffer) error
+
+// A oneofUnmarshaler does the unmarshaling for a oneof field in a message.
+type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error)
+
+// A oneofSizer does the sizing for all oneof fields in a message.
+type oneofSizer func(Message) int
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+ fastTags []int
+ slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+ if t > 0 && t < tagMapFastLimit {
+ if t >= len(p.fastTags) {
+ return 0, false
+ }
+ fi := p.fastTags[t]
+ return fi, fi >= 0
+ }
+ fi, ok := p.slowTags[t]
+ return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+ if t > 0 && t < tagMapFastLimit {
+ for len(p.fastTags) < t+1 {
+ p.fastTags = append(p.fastTags, -1)
+ }
+ p.fastTags[t] = fi
+ return
+ }
+ if p.slowTags == nil {
+ p.slowTags = make(map[int]int)
+ }
+ p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
+type StructProperties struct {
+ Prop []*Properties // properties for each field
+ reqCount int // required count
+ decoderTags tagMap // map from proto tag to struct field number
+ decoderOrigNames map[string]int // map from original name to struct field number
+ order []int // list of struct field numbers in tag order
+ unrecField field // field id of the XXX_unrecognized []byte field
+ extendable bool // is this an extendable proto
+
+ oneofMarshaler oneofMarshaler
+ oneofUnmarshaler oneofUnmarshaler
+ oneofSizer oneofSizer
+ stype reflect.Type
+
+ // OneofTypes contains information about the oneof fields in this message.
+ // It is keyed by the original name of a field.
+ OneofTypes map[string]*OneofProperties
+}
+
+// OneofProperties represents information about a specific field in a oneof.
+type OneofProperties struct {
+ Type reflect.Type // pointer to generated struct type for this oneof field
+ Field int // struct field number of the containing oneof in the message
+ Prop *Properties
+}
+
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+ return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+ Name string // name of the field, for error messages
+ OrigName string // original name before protocol compiler (always set)
+ JSONName string // name to use for JSON; determined by protoc
+ Wire string
+ WireType int
+ Tag int
+ Required bool
+ Optional bool
+ Repeated bool
+ Packed bool // relevant for repeated primitives only
+ Enum string // set for enum types only
+ proto3 bool // whether this is known to be a proto3 field; set for []byte only
+ oneof bool // whether this is a oneof field
+
+ Default string // default value
+ HasDefault bool // whether an explicit default was provided
+ CustomType string
+ def_uint64 uint64
+
+ enc encoder
+ valEnc valueEncoder // set for bool and numeric types only
+ field field
+ tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType)
+ tagbuf [8]byte
+ stype reflect.Type // set for struct types only
+ sstype reflect.Type // set for slices of structs types only
+ ctype reflect.Type // set for custom types only
+ sprop *StructProperties // set for struct types only
+ isMarshaler bool
+ isUnmarshaler bool
+
+ mtype reflect.Type // set for map types only
+ mkeyprop *Properties // set for map types only
+ mvalprop *Properties // set for map types only
+
+ size sizer
+ valSize valueSizer // set for bool and numeric types only
+
+ dec decoder
+ valDec valueDecoder // set for bool and numeric types only
+
+ // If this is a packable field, this will be the decoder for the packed version of the field.
+ packedDec decoder
+}
+
+// String formats the properties in the protobuf struct field tag style.
+func (p *Properties) String() string {
+ s := p.Wire
+ s = ","
+ s += strconv.Itoa(p.Tag)
+ if p.Required {
+ s += ",req"
+ }
+ if p.Optional {
+ s += ",opt"
+ }
+ if p.Repeated {
+ s += ",rep"
+ }
+ if p.Packed {
+ s += ",packed"
+ }
+ s += ",name=" + p.OrigName
+ if p.JSONName != p.OrigName {
+ s += ",json=" + p.JSONName
+ }
+ if p.proto3 {
+ s += ",proto3"
+ }
+ if p.oneof {
+ s += ",oneof"
+ }
+ if len(p.Enum) > 0 {
+ s += ",enum=" + p.Enum
+ }
+ if p.HasDefault {
+ s += ",def=" + p.Default
+ }
+ return s
+}
+
+// Parse populates p by parsing a string in the protobuf struct field tag style.
+func (p *Properties) Parse(s string) {
+ // "bytes,49,opt,name=foo,def=hello!"
+ fields := strings.Split(s, ",") // breaks def=, but handled below.
+ if len(fields) < 2 {
+ fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
+ return
+ }
+
+ p.Wire = fields[0]
+ switch p.Wire {
+ case "varint":
+ p.WireType = WireVarint
+ p.valEnc = (*Buffer).EncodeVarint
+ p.valDec = (*Buffer).DecodeVarint
+ p.valSize = sizeVarint
+ case "fixed32":
+ p.WireType = WireFixed32
+ p.valEnc = (*Buffer).EncodeFixed32
+ p.valDec = (*Buffer).DecodeFixed32
+ p.valSize = sizeFixed32
+ case "fixed64":
+ p.WireType = WireFixed64
+ p.valEnc = (*Buffer).EncodeFixed64
+ p.valDec = (*Buffer).DecodeFixed64
+ p.valSize = sizeFixed64
+ case "zigzag32":
+ p.WireType = WireVarint
+ p.valEnc = (*Buffer).EncodeZigzag32
+ p.valDec = (*Buffer).DecodeZigzag32
+ p.valSize = sizeZigzag32
+ case "zigzag64":
+ p.WireType = WireVarint
+ p.valEnc = (*Buffer).EncodeZigzag64
+ p.valDec = (*Buffer).DecodeZigzag64
+ p.valSize = sizeZigzag64
+ case "bytes", "group":
+ p.WireType = WireBytes
+ // no numeric converter for non-numeric types
+ default:
+ fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
+ return
+ }
+
+ var err error
+ p.Tag, err = strconv.Atoi(fields[1])
+ if err != nil {
+ return
+ }
+
+ for i := 2; i < len(fields); i++ {
+ f := fields[i]
+ switch {
+ case f == "req":
+ p.Required = true
+ case f == "opt":
+ p.Optional = true
+ case f == "rep":
+ p.Repeated = true
+ case f == "packed":
+ p.Packed = true
+ case strings.HasPrefix(f, "name="):
+ p.OrigName = f[5:]
+ case strings.HasPrefix(f, "json="):
+ p.JSONName = f[5:]
+ case strings.HasPrefix(f, "enum="):
+ p.Enum = f[5:]
+ case f == "proto3":
+ p.proto3 = true
+ case f == "oneof":
+ p.oneof = true
+ case strings.HasPrefix(f, "def="):
+ p.HasDefault = true
+ p.Default = f[4:] // rest of string
+ if i+1 < len(fields) {
+ // Commas aren't escaped, and def is always last.
+ p.Default += "," + strings.Join(fields[i+1:], ",")
+ break
+ }
+ case strings.HasPrefix(f, "embedded="):
+ p.OrigName = strings.Split(f, "=")[1]
+ case strings.HasPrefix(f, "customtype="):
+ p.CustomType = strings.Split(f, "=")[1]
+ }
+ }
+}
+
+func logNoSliceEnc(t1, t2 reflect.Type) {
+ fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
+}
+
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// Initialize the fields for encoding and decoding.
+func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+ p.enc = nil
+ p.dec = nil
+ p.size = nil
+ if len(p.CustomType) > 0 {
+ p.setCustomEncAndDec(typ)
+ p.setTag(lockGetProp)
+ return
+ }
+ switch t1 := typ; t1.Kind() {
+ default:
+ fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1)
+
+ // proto3 scalar types
+
+ case reflect.Bool:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_bool
+ p.dec = (*Buffer).dec_proto3_bool
+ p.size = size_proto3_bool
+ } else {
+ p.enc = (*Buffer).enc_ref_bool
+ p.dec = (*Buffer).dec_proto3_bool
+ p.size = size_ref_bool
+ }
+ case reflect.Int32:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_int32
+ p.dec = (*Buffer).dec_proto3_int32
+ p.size = size_proto3_int32
+ } else {
+ p.enc = (*Buffer).enc_ref_int32
+ p.dec = (*Buffer).dec_proto3_int32
+ p.size = size_ref_int32
+ }
+ case reflect.Uint32:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_uint32
+ p.dec = (*Buffer).dec_proto3_int32 // can reuse
+ p.size = size_proto3_uint32
+ } else {
+ p.enc = (*Buffer).enc_ref_uint32
+ p.dec = (*Buffer).dec_proto3_int32 // can reuse
+ p.size = size_ref_uint32
+ }
+ case reflect.Int64, reflect.Uint64:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_int64
+ p.dec = (*Buffer).dec_proto3_int64
+ p.size = size_proto3_int64
+ } else {
+ p.enc = (*Buffer).enc_ref_int64
+ p.dec = (*Buffer).dec_proto3_int64
+ p.size = size_ref_int64
+ }
+ case reflect.Float32:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits
+ p.dec = (*Buffer).dec_proto3_int32
+ p.size = size_proto3_uint32
+ } else {
+ p.enc = (*Buffer).enc_ref_uint32 // can just treat them as bits
+ p.dec = (*Buffer).dec_proto3_int32
+ p.size = size_ref_uint32
+ }
+ case reflect.Float64:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits
+ p.dec = (*Buffer).dec_proto3_int64
+ p.size = size_proto3_int64
+ } else {
+ p.enc = (*Buffer).enc_ref_int64 // can just treat them as bits
+ p.dec = (*Buffer).dec_proto3_int64
+ p.size = size_ref_int64
+ }
+ case reflect.String:
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_string
+ p.dec = (*Buffer).dec_proto3_string
+ p.size = size_proto3_string
+ } else {
+ p.enc = (*Buffer).enc_ref_string
+ p.dec = (*Buffer).dec_proto3_string
+ p.size = size_ref_string
+ }
+ case reflect.Struct:
+ p.stype = typ
+ p.isMarshaler = isMarshaler(typ)
+ p.isUnmarshaler = isUnmarshaler(typ)
+ if p.Wire == "bytes" {
+ p.enc = (*Buffer).enc_ref_struct_message
+ p.dec = (*Buffer).dec_ref_struct_message
+ p.size = size_ref_struct_message
+ } else {
+ fmt.Fprintf(os.Stderr, "proto: no coders for struct %T\n", typ)
+ }
+
+ case reflect.Ptr:
+ switch t2 := t1.Elem(); t2.Kind() {
+ default:
+ fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2)
+ break
+ case reflect.Bool:
+ p.enc = (*Buffer).enc_bool
+ p.dec = (*Buffer).dec_bool
+ p.size = size_bool
+ case reflect.Int32:
+ p.enc = (*Buffer).enc_int32
+ p.dec = (*Buffer).dec_int32
+ p.size = size_int32
+ case reflect.Uint32:
+ p.enc = (*Buffer).enc_uint32
+ p.dec = (*Buffer).dec_int32 // can reuse
+ p.size = size_uint32
+ case reflect.Int64, reflect.Uint64:
+ p.enc = (*Buffer).enc_int64
+ p.dec = (*Buffer).dec_int64
+ p.size = size_int64
+ case reflect.Float32:
+ p.enc = (*Buffer).enc_uint32 // can just treat them as bits
+ p.dec = (*Buffer).dec_int32
+ p.size = size_uint32
+ case reflect.Float64:
+ p.enc = (*Buffer).enc_int64 // can just treat them as bits
+ p.dec = (*Buffer).dec_int64
+ p.size = size_int64
+ case reflect.String:
+ p.enc = (*Buffer).enc_string
+ p.dec = (*Buffer).dec_string
+ p.size = size_string
+ case reflect.Struct:
+ p.stype = t1.Elem()
+ p.isMarshaler = isMarshaler(t1)
+ p.isUnmarshaler = isUnmarshaler(t1)
+ if p.Wire == "bytes" {
+ p.enc = (*Buffer).enc_struct_message
+ p.dec = (*Buffer).dec_struct_message
+ p.size = size_struct_message
+ } else {
+ p.enc = (*Buffer).enc_struct_group
+ p.dec = (*Buffer).dec_struct_group
+ p.size = size_struct_group
+ }
+ }
+
+ case reflect.Slice:
+ switch t2 := t1.Elem(); t2.Kind() {
+ default:
+ logNoSliceEnc(t1, t2)
+ break
+ case reflect.Bool:
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_bool
+ p.size = size_slice_packed_bool
+ } else {
+ p.enc = (*Buffer).enc_slice_bool
+ p.size = size_slice_bool
+ }
+ p.dec = (*Buffer).dec_slice_bool
+ p.packedDec = (*Buffer).dec_slice_packed_bool
+ case reflect.Int32:
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_int32
+ p.size = size_slice_packed_int32
+ } else {
+ p.enc = (*Buffer).enc_slice_int32
+ p.size = size_slice_int32
+ }
+ p.dec = (*Buffer).dec_slice_int32
+ p.packedDec = (*Buffer).dec_slice_packed_int32
+ case reflect.Uint32:
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_uint32
+ p.size = size_slice_packed_uint32
+ } else {
+ p.enc = (*Buffer).enc_slice_uint32
+ p.size = size_slice_uint32
+ }
+ p.dec = (*Buffer).dec_slice_int32
+ p.packedDec = (*Buffer).dec_slice_packed_int32
+ case reflect.Int64, reflect.Uint64:
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_int64
+ p.size = size_slice_packed_int64
+ } else {
+ p.enc = (*Buffer).enc_slice_int64
+ p.size = size_slice_int64
+ }
+ p.dec = (*Buffer).dec_slice_int64
+ p.packedDec = (*Buffer).dec_slice_packed_int64
+ case reflect.Uint8:
+ p.dec = (*Buffer).dec_slice_byte
+ if p.proto3 {
+ p.enc = (*Buffer).enc_proto3_slice_byte
+ p.size = size_proto3_slice_byte
+ } else {
+ p.enc = (*Buffer).enc_slice_byte
+ p.size = size_slice_byte
+ }
+ case reflect.Float32, reflect.Float64:
+ switch t2.Bits() {
+ case 32:
+ // can just treat them as bits
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_uint32
+ p.size = size_slice_packed_uint32
+ } else {
+ p.enc = (*Buffer).enc_slice_uint32
+ p.size = size_slice_uint32
+ }
+ p.dec = (*Buffer).dec_slice_int32
+ p.packedDec = (*Buffer).dec_slice_packed_int32
+ case 64:
+ // can just treat them as bits
+ if p.Packed {
+ p.enc = (*Buffer).enc_slice_packed_int64
+ p.size = size_slice_packed_int64
+ } else {
+ p.enc = (*Buffer).enc_slice_int64
+ p.size = size_slice_int64
+ }
+ p.dec = (*Buffer).dec_slice_int64
+ p.packedDec = (*Buffer).dec_slice_packed_int64
+ default:
+ logNoSliceEnc(t1, t2)
+ break
+ }
+ case reflect.String:
+ p.enc = (*Buffer).enc_slice_string
+ p.dec = (*Buffer).dec_slice_string
+ p.size = size_slice_string
+ case reflect.Ptr:
+ switch t3 := t2.Elem(); t3.Kind() {
+ default:
+ fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
+ break
+ case reflect.Struct:
+ p.stype = t2.Elem()
+ p.isMarshaler = isMarshaler(t2)
+ p.isUnmarshaler = isUnmarshaler(t2)
+ if p.Wire == "bytes" {
+ p.enc = (*Buffer).enc_slice_struct_message
+ p.dec = (*Buffer).dec_slice_struct_message
+ p.size = size_slice_struct_message
+ } else {
+ p.enc = (*Buffer).enc_slice_struct_group
+ p.dec = (*Buffer).dec_slice_struct_group
+ p.size = size_slice_struct_group
+ }
+ }
+ case reflect.Slice:
+ switch t2.Elem().Kind() {
+ default:
+ fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
+ break
+ case reflect.Uint8:
+ p.enc = (*Buffer).enc_slice_slice_byte
+ p.dec = (*Buffer).dec_slice_slice_byte
+ p.size = size_slice_slice_byte
+ }
+ case reflect.Struct:
+ p.setSliceOfNonPointerStructs(t1)
+ }
+
+ case reflect.Map:
+ p.enc = (*Buffer).enc_new_map
+ p.dec = (*Buffer).dec_new_map
+ p.size = size_new_map
+
+ p.mtype = t1
+ p.mkeyprop = &Properties{}
+ p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+ p.mvalprop = &Properties{}
+ vtype := p.mtype.Elem()
+ if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+ // The value type is not a message (*T) or bytes ([]byte),
+ // so we need encoders for the pointer to this type.
+ vtype = reflect.PtrTo(vtype)
+ }
+ p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+ }
+ p.setTag(lockGetProp)
+}
+
+func (p *Properties) setTag(lockGetProp bool) {
+ // precalculate tag code
+ wire := p.WireType
+ if p.Packed {
+ wire = WireBytes
+ }
+ x := uint32(p.Tag)<<3 | uint32(wire)
+ i := 0
+ for i = 0; x > 127; i++ {
+ p.tagbuf[i] = 0x80 | uint8(x&0x7F)
+ x >>= 7
+ }
+ p.tagbuf[i] = uint8(x)
+ p.tagcode = p.tagbuf[0 : i+1]
+
+ if p.stype != nil {
+ if lockGetProp {
+ p.sprop = GetProperties(p.stype)
+ } else {
+ p.sprop = getPropertiesLocked(p.stype)
+ }
+ }
+}
+
+var (
+ marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
+ unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+)
+
+// isMarshaler reports whether type t implements Marshaler.
+func isMarshaler(t reflect.Type) bool {
+ return t.Implements(marshalerType)
+}
+
+// isUnmarshaler reports whether type t implements Unmarshaler.
+func isUnmarshaler(t reflect.Type) bool {
+ return t.Implements(unmarshalerType)
+}
+
+// Init populates the properties from a protocol buffer struct tag.
+func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+ p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+ // "bytes,49,opt,def=hello!"
+ p.Name = name
+ p.OrigName = name
+ if f != nil {
+ p.field = toField(f)
+ }
+ if tag == "" {
+ return
+ }
+ p.Parse(tag)
+ p.setEncAndDec(typ, f, lockGetProp)
+}
+
+var (
+ propertiesMu sync.RWMutex
+ propertiesMap = make(map[reflect.Type]*StructProperties)
+)
+
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
+func GetProperties(t reflect.Type) *StructProperties {
+ if t.Kind() != reflect.Struct {
+ panic("proto: type must have kind struct")
+ }
+
+ // Most calls to GetProperties in a long-running program will be
+ // retrieving details for types we have seen before.
+ propertiesMu.RLock()
+ sprop, ok := propertiesMap[t]
+ propertiesMu.RUnlock()
+ if ok {
+ if collectStats {
+ stats.Chit++
+ }
+ return sprop
+ }
+
+ propertiesMu.Lock()
+ sprop = getPropertiesLocked(t)
+ propertiesMu.Unlock()
+ return sprop
+}
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+ if prop, ok := propertiesMap[t]; ok {
+ if collectStats {
+ stats.Chit++
+ }
+ return prop
+ }
+ if collectStats {
+ stats.Cmiss++
+ }
+
+ prop := new(StructProperties)
+ // in case of recursive protos, fill this in now.
+ propertiesMap[t] = prop
+
+ // build properties
+ prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ||
+ reflect.PtrTo(t).Implements(extendableProtoV1Type) ||
+ reflect.PtrTo(t).Implements(extendableBytesType)
+ prop.unrecField = invalidField
+ prop.Prop = make([]*Properties, t.NumField())
+ prop.order = make([]int, t.NumField())
+
+ isOneofMessage := false
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ p := new(Properties)
+ name := f.Name
+ p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
+
+ if f.Name == "XXX_InternalExtensions" { // special case
+ p.enc = (*Buffer).enc_exts
+ p.dec = nil // not needed
+ p.size = size_exts
+ } else if f.Name == "XXX_extensions" { // special case
+ if len(f.Tag.Get("protobuf")) > 0 {
+ p.enc = (*Buffer).enc_ext_slice_byte
+ p.dec = nil // not needed
+ p.size = size_ext_slice_byte
+ } else {
+ p.enc = (*Buffer).enc_map
+ p.dec = nil // not needed
+ p.size = size_map
+ }
+ } else if f.Name == "XXX_unrecognized" { // special case
+ prop.unrecField = toField(&f)
+ }
+ oneof := f.Tag.Get("protobuf_oneof") // special case
+ if oneof != "" {
+ isOneofMessage = true
+ // Oneof fields don't use the traditional protobuf tag.
+ p.OrigName = oneof
+ }
+ prop.Prop[i] = p
+ prop.order[i] = i
+ if debug {
+ print(i, " ", f.Name, " ", t.String(), " ")
+ if p.Tag > 0 {
+ print(p.String())
+ }
+ print("\n")
+ }
+ if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" {
+ fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
+ }
+ }
+
+ // Re-order prop.order.
+ sort.Sort(prop)
+
+ type oneofMessage interface {
+ XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+ }
+ if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); isOneofMessage && ok {
+ var oots []interface{}
+ prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs()
+ prop.stype = t
+
+ // Interpret oneof metadata.
+ prop.OneofTypes = make(map[string]*OneofProperties)
+ for _, oot := range oots {
+ oop := &OneofProperties{
+ Type: reflect.ValueOf(oot).Type(), // *T
+ Prop: new(Properties),
+ }
+ sft := oop.Type.Elem().Field(0)
+ oop.Prop.Name = sft.Name
+ oop.Prop.Parse(sft.Tag.Get("protobuf"))
+ // There will be exactly one interface field that
+ // this new value is assignable to.
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ if f.Type.Kind() != reflect.Interface {
+ continue
+ }
+ if !oop.Type.AssignableTo(f.Type) {
+ continue
+ }
+ oop.Field = i
+ break
+ }
+ prop.OneofTypes[oop.Prop.OrigName] = oop
+ }
+ }
+
+ // build required counts
+ // build tags
+ reqCount := 0
+ prop.decoderOrigNames = make(map[string]int)
+ for i, p := range prop.Prop {
+ if strings.HasPrefix(p.Name, "XXX_") {
+ // Internal fields should not appear in tags/origNames maps.
+ // They are handled specially when encoding and decoding.
+ continue
+ }
+ if p.Required {
+ reqCount++
+ }
+ prop.decoderTags.put(p.Tag, i)
+ prop.decoderOrigNames[p.OrigName] = i
+ }
+ prop.reqCount = reqCount
+
+ return prop
+}
+
+// Return the Properties object for the x[0]'th field of the structure.
+func propByIndex(t reflect.Type, x []int) *Properties {
+ if len(x) != 1 {
+ fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t)
+ return nil
+ }
+ prop := GetProperties(t)
+ return prop.Prop[x[0]]
+}
+
+// Get the address and type of a pointer to a struct from an interface.
+func getbase(pb Message) (t reflect.Type, b structPointer, err error) {
+ if pb == nil {
+ err = ErrNil
+ return
+ }
+ // get the reflect type of the pointer to the struct.
+ t = reflect.TypeOf(pb)
+ // get the address of the struct.
+ value := reflect.ValueOf(pb)
+ b = toStructPointer(value)
+ return
+}
+
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+var enumStringMaps = make(map[string]map[int32]string)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+ if _, ok := enumValueMaps[typeName]; ok {
+ panic("proto: duplicate enum registered: " + typeName)
+ }
+ enumValueMaps[typeName] = valueMap
+ if _, ok := enumStringMaps[typeName]; ok {
+ panic("proto: duplicate enum registered: " + typeName)
+ }
+ enumStringMaps[typeName] = unusedNameMap
+}
+
+// EnumValueMap returns the mapping from names to integers of the
+// enum type enumType, or a nil if not found.
+func EnumValueMap(enumType string) map[string]int32 {
+ return enumValueMaps[enumType]
+}
+
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+ protoTypes = make(map[string]reflect.Type)
+ revProtoTypes = make(map[reflect.Type]string)
+)
+
+// RegisterType is called from generated code and maps from the fully qualified
+// proto name to the type (pointer to struct) of the protocol buffer.
+func RegisterType(x Message, name string) {
+ if _, ok := protoTypes[name]; ok {
+ // TODO: Some day, make this a panic.
+ log.Printf("proto: duplicate proto type registered: %s", name)
+ return
+ }
+ t := reflect.TypeOf(x)
+ protoTypes[name] = t
+ revProtoTypes[t] = name
+}
+
+// MessageName returns the fully-qualified proto name for the given message type.
+func MessageName(x Message) string { return revProtoTypes[reflect.TypeOf(x)] }
+
+// MessageType returns the message type (pointer to struct) for a named message.
+func MessageType(name string) reflect.Type { return protoTypes[name] }
+
+// A registry of all linked proto files.
+var (
+ protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+ protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/gogo/protobuf/proto/properties_gogo.go b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..4607a975410aff1d73af9e18d6dc2f4ce222f668
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
@@ -0,0 +1,66 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "fmt"
+ "os"
+ "reflect"
+)
+
+func (p *Properties) setCustomEncAndDec(typ reflect.Type) {
+ p.ctype = typ
+ if p.Repeated {
+ p.enc = (*Buffer).enc_custom_slice_bytes
+ p.dec = (*Buffer).dec_custom_slice_bytes
+ p.size = size_custom_slice_bytes
+ } else if typ.Kind() == reflect.Ptr {
+ p.enc = (*Buffer).enc_custom_bytes
+ p.dec = (*Buffer).dec_custom_bytes
+ p.size = size_custom_bytes
+ } else {
+ p.enc = (*Buffer).enc_custom_ref_bytes
+ p.dec = (*Buffer).dec_custom_ref_bytes
+ p.size = size_custom_ref_bytes
+ }
+}
+
+func (p *Properties) setSliceOfNonPointerStructs(typ reflect.Type) {
+ t2 := typ.Elem()
+ p.sstype = typ
+ p.stype = t2
+ p.isMarshaler = isMarshaler(t2)
+ p.isUnmarshaler = isUnmarshaler(t2)
+ p.enc = (*Buffer).enc_slice_ref_struct_message
+ p.dec = (*Buffer).dec_slice_ref_struct_message
+ p.size = size_slice_ref_struct_message
+ if p.Wire != "bytes" {
+ fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T \n", typ, t2)
+ }
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/skip_gogo.go b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a5fd93f7c196e36fa537ad56fe5843c37194591
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
@@ -0,0 +1,119 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "fmt"
+ "io"
+)
+
+func Skip(data []byte) (n int, err error) {
+ l := len(data)
+ index := 0
+ for index < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if index >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[index]
+ index++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for {
+ if index >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ index++
+ if data[index-1] < 0x80 {
+ break
+ }
+ }
+ return index, nil
+ case 1:
+ index += 8
+ return index, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if index >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[index]
+ index++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ index += length
+ return index, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = index
+ for shift := uint(0); ; shift += 7 {
+ if index >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[index]
+ index++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := Skip(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ index = start + next
+ }
+ return index, nil
+ case 4:
+ return index, nil
+ case 5:
+ index += 4
+ return index, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go
similarity index 85%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/text.go
rename to vendor/github.com/gogo/protobuf/proto/text.go
index 2336b144c12f481d179e937bcd4e160f058cb656..b3e12e268445025c7e47f1780d8a421c12fb1052 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/text.go
+++ b/vendor/github.com/gogo/protobuf/proto/text.go
@@ -1,3 +1,8 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
@@ -45,6 +50,7 @@ import (
"reflect"
"sort"
"strings"
+ "sync"
)
var (
@@ -154,7 +160,7 @@ func (w *textWriter) indent() { w.ind++ }
func (w *textWriter) unindent() {
if w.ind == 0 {
- log.Printf("proto: textWriter unindented too far")
+ log.Print("proto: textWriter unindented too far")
return
}
w.ind--
@@ -227,7 +233,11 @@ func writeStruct(w *textWriter, sv reflect.Value) error {
}
continue
}
- if err := writeAny(w, v, props); err != nil {
+ if len(props.Enum) > 0 {
+ if err := writeEnum(w, v, props); err != nil {
+ return err
+ }
+ } else if err := writeAny(w, v, props); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
@@ -308,7 +318,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {
// empty bytes field
continue
}
- if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+ if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
// proto3 non-repeated scalar field; skip if zero value
if isProto3Zero(fv) {
continue
@@ -357,8 +367,11 @@ func writeStruct(w *textWriter, sv reflect.Value) error {
continue
}
- // Enums have a String method, so writeAny will work fine.
- if err := writeAny(w, fv, props); err != nil {
+ if len(props.Enum) > 0 {
+ if err := writeEnum(w, fv, props); err != nil {
+ return err
+ }
+ } else if err := writeAny(w, fv, props); err != nil {
return err
}
@@ -368,8 +381,14 @@ func writeStruct(w *textWriter, sv reflect.Value) error {
}
// Extensions (the XXX_extensions field).
- pv := sv.Addr()
- if pv.Type().Implements(extendableProtoType) {
+ pv := sv
+ if pv.CanAddr() {
+ pv = sv.Addr()
+ } else {
+ pv = reflect.New(sv.Type())
+ pv.Elem().Set(sv)
+ }
+ if pv.Type().Implements(extensionRangeType) {
if err := writeExtensions(w, pv); err != nil {
return err
}
@@ -403,6 +422,20 @@ func writeRaw(w *textWriter, b []byte) error {
func writeAny(w *textWriter, v reflect.Value, props *Properties) error {
v = reflect.Indirect(v)
+ if props != nil && len(props.CustomType) > 0 {
+ custom, ok := v.Interface().(Marshaler)
+ if ok {
+ data, err := custom.Marshal()
+ if err != nil {
+ return err
+ }
+ if err := writeString(w, string(data)); err != nil {
+ return err
+ }
+ return nil
+ }
+ }
+
// Floats have special cases.
if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
x := v.Float()
@@ -427,7 +460,7 @@ func writeAny(w *textWriter, v reflect.Value, props *Properties) error {
switch v.Kind() {
case reflect.Slice:
// Should only be a []byte; repeated fields are handled in writeStruct.
- if err := writeString(w, string(v.Interface().([]byte))); err != nil {
+ if err := writeString(w, string(v.Bytes())); err != nil {
return err
}
case reflect.String:
@@ -527,27 +560,27 @@ func writeUnknownStruct(w *textWriter, data []byte) (err error) {
for b.index < len(b.buf) {
x, err := b.DecodeVarint()
if err != nil {
- _, err := fmt.Fprintf(w, "/* %v */\n", err)
- return err
+ _, ferr := fmt.Fprintf(w, "/* %v */\n", err)
+ return ferr
}
wire, tag := x&7, x>>3
if wire == WireEndGroup {
w.unindent()
- if _, err := w.Write(endBraceNewline); err != nil {
- return err
+ if _, werr := w.Write(endBraceNewline); werr != nil {
+ return werr
}
continue
}
- if _, err := fmt.Fprint(w, tag); err != nil {
- return err
+ if _, ferr := fmt.Fprint(w, tag); ferr != nil {
+ return ferr
}
if wire != WireStartGroup {
- if err := w.WriteByte(':'); err != nil {
+ if err = w.WriteByte(':'); err != nil {
return err
}
}
if !w.compact || wire == WireStartGroup {
- if err := w.WriteByte(' '); err != nil {
+ if err = w.WriteByte(' '); err != nil {
return err
}
}
@@ -577,7 +610,7 @@ func writeUnknownStruct(w *textWriter, data []byte) (err error) {
if err != nil {
return err
}
- if err = w.WriteByte('\n'); err != nil {
+ if err := w.WriteByte('\n'); err != nil {
return err
}
}
@@ -603,17 +636,37 @@ func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// pv is assumed to be a pointer to a protocol message struct that is extendable.
func writeExtensions(w *textWriter, pv reflect.Value) error {
emap := extensionMaps[pv.Type().Elem()]
- ep := pv.Interface().(extendableProto)
+ e := pv.Interface().(Message)
+
+ var m map[int32]Extension
+ var mu sync.Locker
+ if em, ok := e.(extensionsBytes); ok {
+ eb := em.GetExtensions()
+ var err error
+ m, err = BytesToExtensionsMap(*eb)
+ if err != nil {
+ return err
+ }
+ mu = notLocker{}
+ } else if _, ok := e.(extendableProto); ok {
+ ep, _ := extendable(e)
+ m, mu = ep.extensionsRead()
+ if m == nil {
+ return nil
+ }
+ }
// Order the extensions by ID.
// This isn't strictly necessary, but it will give us
// canonical output, which will also make testing easier.
- m := ep.ExtensionMap()
+
+ mu.Lock()
ids := make([]int32, 0, len(m))
for id := range m {
ids = append(ids, id)
}
sort.Sort(int32Slice(ids))
+ mu.Unlock()
for _, extNum := range ids {
ext := m[extNum]
@@ -629,7 +682,7 @@ func writeExtensions(w *textWriter, pv reflect.Value) error {
continue
}
- pb, err := GetExtension(ep, desc)
+ pb, err := GetExtension(e, desc)
if err != nil {
return fmt.Errorf("failed getting extension: %v", err)
}
@@ -685,7 +738,14 @@ func (w *textWriter) writeIndent() {
w.complete = false
}
-func marshalText(w io.Writer, pb Message, compact bool) error {
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+ Compact bool // use compact text format (one line).
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (m *TextMarshaler) Marshal(w io.Writer, pb Message) error {
val := reflect.ValueOf(pb)
if pb == nil || val.IsNil() {
w.Write([]byte("<nil>"))
@@ -700,7 +760,7 @@ func marshalText(w io.Writer, pb Message, compact bool) error {
aw := &textWriter{
w: ww,
complete: true,
- compact: compact,
+ compact: m.Compact,
}
if tm, ok := pb.(encoding.TextMarshaler); ok {
@@ -727,25 +787,29 @@ func marshalText(w io.Writer, pb Message, compact bool) error {
return nil
}
+// Text is the same as Marshal, but returns the string directly.
+func (m *TextMarshaler) Text(pb Message) string {
+ var buf bytes.Buffer
+ m.Marshal(&buf, pb)
+ return buf.String()
+}
+
+var (
+ defaultTextMarshaler = TextMarshaler{}
+ compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
// MarshalText writes a given protocol buffer in text format.
// The only errors returned are from w.
-func MarshalText(w io.Writer, pb Message) error {
- return marshalText(w, pb, false)
-}
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
// MarshalTextString is the same as MarshalText, but returns the string directly.
-func MarshalTextString(pb Message) string {
- var buf bytes.Buffer
- marshalText(&buf, pb, false)
- return buf.String()
-}
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
// CompactText writes a given protocol buffer in compact text format (one line).
-func CompactText(w io.Writer, pb Message) error { return marshalText(w, pb, true) }
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
// CompactTextString is the same as CompactText, but returns the string directly.
-func CompactTextString(pb Message) string {
- var buf bytes.Buffer
- marshalText(&buf, pb, true)
- return buf.String()
-}
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/gogo/protobuf/proto/text_gogo.go b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
new file mode 100644
index 0000000000000000000000000000000000000000..5892674197fc07718ff2a4421968d7b9d7eaef71
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
@@ -0,0 +1,57 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+ "fmt"
+ "reflect"
+)
+
+func writeEnum(w *textWriter, v reflect.Value, props *Properties) error {
+ m, ok := enumStringMaps[props.Enum]
+ if !ok {
+ if err := writeAny(w, v, props); err != nil {
+ return err
+ }
+ }
+ key := int32(0)
+ if v.Kind() == reflect.Ptr {
+ key = int32(v.Elem().Int())
+ } else {
+ key = int32(v.Int())
+ }
+ s, ok := m[key]
+ if !ok {
+ if err := writeAny(w, v, props); err != nil {
+ return err
+ }
+ }
+ _, err := fmt.Fprint(w, s)
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go
similarity index 87%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/text_parser.go
rename to vendor/github.com/gogo/protobuf/proto/text_parser.go
index 6d0cf258947cd20f75a6feef8c02a76111a5d452..bcd732c3c489c3ab73051a09b9294c3d175f5dd3 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/text_parser.go
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go
@@ -1,3 +1,8 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
@@ -119,6 +124,14 @@ func isWhitespace(c byte) bool {
return false
}
+func isQuote(c byte) bool {
+ switch c {
+ case '"', '\'':
+ return true
+ }
+ return false
+}
+
func (p *textParser) skipWhitespace() {
i := 0
for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
@@ -333,13 +346,13 @@ func (p *textParser) next() *token {
p.advance()
if p.done {
p.cur.value = ""
- } else if len(p.cur.value) > 0 && p.cur.value[0] == '"' {
+ } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
// Look for multiple quoted strings separated by whitespace,
// and concatenate them.
cat := p.cur
for {
p.skipWhitespace()
- if p.done || p.s[0] != '"' {
+ if p.done || !isQuote(p.s[0]) {
break
}
p.advance()
@@ -506,7 +519,7 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
}
reqFieldErr = err
}
- ep := sv.Addr().Interface().(extendableProto)
+ ep := sv.Addr().Interface().(Message)
if !rep {
SetExtension(ep, desc, ext.Interface())
} else {
@@ -558,8 +571,9 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
// The map entry should be this sequence of tokens:
// < key : KEY value : VALUE >
- // Technically the "key" and "value" could come in any order,
- // but in practice they won't.
+ // However, implementations may omit key or value, and technically
+ // we should support them in any order. See b/28924776 for a time
+ // this went wrong.
tok := p.next()
var terminator string
@@ -571,32 +585,39 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
default:
return p.errorf("expected '{' or '<', found %q", tok.value)
}
- if err := p.consumeToken("key"); err != nil {
- return err
- }
- if err := p.consumeToken(":"); err != nil {
- return err
- }
- if err := p.readAny(key, props.mkeyprop); err != nil {
- return err
- }
- if err := p.consumeOptionalSeparator(); err != nil {
- return err
- }
- if err := p.consumeToken("value"); err != nil {
- return err
- }
- if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
- return err
- }
- if err := p.readAny(val, props.mvalprop); err != nil {
- return err
- }
- if err := p.consumeOptionalSeparator(); err != nil {
- return err
- }
- if err := p.consumeToken(terminator); err != nil {
- return err
+ for {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == terminator {
+ break
+ }
+ switch tok.value {
+ case "key":
+ if err := p.consumeToken(":"); err != nil {
+ return err
+ }
+ if err := p.readAny(key, props.mkeyprop); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ case "value":
+ if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
+ return err
+ }
+ if err := p.readAny(val, props.mvalprop); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ default:
+ p.back()
+ return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+ }
}
dst.SetMapIndex(key, val)
@@ -619,7 +640,8 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
return err
}
reqFieldErr = err
- } else if props.Required {
+ }
+ if props.Required {
reqCount--
}
@@ -656,7 +678,45 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {
if tok.value == "" {
return p.errorf("unexpected EOF")
}
-
+ if len(props.CustomType) > 0 {
+ if props.Repeated {
+ t := reflect.TypeOf(v.Interface())
+ if t.Kind() == reflect.Slice {
+ tc := reflect.TypeOf(new(Marshaler))
+ ok := t.Elem().Implements(tc.Elem())
+ if ok {
+ fv := v
+ flen := fv.Len()
+ if flen == fv.Cap() {
+ nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1)
+ reflect.Copy(nav, fv)
+ fv.Set(nav)
+ }
+ fv.SetLen(flen + 1)
+
+ // Read one.
+ p.back()
+ return p.readAny(fv.Index(flen), props)
+ }
+ }
+ }
+ if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+ custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler)
+ err := custom.Unmarshal([]byte(tok.unquoted))
+ if err != nil {
+ return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+ }
+ v.Set(reflect.ValueOf(custom))
+ } else {
+ custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler)
+ err := custom.Unmarshal([]byte(tok.unquoted))
+ if err != nil {
+ return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+ }
+ v.Set(reflect.Indirect(reflect.ValueOf(custom)))
+ }
+ return nil
+ }
switch fv := v; fv.Kind() {
case reflect.Slice:
at := v.Type()
@@ -681,15 +741,15 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {
if err != nil {
return err
}
- tok := p.next()
- if tok.err != nil {
- return tok.err
+ ntok := p.next()
+ if ntok.err != nil {
+ return ntok.err
}
- if tok.value == "]" {
+ if ntok.value == "]" {
break
}
- if tok.value != "," {
- return p.errorf("Expected ']' or ',' found %q", tok.value)
+ if ntok.value != "," {
+ return p.errorf("Expected ']' or ',' found %q", ntok.value)
}
}
return nil
diff --git a/Godeps/_workspace/src/github.com/golang/groupcache/LICENSE b/vendor/github.com/golang/glog/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/groupcache/LICENSE
rename to vendor/github.com/golang/glog/LICENSE
diff --git a/Godeps/_workspace/src/github.com/golang/glog/README b/vendor/github.com/golang/glog/README
similarity index 97%
rename from Godeps/_workspace/src/github.com/golang/glog/README
rename to vendor/github.com/golang/glog/README
index 5f9c11485e037e27a8f96a5cb5fcc131afc8254f..387b4eb68909bf950a1c9d334ea8710d06c1854a 100644
--- a/Godeps/_workspace/src/github.com/golang/glog/README
+++ b/vendor/github.com/golang/glog/README
@@ -5,7 +5,7 @@ Leveled execution logs for Go.
This is an efficient pure Go implementation of leveled logs in the
manner of the open source C++ package
- http://code.google.com/p/google-glog
+ https://github.com/google/glog
By binding methods to booleans it is possible to use the log package
without paying the expense of evaluating the arguments to the log.
diff --git a/Godeps/_workspace/src/github.com/golang/glog/glog.go b/vendor/github.com/golang/glog/glog.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/golang/glog/glog.go
rename to vendor/github.com/golang/glog/glog.go
index 3e63fffd5ecb1b313b0d2283d19bf10b8b59a29b..54bd7afdcabec4769e849f2c067b53e24a139fd8 100644
--- a/Godeps/_workspace/src/github.com/golang/glog/glog.go
+++ b/vendor/github.com/golang/glog/glog.go
@@ -676,7 +676,10 @@ func (l *loggingT) output(s severity, buf *buffer, file string, line int, alsoTo
}
}
data := buf.Bytes()
- if l.toStderr {
+ if !flag.Parsed() {
+ os.Stderr.Write([]byte("ERROR: logging before flag.Parse: "))
+ os.Stderr.Write(data)
+ } else if l.toStderr {
os.Stderr.Write(data)
} else {
if alsoToStderr || l.alsoToStderr || s >= l.stderrThreshold.get() {
diff --git a/Godeps/_workspace/src/github.com/golang/glog/glog_file.go b/vendor/github.com/golang/glog/glog_file.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/glog/glog_file.go
rename to vendor/github.com/golang/glog/glog_file.go
diff --git a/vendor/github.com/golang/groupcache/LICENSE b/vendor/github.com/golang/groupcache/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..37ec93a14fdcd0d6e525d97c0cfa6b314eaa98d8
--- /dev/null
+++ b/vendor/github.com/golang/groupcache/LICENSE
@@ -0,0 +1,191 @@
+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:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+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
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/Godeps/_workspace/src/github.com/golang/groupcache/lru/lru.go b/vendor/github.com/golang/groupcache/lru/lru.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/groupcache/lru/lru.go
rename to vendor/github.com/golang/groupcache/lru/lru.go
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/LICENSE b/vendor/github.com/golang/protobuf/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/protobuf/LICENSE
rename to vendor/github.com/golang/protobuf/LICENSE
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/Makefile b/vendor/github.com/golang/protobuf/proto/Makefile
similarity index 94%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/Makefile
rename to vendor/github.com/golang/protobuf/proto/Makefile
index f1f06564a157df383f40ce6c068fdf4550bf882b..e2e0651a934d3ab8fe6393dfd2556bbc4bd0792e 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/Makefile
+++ b/vendor/github.com/golang/protobuf/proto/Makefile
@@ -39,5 +39,5 @@ test: install generate-test-pbs
generate-test-pbs:
make install
make -C testdata
- protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata:. proto3_proto/proto3.proto
+ protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto
make
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/clone.go
rename to vendor/github.com/golang/protobuf/proto/clone.go
index e98ddec9815b6da6a1483127656d5018656afccd..e392575b353afa4f22f513d3f22ff64a8f5fdbf1 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/clone.go
+++ b/vendor/github.com/golang/protobuf/proto/clone.go
@@ -84,9 +84,15 @@ func mergeStruct(out, in reflect.Value) {
mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
}
- if emIn, ok := in.Addr().Interface().(extendableProto); ok {
- emOut := out.Addr().Interface().(extendableProto)
- mergeExtension(emOut.ExtensionMap(), emIn.ExtensionMap())
+ if emIn, ok := extendable(in.Addr().Interface()); ok {
+ emOut, _ := extendable(out.Addr().Interface())
+ mIn, muIn := emIn.extensionsRead()
+ if mIn != nil {
+ mOut := emOut.extensionsWrite()
+ muIn.Lock()
+ mergeExtension(mOut, mIn)
+ muIn.Unlock()
+ }
}
uf := in.FieldByName("XXX_unrecognized")
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/decode.go
rename to vendor/github.com/golang/protobuf/proto/decode.go
index 5810782fd84d55364203111ac09baad7978e0884..04dcb881305e23c0d6fbbf1aae481c152f57cb0f 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/decode.go
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -378,6 +378,11 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group
wire := int(u & 0x7)
if wire == WireEndGroup {
if is_group {
+ if required > 0 {
+ // Not enough information to determine the exact field.
+ // (See below.)
+ return &RequiredNotSetError{"{Unknown}"}
+ }
return nil // input is satisfied
}
return fmt.Errorf("proto: %s: wiretype end group for non-group", st)
@@ -390,11 +395,12 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group
if !ok {
// Maybe it's an extension?
if prop.extendable {
- if e := structPointer_Interface(base, st).(extendableProto); isExtensionField(e, int32(tag)) {
+ if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {
if err = o.skip(st, tag, wire); err == nil {
- ext := e.ExtensionMap()[int32(tag)] // may be missing
+ extmap := e.extensionsWrite()
+ ext := extmap[int32(tag)] // may be missing
ext.enc = append(ext.enc, o.buf[oi:o.index]...)
- e.ExtensionMap()[int32(tag)] = ext
+ extmap[int32(tag)] = ext
}
continue
}
@@ -768,10 +774,11 @@ func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {
}
}
keyelem, valelem := keyptr.Elem(), valptr.Elem()
- if !keyelem.IsValid() || !valelem.IsValid() {
- // We did not decode the key or the value in the map entry.
- // Either way, it's an invalid map entry.
- return fmt.Errorf("proto: bad map data: missing key/val")
+ if !keyelem.IsValid() {
+ keyelem = reflect.Zero(p.mtype.Key())
+ }
+ if !valelem.IsValid() {
+ valelem = reflect.Zero(p.mtype.Elem())
}
v.SetMapIndex(keyelem, valelem)
diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c1b8fd1f6831579d821a8bce8d657d597f55fb0
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/encode.go
@@ -0,0 +1,1363 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "sort"
+)
+
+// RequiredNotSetError is the error returned if Marshal is called with
+// a protocol buffer struct whose required fields have not
+// all been initialized. It is also the error returned if Unmarshal is
+// called with an encoded protocol buffer that does not include all the
+// required fields.
+//
+// When printed, RequiredNotSetError reports the first unset required field in a
+// message. If the field cannot be precisely determined, it is reported as
+// "{Unknown}".
+type RequiredNotSetError struct {
+ field string
+}
+
+func (e *RequiredNotSetError) Error() string {
+ return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+
+var (
+ // errRepeatedHasNil is the error returned if Marshal is called with
+ // a struct with a repeated field containing a nil element.
+ errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+ // errOneofHasNil is the error returned if Marshal is called with
+ // a struct with a oneof field containing a nil element.
+ errOneofHasNil = errors.New("proto: oneof field has nil value")
+
+ // ErrNil is the error returned if Marshal is called with nil.
+ ErrNil = errors.New("proto: Marshal called with nil")
+
+ // ErrTooLarge is the error returned if Marshal is called with a
+ // message that encodes to >2GB.
+ ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// maxMarshalSize is the largest allowed size of an encoded protobuf,
+// since C++ and Java use signed int32s for the size.
+const maxMarshalSize = 1<<31 - 1
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+ var buf [maxVarintBytes]byte
+ var n int
+ for n = 0; x > 127; n++ {
+ buf[n] = 0x80 | uint8(x&0x7F)
+ x >>= 7
+ }
+ buf[n] = uint8(x)
+ n++
+ return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+ for x >= 1<<7 {
+ p.buf = append(p.buf, uint8(x&0x7f|0x80))
+ x >>= 7
+ }
+ p.buf = append(p.buf, uint8(x))
+ return nil
+}
+
+// SizeVarint returns the varint encoding size of an integer.
+func SizeVarint(x uint64) int {
+ return sizeVarint(x)
+}
+
+func sizeVarint(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+ p.buf = append(p.buf,
+ uint8(x),
+ uint8(x>>8),
+ uint8(x>>16),
+ uint8(x>>24),
+ uint8(x>>32),
+ uint8(x>>40),
+ uint8(x>>48),
+ uint8(x>>56))
+ return nil
+}
+
+func sizeFixed64(x uint64) int {
+ return 8
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+ p.buf = append(p.buf,
+ uint8(x),
+ uint8(x>>8),
+ uint8(x>>16),
+ uint8(x>>24))
+ return nil
+}
+
+func sizeFixed32(x uint64) int {
+ return 4
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+ // use signed number to get arithmetic right shift.
+ return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+func sizeZigzag64(x uint64) int {
+ return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+ // use signed number to get arithmetic right shift.
+ return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+func sizeZigzag32(x uint64) int {
+ return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+ p.EncodeVarint(uint64(len(b)))
+ p.buf = append(p.buf, b...)
+ return nil
+}
+
+func sizeRawBytes(b []byte) int {
+ return sizeVarint(uint64(len(b))) +
+ len(b)
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+ p.EncodeVarint(uint64(len(s)))
+ p.buf = append(p.buf, s...)
+ return nil
+}
+
+func sizeStringBytes(s string) int {
+ return sizeVarint(uint64(len(s))) +
+ len(s)
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+ Marshal() ([]byte, error)
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, returning the data.
+func Marshal(pb Message) ([]byte, error) {
+ // Can the object marshal itself?
+ if m, ok := pb.(Marshaler); ok {
+ return m.Marshal()
+ }
+ p := NewBuffer(nil)
+ err := p.Marshal(pb)
+ var state errorState
+ if err != nil && !state.shouldContinue(err, nil) {
+ return nil, err
+ }
+ if p.buf == nil && err == nil {
+ // Return a non-nil slice on success.
+ return []byte{}, nil
+ }
+ return p.buf, err
+}
+
+// EncodeMessage writes the protocol buffer to the Buffer,
+// prefixed by a varint-encoded length.
+func (p *Buffer) EncodeMessage(pb Message) error {
+ t, base, err := getbase(pb)
+ if structPointer_IsNil(base) {
+ return ErrNil
+ }
+ if err == nil {
+ var state errorState
+ err = p.enc_len_struct(GetProperties(t.Elem()), base, &state)
+ }
+ return err
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+func (p *Buffer) Marshal(pb Message) error {
+ // Can the object marshal itself?
+ if m, ok := pb.(Marshaler); ok {
+ data, err := m.Marshal()
+ if err != nil {
+ return err
+ }
+ p.buf = append(p.buf, data...)
+ return nil
+ }
+
+ t, base, err := getbase(pb)
+ if structPointer_IsNil(base) {
+ return ErrNil
+ }
+ if err == nil {
+ err = p.enc_struct(GetProperties(t.Elem()), base)
+ }
+
+ if collectStats {
+ stats.Encode++
+ }
+
+ if len(p.buf) > maxMarshalSize {
+ return ErrTooLarge
+ }
+ return err
+}
+
+// Size returns the encoded size of a protocol buffer.
+func Size(pb Message) (n int) {
+ // Can the object marshal itself? If so, Size is slow.
+ // TODO: add Size to Marshaler, or add a Sizer interface.
+ if m, ok := pb.(Marshaler); ok {
+ b, _ := m.Marshal()
+ return len(b)
+ }
+
+ t, base, err := getbase(pb)
+ if structPointer_IsNil(base) {
+ return 0
+ }
+ if err == nil {
+ n = size_struct(GetProperties(t.Elem()), base)
+ }
+
+ if collectStats {
+ stats.Size++
+ }
+
+ return
+}
+
+// Individual type encoders.
+
+// Encode a bool.
+func (o *Buffer) enc_bool(p *Properties, base structPointer) error {
+ v := *structPointer_Bool(base, p.field)
+ if v == nil {
+ return ErrNil
+ }
+ x := 0
+ if *v {
+ x = 1
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {
+ v := *structPointer_BoolVal(base, p.field)
+ if !v {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, 1)
+ return nil
+}
+
+func size_bool(p *Properties, base structPointer) int {
+ v := *structPointer_Bool(base, p.field)
+ if v == nil {
+ return 0
+ }
+ return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+func size_proto3_bool(p *Properties, base structPointer) int {
+ v := *structPointer_BoolVal(base, p.field)
+ if !v && !p.oneof {
+ return 0
+ }
+ return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode an int32.
+func (o *Buffer) enc_int32(p *Properties, base structPointer) error {
+ v := structPointer_Word32(base, p.field)
+ if word32_IsNil(v) {
+ return ErrNil
+ }
+ x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {
+ v := structPointer_Word32Val(base, p.field)
+ x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+ if x == 0 {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func size_int32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32(base, p.field)
+ if word32_IsNil(v) {
+ return 0
+ }
+ x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+func size_proto3_int32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32Val(base, p.field)
+ x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+ if x == 0 && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+// Encode a uint32.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {
+ v := structPointer_Word32(base, p.field)
+ if word32_IsNil(v) {
+ return ErrNil
+ }
+ x := word32_Get(v)
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {
+ v := structPointer_Word32Val(base, p.field)
+ x := word32Val_Get(v)
+ if x == 0 {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, uint64(x))
+ return nil
+}
+
+func size_uint32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32(base, p.field)
+ if word32_IsNil(v) {
+ return 0
+ }
+ x := word32_Get(v)
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+func size_proto3_uint32(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word32Val(base, p.field)
+ x := word32Val_Get(v)
+ if x == 0 && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += p.valSize(uint64(x))
+ return
+}
+
+// Encode an int64.
+func (o *Buffer) enc_int64(p *Properties, base structPointer) error {
+ v := structPointer_Word64(base, p.field)
+ if word64_IsNil(v) {
+ return ErrNil
+ }
+ x := word64_Get(v)
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, x)
+ return nil
+}
+
+func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {
+ v := structPointer_Word64Val(base, p.field)
+ x := word64Val_Get(v)
+ if x == 0 {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, x)
+ return nil
+}
+
+func size_int64(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word64(base, p.field)
+ if word64_IsNil(v) {
+ return 0
+ }
+ x := word64_Get(v)
+ n += len(p.tagcode)
+ n += p.valSize(x)
+ return
+}
+
+func size_proto3_int64(p *Properties, base structPointer) (n int) {
+ v := structPointer_Word64Val(base, p.field)
+ x := word64Val_Get(v)
+ if x == 0 && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += p.valSize(x)
+ return
+}
+
+// Encode a string.
+func (o *Buffer) enc_string(p *Properties, base structPointer) error {
+ v := *structPointer_String(base, p.field)
+ if v == nil {
+ return ErrNil
+ }
+ x := *v
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeStringBytes(x)
+ return nil
+}
+
+func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {
+ v := *structPointer_StringVal(base, p.field)
+ if v == "" {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeStringBytes(v)
+ return nil
+}
+
+func size_string(p *Properties, base structPointer) (n int) {
+ v := *structPointer_String(base, p.field)
+ if v == nil {
+ return 0
+ }
+ x := *v
+ n += len(p.tagcode)
+ n += sizeStringBytes(x)
+ return
+}
+
+func size_proto3_string(p *Properties, base structPointer) (n int) {
+ v := *structPointer_StringVal(base, p.field)
+ if v == "" && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += sizeStringBytes(v)
+ return
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+ return v.IsNil()
+ }
+ return false
+}
+
+// Encode a message struct.
+func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {
+ var state errorState
+ structp := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(structp) {
+ return ErrNil
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, err := m.Marshal()
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ return state.err
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+func size_struct_message(p *Properties, base structPointer) int {
+ structp := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(structp) {
+ return 0
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, _ := m.Marshal()
+ n0 := len(p.tagcode)
+ n1 := sizeRawBytes(data)
+ return n0 + n1
+ }
+
+ n0 := len(p.tagcode)
+ n1 := size_struct(p.sprop, structp)
+ n2 := sizeVarint(uint64(n1)) // size of encoded length
+ return n0 + n1 + n2
+}
+
+// Encode a group struct.
+func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {
+ var state errorState
+ b := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(b) {
+ return ErrNil
+ }
+
+ o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+ err := o.enc_struct(p.sprop, b)
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+ return state.err
+}
+
+func size_struct_group(p *Properties, base structPointer) (n int) {
+ b := structPointer_GetStructPointer(base, p.field)
+ if structPointer_IsNil(b) {
+ return 0
+ }
+
+ n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))
+ n += size_struct(p.sprop, b)
+ n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))
+ return
+}
+
+// Encode a slice of bools ([]bool).
+func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {
+ s := *structPointer_BoolSlice(base, p.field)
+ l := len(s)
+ if l == 0 {
+ return ErrNil
+ }
+ for _, x := range s {
+ o.buf = append(o.buf, p.tagcode...)
+ v := uint64(0)
+ if x {
+ v = 1
+ }
+ p.valEnc(o, v)
+ }
+ return nil
+}
+
+func size_slice_bool(p *Properties, base structPointer) int {
+ s := *structPointer_BoolSlice(base, p.field)
+ l := len(s)
+ if l == 0 {
+ return 0
+ }
+ return l * (len(p.tagcode) + 1) // each bool takes exactly one byte
+}
+
+// Encode a slice of bools ([]bool) in packed format.
+func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {
+ s := *structPointer_BoolSlice(base, p.field)
+ l := len(s)
+ if l == 0 {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeVarint(uint64(l)) // each bool takes exactly one byte
+ for _, x := range s {
+ v := uint64(0)
+ if x {
+ v = 1
+ }
+ p.valEnc(o, v)
+ }
+ return nil
+}
+
+func size_slice_packed_bool(p *Properties, base structPointer) (n int) {
+ s := *structPointer_BoolSlice(base, p.field)
+ l := len(s)
+ if l == 0 {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += sizeVarint(uint64(l))
+ n += l // each bool takes exactly one byte
+ return
+}
+
+// Encode a slice of bytes ([]byte).
+func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {
+ s := *structPointer_Bytes(base, p.field)
+ if s == nil {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(s)
+ return nil
+}
+
+func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {
+ s := *structPointer_Bytes(base, p.field)
+ if len(s) == 0 {
+ return ErrNil
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(s)
+ return nil
+}
+
+func size_slice_byte(p *Properties, base structPointer) (n int) {
+ s := *structPointer_Bytes(base, p.field)
+ if s == nil && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += sizeRawBytes(s)
+ return
+}
+
+func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {
+ s := *structPointer_Bytes(base, p.field)
+ if len(s) == 0 && !p.oneof {
+ return 0
+ }
+ n += len(p.tagcode)
+ n += sizeRawBytes(s)
+ return
+}
+
+// Encode a slice of int32s ([]int32).
+func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ for i := 0; i < l; i++ {
+ o.buf = append(o.buf, p.tagcode...)
+ x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+ p.valEnc(o, uint64(x))
+ }
+ return nil
+}
+
+func size_slice_int32(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ for i := 0; i < l; i++ {
+ n += len(p.tagcode)
+ x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+ n += p.valSize(uint64(x))
+ }
+ return
+}
+
+// Encode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ // TODO: Reuse a Buffer.
+ buf := NewBuffer(nil)
+ for i := 0; i < l; i++ {
+ x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+ p.valEnc(buf, uint64(x))
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeVarint(uint64(len(buf.buf)))
+ o.buf = append(o.buf, buf.buf...)
+ return nil
+}
+
+func size_slice_packed_int32(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ var bufSize int
+ for i := 0; i < l; i++ {
+ x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+ bufSize += p.valSize(uint64(x))
+ }
+
+ n += len(p.tagcode)
+ n += sizeVarint(uint64(bufSize))
+ n += bufSize
+ return
+}
+
+// Encode a slice of uint32s ([]uint32).
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ for i := 0; i < l; i++ {
+ o.buf = append(o.buf, p.tagcode...)
+ x := s.Index(i)
+ p.valEnc(o, uint64(x))
+ }
+ return nil
+}
+
+func size_slice_uint32(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ for i := 0; i < l; i++ {
+ n += len(p.tagcode)
+ x := s.Index(i)
+ n += p.valSize(uint64(x))
+ }
+ return
+}
+
+// Encode a slice of uint32s ([]uint32) in packed format.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ // TODO: Reuse a Buffer.
+ buf := NewBuffer(nil)
+ for i := 0; i < l; i++ {
+ p.valEnc(buf, uint64(s.Index(i)))
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeVarint(uint64(len(buf.buf)))
+ o.buf = append(o.buf, buf.buf...)
+ return nil
+}
+
+func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word32Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ var bufSize int
+ for i := 0; i < l; i++ {
+ bufSize += p.valSize(uint64(s.Index(i)))
+ }
+
+ n += len(p.tagcode)
+ n += sizeVarint(uint64(bufSize))
+ n += bufSize
+ return
+}
+
+// Encode a slice of int64s ([]int64).
+func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {
+ s := structPointer_Word64Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ for i := 0; i < l; i++ {
+ o.buf = append(o.buf, p.tagcode...)
+ p.valEnc(o, s.Index(i))
+ }
+ return nil
+}
+
+func size_slice_int64(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word64Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ for i := 0; i < l; i++ {
+ n += len(p.tagcode)
+ n += p.valSize(s.Index(i))
+ }
+ return
+}
+
+// Encode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {
+ s := structPointer_Word64Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return ErrNil
+ }
+ // TODO: Reuse a Buffer.
+ buf := NewBuffer(nil)
+ for i := 0; i < l; i++ {
+ p.valEnc(buf, s.Index(i))
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeVarint(uint64(len(buf.buf)))
+ o.buf = append(o.buf, buf.buf...)
+ return nil
+}
+
+func size_slice_packed_int64(p *Properties, base structPointer) (n int) {
+ s := structPointer_Word64Slice(base, p.field)
+ l := s.Len()
+ if l == 0 {
+ return 0
+ }
+ var bufSize int
+ for i := 0; i < l; i++ {
+ bufSize += p.valSize(s.Index(i))
+ }
+
+ n += len(p.tagcode)
+ n += sizeVarint(uint64(bufSize))
+ n += bufSize
+ return
+}
+
+// Encode a slice of slice of bytes ([][]byte).
+func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {
+ ss := *structPointer_BytesSlice(base, p.field)
+ l := len(ss)
+ if l == 0 {
+ return ErrNil
+ }
+ for i := 0; i < l; i++ {
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(ss[i])
+ }
+ return nil
+}
+
+func size_slice_slice_byte(p *Properties, base structPointer) (n int) {
+ ss := *structPointer_BytesSlice(base, p.field)
+ l := len(ss)
+ if l == 0 {
+ return 0
+ }
+ n += l * len(p.tagcode)
+ for i := 0; i < l; i++ {
+ n += sizeRawBytes(ss[i])
+ }
+ return
+}
+
+// Encode a slice of strings ([]string).
+func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {
+ ss := *structPointer_StringSlice(base, p.field)
+ l := len(ss)
+ for i := 0; i < l; i++ {
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeStringBytes(ss[i])
+ }
+ return nil
+}
+
+func size_slice_string(p *Properties, base structPointer) (n int) {
+ ss := *structPointer_StringSlice(base, p.field)
+ l := len(ss)
+ n += l * len(p.tagcode)
+ for i := 0; i < l; i++ {
+ n += sizeStringBytes(ss[i])
+ }
+ return
+}
+
+// Encode a slice of message structs ([]*struct).
+func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {
+ var state errorState
+ s := structPointer_StructPointerSlice(base, p.field)
+ l := s.Len()
+
+ for i := 0; i < l; i++ {
+ structp := s.Index(i)
+ if structPointer_IsNil(structp) {
+ return errRepeatedHasNil
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, err := m.Marshal()
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ o.buf = append(o.buf, p.tagcode...)
+ o.EncodeRawBytes(data)
+ continue
+ }
+
+ o.buf = append(o.buf, p.tagcode...)
+ err := o.enc_len_struct(p.sprop, structp, &state)
+ if err != nil && !state.shouldContinue(err, nil) {
+ if err == ErrNil {
+ return errRepeatedHasNil
+ }
+ return err
+ }
+ }
+ return state.err
+}
+
+func size_slice_struct_message(p *Properties, base structPointer) (n int) {
+ s := structPointer_StructPointerSlice(base, p.field)
+ l := s.Len()
+ n += l * len(p.tagcode)
+ for i := 0; i < l; i++ {
+ structp := s.Index(i)
+ if structPointer_IsNil(structp) {
+ return // return the size up to this point
+ }
+
+ // Can the object marshal itself?
+ if p.isMarshaler {
+ m := structPointer_Interface(structp, p.stype).(Marshaler)
+ data, _ := m.Marshal()
+ n += len(p.tagcode)
+ n += sizeRawBytes(data)
+ continue
+ }
+
+ n0 := size_struct(p.sprop, structp)
+ n1 := sizeVarint(uint64(n0)) // size of encoded length
+ n += n0 + n1
+ }
+ return
+}
+
+// Encode a slice of group structs ([]*struct).
+func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {
+ var state errorState
+ s := structPointer_StructPointerSlice(base, p.field)
+ l := s.Len()
+
+ for i := 0; i < l; i++ {
+ b := s.Index(i)
+ if structPointer_IsNil(b) {
+ return errRepeatedHasNil
+ }
+
+ o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+
+ err := o.enc_struct(p.sprop, b)
+
+ if err != nil && !state.shouldContinue(err, nil) {
+ if err == ErrNil {
+ return errRepeatedHasNil
+ }
+ return err
+ }
+
+ o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+ }
+ return state.err
+}
+
+func size_slice_struct_group(p *Properties, base structPointer) (n int) {
+ s := structPointer_StructPointerSlice(base, p.field)
+ l := s.Len()
+
+ n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))
+ n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))
+ for i := 0; i < l; i++ {
+ b := s.Index(i)
+ if structPointer_IsNil(b) {
+ return // return size up to this point
+ }
+
+ n += size_struct(p.sprop, b)
+ }
+ return
+}
+
+// Encode an extension map.
+func (o *Buffer) enc_map(p *Properties, base structPointer) error {
+ exts := structPointer_ExtMap(base, p.field)
+ if err := encodeExtensionsMap(*exts); err != nil {
+ return err
+ }
+
+ return o.enc_map_body(*exts)
+}
+
+func (o *Buffer) enc_exts(p *Properties, base structPointer) error {
+ exts := structPointer_Extensions(base, p.field)
+ if err := encodeExtensions(exts); err != nil {
+ return err
+ }
+ v, _ := exts.extensionsRead()
+
+ return o.enc_map_body(v)
+}
+
+func (o *Buffer) enc_map_body(v map[int32]Extension) error {
+ // Fast-path for common cases: zero or one extensions.
+ if len(v) <= 1 {
+ for _, e := range v {
+ o.buf = append(o.buf, e.enc...)
+ }
+ return nil
+ }
+
+ // Sort keys to provide a deterministic encoding.
+ keys := make([]int, 0, len(v))
+ for k := range v {
+ keys = append(keys, int(k))
+ }
+ sort.Ints(keys)
+
+ for _, k := range keys {
+ o.buf = append(o.buf, v[int32(k)].enc...)
+ }
+ return nil
+}
+
+func size_map(p *Properties, base structPointer) int {
+ v := structPointer_ExtMap(base, p.field)
+ return extensionsMapSize(*v)
+}
+
+func size_exts(p *Properties, base structPointer) int {
+ v := structPointer_Extensions(base, p.field)
+ return extensionsSize(v)
+}
+
+// Encode a map field.
+func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
+ var state errorState // XXX: or do we need to plumb this through?
+
+ /*
+ A map defined as
+ map<key_type, value_type> map_field = N;
+ is encoded in the same way as
+ message MapFieldEntry {
+ key_type key = 1;
+ value_type value = 2;
+ }
+ repeated MapFieldEntry map_field = N;
+ */
+
+ v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
+ if v.Len() == 0 {
+ return nil
+ }
+
+ keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+ enc := func() error {
+ if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
+ return err
+ }
+ if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {
+ return err
+ }
+ return nil
+ }
+
+ // Don't sort map keys. It is not required by the spec, and C++ doesn't do it.
+ for _, key := range v.MapKeys() {
+ val := v.MapIndex(key)
+
+ keycopy.Set(key)
+ valcopy.Set(val)
+
+ o.buf = append(o.buf, p.tagcode...)
+ if err := o.enc_len_thing(enc, &state); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func size_new_map(p *Properties, base structPointer) int {
+ v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
+
+ keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+ n := 0
+ for _, key := range v.MapKeys() {
+ val := v.MapIndex(key)
+ keycopy.Set(key)
+ valcopy.Set(val)
+
+ // Tag codes for key and val are the responsibility of the sub-sizer.
+ keysize := p.mkeyprop.size(p.mkeyprop, keybase)
+ valsize := p.mvalprop.size(p.mvalprop, valbase)
+ entry := keysize + valsize
+ // Add on tag code and length of map entry itself.
+ n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry
+ }
+ return n
+}
+
+// mapEncodeScratch returns a new reflect.Value matching the map's value type,
+// and a structPointer suitable for passing to an encoder or sizer.
+func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
+ // Prepare addressable doubly-indirect placeholders for the key and value types.
+ // This is needed because the element-type encoders expect **T, but the map iteration produces T.
+
+ keycopy = reflect.New(mapType.Key()).Elem() // addressable K
+ keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
+ keyptr.Set(keycopy.Addr()) //
+ keybase = toStructPointer(keyptr.Addr()) // **K
+
+ // Value types are more varied and require special handling.
+ switch mapType.Elem().Kind() {
+ case reflect.Slice:
+ // []byte
+ var dummy []byte
+ valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
+ valbase = toStructPointer(valcopy.Addr())
+ case reflect.Ptr:
+ // message; the generated field type is map[K]*Msg (so V is *Msg),
+ // so we only need one level of indirection.
+ valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
+ valbase = toStructPointer(valcopy.Addr())
+ default:
+ // everything else
+ valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
+ valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
+ valptr.Set(valcopy.Addr()) //
+ valbase = toStructPointer(valptr.Addr()) // **V
+ }
+ return
+}
+
+// Encode a struct.
+func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
+ var state errorState
+ // Encode fields in tag order so that decoders may use optimizations
+ // that depend on the ordering.
+ // https://developers.google.com/protocol-buffers/docs/encoding#order
+ for _, i := range prop.order {
+ p := prop.Prop[i]
+ if p.enc != nil {
+ err := p.enc(o, p, base)
+ if err != nil {
+ if err == ErrNil {
+ if p.Required && state.err == nil {
+ state.err = &RequiredNotSetError{p.Name}
+ }
+ } else if err == errRepeatedHasNil {
+ // Give more context to nil values in repeated fields.
+ return errors.New("repeated field " + p.OrigName + " has nil element")
+ } else if !state.shouldContinue(err, p) {
+ return err
+ }
+ }
+ if len(o.buf) > maxMarshalSize {
+ return ErrTooLarge
+ }
+ }
+ }
+
+ // Do oneof fields.
+ if prop.oneofMarshaler != nil {
+ m := structPointer_Interface(base, prop.stype).(Message)
+ if err := prop.oneofMarshaler(m, o); err == ErrNil {
+ return errOneofHasNil
+ } else if err != nil {
+ return err
+ }
+ }
+
+ // Add unrecognized fields at the end.
+ if prop.unrecField.IsValid() {
+ v := *structPointer_Bytes(base, prop.unrecField)
+ if len(o.buf)+len(v) > maxMarshalSize {
+ return ErrTooLarge
+ }
+ if len(v) > 0 {
+ o.buf = append(o.buf, v...)
+ }
+ }
+
+ return state.err
+}
+
+func size_struct(prop *StructProperties, base structPointer) (n int) {
+ for _, i := range prop.order {
+ p := prop.Prop[i]
+ if p.size != nil {
+ n += p.size(p, base)
+ }
+ }
+
+ // Add unrecognized fields at the end.
+ if prop.unrecField.IsValid() {
+ v := *structPointer_Bytes(base, prop.unrecField)
+ n += len(v)
+ }
+
+ // Factor in any oneof fields.
+ if prop.oneofSizer != nil {
+ m := structPointer_Interface(base, prop.stype).(Message)
+ n += prop.oneofSizer(m)
+ }
+
+ return
+}
+
+var zeroes [20]byte // longer than any conceivable sizeVarint
+
+// Encode a struct, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {
+ return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)
+}
+
+// Encode something, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {
+ iLen := len(o.buf)
+ o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length
+ iMsg := len(o.buf)
+ err := enc()
+ if err != nil && !state.shouldContinue(err, nil) {
+ return err
+ }
+ lMsg := len(o.buf) - iMsg
+ lLen := sizeVarint(uint64(lMsg))
+ switch x := lLen - (iMsg - iLen); {
+ case x > 0: // actual length is x bytes larger than the space we reserved
+ // Move msg x bytes right.
+ o.buf = append(o.buf, zeroes[:x]...)
+ copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+ case x < 0: // actual length is x bytes smaller than the space we reserved
+ // Move msg x bytes left.
+ copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+ o.buf = o.buf[:len(o.buf)+x] // x is negative
+ }
+ // Encode the length in the reserved space.
+ o.buf = o.buf[:iLen]
+ o.EncodeVarint(uint64(lMsg))
+ o.buf = o.buf[:len(o.buf)+lMsg]
+ return state.err
+}
+
+// errorState maintains the first error that occurs and updates that error
+// with additional context.
+type errorState struct {
+ err error
+}
+
+// shouldContinue reports whether encoding should continue upon encountering the
+// given error. If the error is RequiredNotSetError, shouldContinue returns true
+// and, if this is the first appearance of that error, remembers it for future
+// reporting.
+//
+// If prop is not nil, it may update any error with additional context about the
+// field with the error.
+func (s *errorState) shouldContinue(err error, prop *Properties) bool {
+ // Ignore unset required fields.
+ reqNotSet, ok := err.(*RequiredNotSetError)
+ if !ok {
+ return false
+ }
+ if s.err == nil {
+ if prop != nil {
+ err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}
+ }
+ s.err = err
+ }
+ return true
+}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b16f951c712703a03a14591510818da15557b01
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -0,0 +1,296 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer comparison.
+
+package proto
+
+import (
+ "bytes"
+ "log"
+ "reflect"
+ "strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+ - Two messages are equal iff they are the same type,
+ corresponding fields are equal, unknown field sets
+ are equal, and extensions sets are equal.
+ - Two set scalar fields are equal iff their values are equal.
+ If the fields are of a floating-point type, remember that
+ NaN != x for all x, including NaN. If the message is defined
+ in a proto3 .proto file, fields are not "set"; specifically,
+ zero length proto3 "bytes" fields are equal (nil == {}).
+ - Two repeated fields are equal iff their lengths are the same,
+ and their corresponding elements are equal (a "bytes" field,
+ although represented by []byte, is not a repeated field)
+ - Two unset fields are equal.
+ - Two unknown field sets are equal if their current
+ encoded state is equal.
+ - Two extension sets are equal iff they have corresponding
+ elements that are pairwise equal.
+ - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+ if a == nil || b == nil {
+ return a == b
+ }
+ v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+ if v1.Type() != v2.Type() {
+ return false
+ }
+ if v1.Kind() == reflect.Ptr {
+ if v1.IsNil() {
+ return v2.IsNil()
+ }
+ if v2.IsNil() {
+ return false
+ }
+ v1, v2 = v1.Elem(), v2.Elem()
+ }
+ if v1.Kind() != reflect.Struct {
+ return false
+ }
+ return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+ sprop := GetProperties(v1.Type())
+ for i := 0; i < v1.NumField(); i++ {
+ f := v1.Type().Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ f1, f2 := v1.Field(i), v2.Field(i)
+ if f.Type.Kind() == reflect.Ptr {
+ if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+ // both unset
+ continue
+ } else if n1 != n2 {
+ // set/unset mismatch
+ return false
+ }
+ b1, ok := f1.Interface().(raw)
+ if ok {
+ b2 := f2.Interface().(raw)
+ // RawMessage
+ if !bytes.Equal(b1.Bytes(), b2.Bytes()) {
+ return false
+ }
+ continue
+ }
+ f1, f2 = f1.Elem(), f2.Elem()
+ }
+ if !equalAny(f1, f2, sprop.Prop[i]) {
+ return false
+ }
+ }
+
+ if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+ em2 := v2.FieldByName("XXX_InternalExtensions")
+ if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+ return false
+ }
+ }
+
+ if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+ em2 := v2.FieldByName("XXX_extensions")
+ if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+ return false
+ }
+ }
+
+ uf := v1.FieldByName("XXX_unrecognized")
+ if !uf.IsValid() {
+ return true
+ }
+
+ u1 := uf.Bytes()
+ u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+ if !bytes.Equal(u1, u2) {
+ return false
+ }
+
+ return true
+}
+
+// v1 and v2 are known to have the same type.
+// prop may be nil.
+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
+ if v1.Type() == protoMessageType {
+ m1, _ := v1.Interface().(Message)
+ m2, _ := v2.Interface().(Message)
+ return Equal(m1, m2)
+ }
+ switch v1.Kind() {
+ case reflect.Bool:
+ return v1.Bool() == v2.Bool()
+ case reflect.Float32, reflect.Float64:
+ return v1.Float() == v2.Float()
+ case reflect.Int32, reflect.Int64:
+ return v1.Int() == v2.Int()
+ case reflect.Interface:
+ // Probably a oneof field; compare the inner values.
+ n1, n2 := v1.IsNil(), v2.IsNil()
+ if n1 || n2 {
+ return n1 == n2
+ }
+ e1, e2 := v1.Elem(), v2.Elem()
+ if e1.Type() != e2.Type() {
+ return false
+ }
+ return equalAny(e1, e2, nil)
+ case reflect.Map:
+ if v1.Len() != v2.Len() {
+ return false
+ }
+ for _, key := range v1.MapKeys() {
+ val2 := v2.MapIndex(key)
+ if !val2.IsValid() {
+ // This key was not found in the second map.
+ return false
+ }
+ if !equalAny(v1.MapIndex(key), val2, nil) {
+ return false
+ }
+ }
+ return true
+ case reflect.Ptr:
+ // Maps may have nil values in them, so check for nil.
+ if v1.IsNil() && v2.IsNil() {
+ return true
+ }
+ if v1.IsNil() != v2.IsNil() {
+ return false
+ }
+ return equalAny(v1.Elem(), v2.Elem(), prop)
+ case reflect.Slice:
+ if v1.Type().Elem().Kind() == reflect.Uint8 {
+ // short circuit: []byte
+
+ // Edge case: if this is in a proto3 message, a zero length
+ // bytes field is considered the zero value.
+ if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
+ return true
+ }
+ if v1.IsNil() != v2.IsNil() {
+ return false
+ }
+ return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+ }
+
+ if v1.Len() != v2.Len() {
+ return false
+ }
+ for i := 0; i < v1.Len(); i++ {
+ if !equalAny(v1.Index(i), v2.Index(i), prop) {
+ return false
+ }
+ }
+ return true
+ case reflect.String:
+ return v1.Interface().(string) == v2.Interface().(string)
+ case reflect.Struct:
+ return equalStruct(v1, v2)
+ case reflect.Uint32, reflect.Uint64:
+ return v1.Uint() == v2.Uint()
+ }
+
+ // unknown type, so not a protocol buffer
+ log.Printf("proto: don't know how to compare %v", v1)
+ return false
+}
+
+// base is the struct type that the extensions are based on.
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+ em1, _ := x1.extensionsRead()
+ em2, _ := x2.extensionsRead()
+ return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
+ if len(em1) != len(em2) {
+ return false
+ }
+
+ for extNum, e1 := range em1 {
+ e2, ok := em2[extNum]
+ if !ok {
+ return false
+ }
+
+ m1, m2 := e1.value, e2.value
+
+ if m1 != nil && m2 != nil {
+ // Both are unencoded.
+ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+ return false
+ }
+ continue
+ }
+
+ // At least one is encoded. To do a semantically correct comparison
+ // we need to unmarshal them first.
+ var desc *ExtensionDesc
+ if m := extensionMaps[base]; m != nil {
+ desc = m[extNum]
+ }
+ if desc == nil {
+ log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+ continue
+ }
+ var err error
+ if m1 == nil {
+ m1, err = decodeExtension(e1.enc, desc)
+ }
+ if m2 == nil && err == nil {
+ m2, err = decodeExtension(e2.enc, desc)
+ }
+ if err != nil {
+ // The encoded form is invalid.
+ log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+ return false
+ }
+ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+ return false
+ }
+ }
+
+ return true
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
similarity index 65%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/extensions.go
rename to vendor/github.com/golang/protobuf/proto/extensions.go
index 054f4f1df78872e3e9a5ec2ad41a937e463631f5..6b9b3637466073859539788f1586ad2ba85ea85b 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -52,14 +52,99 @@ type ExtensionRange struct {
Start, End int32 // both inclusive
}
-// extendableProto is an interface implemented by any protocol buffer that may be extended.
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
type extendableProto interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ extensionsWrite() map[int32]Extension
+ extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
Message
ExtensionRangeArray() []ExtensionRange
ExtensionMap() map[int32]Extension
}
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+ extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+ return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+ return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock() {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, bool) {
+ if ep, ok := p.(extendableProto); ok {
+ return ep, ok
+ }
+ if ep, ok := p.(extendableProtoV1); ok {
+ return extensionAdapter{ep}, ok
+ }
+ return nil, false
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+ // The struct must be indirect so that if a user inadvertently copies a
+ // generated message and its embedded XXX_InternalExtensions, they
+ // avoid the mayhem of a copied mutex.
+ //
+ // The mutex serializes all logically read-only operations to p.extensionMap.
+ // It is up to the client to ensure that write operations to p.extensionMap are
+ // mutually exclusive with other accesses.
+ p *struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ }
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+ if e.p == nil {
+ e.p = new(struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ })
+ e.p.extensionMap = make(map[int32]Extension)
+ }
+ return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use. It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+ if e.p == nil {
+ return nil, nil
+ }
+ return e.p.extensionMap, &e.p.mu
+}
+
var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
+var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()
// ExtensionDesc represents an extension specification.
// Used in generated code from the protocol compiler.
@@ -92,8 +177,13 @@ type Extension struct {
}
// SetRawExtension is for testing only.
-func SetRawExtension(base extendableProto, id int32, b []byte) {
- base.ExtensionMap()[id] = Extension{enc: b}
+func SetRawExtension(base Message, id int32, b []byte) {
+ epb, ok := extendable(base)
+ if !ok {
+ return
+ }
+ extmap := epb.extensionsWrite()
+ extmap[id] = Extension{enc: b}
}
// isExtensionField returns true iff the given field number is in an extension range.
@@ -108,8 +198,12 @@ func isExtensionField(pb extendableProto, field int32) bool {
// checkExtensionTypes checks that the given extension is valid for pb.
func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+ var pbi interface{} = pb
// Check the extended type.
- if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b {
+ if ea, ok := pbi.(extensionAdapter); ok {
+ pbi = ea.extendableProtoV1
+ }
+ if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
}
// Check the range.
@@ -155,8 +249,19 @@ func extensionProperties(ed *ExtensionDesc) *Properties {
return prop
}
-// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m.
-func encodeExtensionMap(m map[int32]Extension) error {
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensions(e *XXX_InternalExtensions) error {
+ m, mu := e.extensionsRead()
+ if m == nil {
+ return nil // fast path
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ return encodeExtensionsMap(m)
+}
+
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensionsMap(m map[int32]Extension) error {
for k, e := range m {
if e.value == nil || e.desc == nil {
// Extension is only in its encoded form.
@@ -184,7 +289,17 @@ func encodeExtensionMap(m map[int32]Extension) error {
return nil
}
-func sizeExtensionMap(m map[int32]Extension) (n int) {
+func extensionsSize(e *XXX_InternalExtensions) (n int) {
+ m, mu := e.extensionsRead()
+ if m == nil {
+ return 0
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ return extensionsMapSize(m)
+}
+
+func extensionsMapSize(m map[int32]Extension) (n int) {
for _, e := range m {
if e.value == nil || e.desc == nil {
// Extension is only in its encoded form.
@@ -209,26 +324,51 @@ func sizeExtensionMap(m map[int32]Extension) (n int) {
}
// HasExtension returns whether the given extension is present in pb.
-func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
// TODO: Check types, field numbers, etc.?
- _, ok := pb.ExtensionMap()[extension.Field]
+ epb, ok := extendable(pb)
+ if !ok {
+ return false
+ }
+ extmap, mu := epb.extensionsRead()
+ if extmap == nil {
+ return false
+ }
+ mu.Lock()
+ _, ok = extmap[extension.Field]
+ mu.Unlock()
return ok
}
// ClearExtension removes the given extension from pb.
-func ClearExtension(pb extendableProto, extension *ExtensionDesc) {
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+ epb, ok := extendable(pb)
+ if !ok {
+ return
+ }
// TODO: Check types, field numbers, etc.?
- delete(pb.ExtensionMap(), extension.Field)
+ extmap := epb.extensionsWrite()
+ delete(extmap, extension.Field)
}
// GetExtension parses and returns the given extension of pb.
// If the extension is not present and has no default value it returns ErrMissingExtension.
-func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) {
- if err := checkExtensionTypes(pb, extension); err != nil {
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+ epb, ok := extendable(pb)
+ if !ok {
+ return nil, errors.New("proto: not an extendable proto")
+ }
+
+ if err := checkExtensionTypes(epb, extension); err != nil {
return nil, err
}
- emap := pb.ExtensionMap()
+ emap, mu := epb.extensionsRead()
+ if emap == nil {
+ return defaultExtensionValue(extension)
+ }
+ mu.Lock()
+ defer mu.Unlock()
e, ok := emap[extension.Field]
if !ok {
// defaultExtensionValue returns the default value or
@@ -332,10 +472,9 @@ func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
// The returned slice has the same length as es; missing extensions will appear as nil elements.
func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
- epb, ok := pb.(extendableProto)
+ epb, ok := extendable(pb)
if !ok {
- err = errors.New("proto: not an extendable proto")
- return
+ return nil, errors.New("proto: not an extendable proto")
}
extensions = make([]interface{}, len(es))
for i, e := range es {
@@ -350,9 +489,44 @@ func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, e
return
}
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+ epb, ok := extendable(pb)
+ if !ok {
+ return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)
+ }
+ registeredExtensions := RegisteredExtensions(pb)
+
+ emap, mu := epb.extensionsRead()
+ if emap == nil {
+ return nil, nil
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ extensions := make([]*ExtensionDesc, 0, len(emap))
+ for extid, e := range emap {
+ desc := e.desc
+ if desc == nil {
+ desc = registeredExtensions[extid]
+ if desc == nil {
+ desc = &ExtensionDesc{Field: extid}
+ }
+ }
+
+ extensions = append(extensions, desc)
+ }
+ return extensions, nil
+}
+
// SetExtension sets the specified extension of pb to the specified value.
-func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error {
- if err := checkExtensionTypes(pb, extension); err != nil {
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+ epb, ok := extendable(pb)
+ if !ok {
+ return errors.New("proto: not an extendable proto")
+ }
+ if err := checkExtensionTypes(epb, extension); err != nil {
return err
}
typ := reflect.TypeOf(extension.ExtensionType)
@@ -368,10 +542,23 @@ func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{
return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
}
- pb.ExtensionMap()[extension.Field] = Extension{desc: extension, value: value}
+ extmap := epb.extensionsWrite()
+ extmap[extension.Field] = Extension{desc: extension, value: value}
return nil
}
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+ epb, ok := extendable(pb)
+ if !ok {
+ return
+ }
+ m := epb.extensionsWrite()
+ for k := range m {
+ delete(m, k)
+ }
+}
+
// A global registry of extensions.
// The generated code will register the generated descriptors by calling RegisterExtension.
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/lib.go
rename to vendor/github.com/golang/protobuf/proto/lib.go
index 0de8f8dffd0880ceea9abd8176eaa2adb1e11109..ac4ddbc075986d77ca4c3558345673789f4e89a7 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/lib.go
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -308,7 +308,7 @@ func GetStats() Stats { return stats }
// temporary Buffer and are fine for most applications.
type Buffer struct {
buf []byte // encode/decode byte stream
- index int // write point
+ index int // read point
// pools of basic types to amortize allocation.
bools []bool
@@ -889,6 +889,10 @@ func isProto3Zero(v reflect.Value) bool {
return false
}
+// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const ProtoPackageIsVersion2 = true
+
// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
const ProtoPackageIsVersion1 = true
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..fd982decd66e4846031a72a785470be20afe99a5
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -0,0 +1,311 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "reflect"
+ "sort"
+)
+
+// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var errNoMessageTypeID = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and messageSet)
+// model what the protocol compiler produces for the following protocol message:
+// message MessageSet {
+// repeated group Item = 1 {
+// required int32 type_id = 2;
+// required string message = 3;
+// };
+// }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+
+type _MessageSet_Item struct {
+ TypeId *int32 `protobuf:"varint,2,req,name=type_id"`
+ Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type messageSet struct {
+ Item []*_MessageSet_Item `protobuf:"group,1,rep"`
+ XXX_unrecognized []byte
+ // TODO: caching?
+}
+
+// Make sure messageSet is a Message.
+var _ Message = (*messageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+ MessageTypeId() int32
+}
+
+func (ms *messageSet) find(pb Message) *_MessageSet_Item {
+ mti, ok := pb.(messageTypeIder)
+ if !ok {
+ return nil
+ }
+ id := mti.MessageTypeId()
+ for _, item := range ms.Item {
+ if *item.TypeId == id {
+ return item
+ }
+ }
+ return nil
+}
+
+func (ms *messageSet) Has(pb Message) bool {
+ if ms.find(pb) != nil {
+ return true
+ }
+ return false
+}
+
+func (ms *messageSet) Unmarshal(pb Message) error {
+ if item := ms.find(pb); item != nil {
+ return Unmarshal(item.Message, pb)
+ }
+ if _, ok := pb.(messageTypeIder); !ok {
+ return errNoMessageTypeID
+ }
+ return nil // TODO: return error instead?
+}
+
+func (ms *messageSet) Marshal(pb Message) error {
+ msg, err := Marshal(pb)
+ if err != nil {
+ return err
+ }
+ if item := ms.find(pb); item != nil {
+ // reuse existing item
+ item.Message = msg
+ return nil
+ }
+
+ mti, ok := pb.(messageTypeIder)
+ if !ok {
+ return errNoMessageTypeID
+ }
+
+ mtid := mti.MessageTypeId()
+ ms.Item = append(ms.Item, &_MessageSet_Item{
+ TypeId: &mtid,
+ Message: msg,
+ })
+ return nil
+}
+
+func (ms *messageSet) Reset() { *ms = messageSet{} }
+func (ms *messageSet) String() string { return CompactTextString(ms) }
+func (*messageSet) ProtoMessage() {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+ i := 0
+ for ; buf[i]&0x80 != 0; i++ {
+ }
+ return buf[i+1:]
+}
+
+// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
+// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSet(exts interface{}) ([]byte, error) {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ if err := encodeExtensions(exts); err != nil {
+ return nil, err
+ }
+ m, _ = exts.extensionsRead()
+ case map[int32]Extension:
+ if err := encodeExtensionsMap(exts); err != nil {
+ return nil, err
+ }
+ m = exts
+ default:
+ return nil, errors.New("proto: not an extension map")
+ }
+
+ // Sort extension IDs to provide a deterministic encoding.
+ // See also enc_map in encode.go.
+ ids := make([]int, 0, len(m))
+ for id := range m {
+ ids = append(ids, int(id))
+ }
+ sort.Ints(ids)
+
+ ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))}
+ for _, id := range ids {
+ e := m[int32(id)]
+ // Remove the wire type and field number varint, as well as the length varint.
+ msg := skipVarint(skipVarint(e.enc))
+
+ ms.Item = append(ms.Item, &_MessageSet_Item{
+ TypeId: Int32(int32(id)),
+ Message: msg,
+ })
+ }
+ return Marshal(ms)
+}
+
+// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSet(buf []byte, exts interface{}) error {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ m = exts.extensionsWrite()
+ case map[int32]Extension:
+ m = exts
+ default:
+ return errors.New("proto: not an extension map")
+ }
+
+ ms := new(messageSet)
+ if err := Unmarshal(buf, ms); err != nil {
+ return err
+ }
+ for _, item := range ms.Item {
+ id := *item.TypeId
+ msg := item.Message
+
+ // Restore wire type and field number varint, plus length varint.
+ // Be careful to preserve duplicate items.
+ b := EncodeVarint(uint64(id)<<3 | WireBytes)
+ if ext, ok := m[id]; ok {
+ // Existing data; rip off the tag and length varint
+ // so we join the new data correctly.
+ // We can assume that ext.enc is set because we are unmarshaling.
+ o := ext.enc[len(b):] // skip wire type and field number
+ _, n := DecodeVarint(o) // calculate length of length varint
+ o = o[n:] // skip length varint
+ msg = append(o, msg...) // join old data and new data
+ }
+ b = append(b, EncodeVarint(uint64(len(msg)))...)
+ b = append(b, msg...)
+
+ m[id] = Extension{enc: b}
+ }
+ return nil
+}
+
+// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
+// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ m, _ = exts.extensionsRead()
+ case map[int32]Extension:
+ m = exts
+ default:
+ return nil, errors.New("proto: not an extension map")
+ }
+ var b bytes.Buffer
+ b.WriteByte('{')
+
+ // Process the map in key order for deterministic output.
+ ids := make([]int32, 0, len(m))
+ for id := range m {
+ ids = append(ids, id)
+ }
+ sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
+
+ for i, id := range ids {
+ ext := m[id]
+ if i > 0 {
+ b.WriteByte(',')
+ }
+
+ msd, ok := messageSetMap[id]
+ if !ok {
+ // Unknown type; we can't render it, so skip it.
+ continue
+ }
+ fmt.Fprintf(&b, `"[%s]":`, msd.name)
+
+ x := ext.value
+ if x == nil {
+ x = reflect.New(msd.t.Elem()).Interface()
+ if err := Unmarshal(ext.enc, x.(Message)); err != nil {
+ return nil, err
+ }
+ }
+ d, err := json.Marshal(x)
+ if err != nil {
+ return nil, err
+ }
+ b.Write(d)
+ }
+ b.WriteByte('}')
+ return b.Bytes(), nil
+}
+
+// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
+// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
+ // Common-case fast path.
+ if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
+ return nil
+ }
+
+ // This is fairly tricky, and it's not clear that it is needed.
+ return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
+}
+
+// A global registry of types that can be used in a MessageSet.
+
+var messageSetMap = make(map[int32]messageSetDesc)
+
+type messageSetDesc struct {
+ t reflect.Type // pointer to struct
+ name string
+}
+
+// RegisterMessageSetType is called from the generated code.
+func RegisterMessageSetType(m Message, fieldNum int32, name string) {
+ messageSetMap[fieldNum] = messageSetDesc{
+ t: reflect.TypeOf(m),
+ name: name,
+ }
+}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb512e2e16dce05683722f810c279367bdc68fe9
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,484 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+ "math"
+ "reflect"
+)
+
+// A structPointer is a pointer to a struct.
+type structPointer struct {
+ v reflect.Value
+}
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+// The reflect value must itself be a pointer to a struct.
+func toStructPointer(v reflect.Value) structPointer {
+ return structPointer{v}
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+ return p.v.IsNil()
+}
+
+// Interface returns the struct pointer as an interface value.
+func structPointer_Interface(p structPointer, _ reflect.Type) interface{} {
+ return p.v.Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+ return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// field returns the given field in the struct as a reflect value.
+func structPointer_field(p structPointer, f field) reflect.Value {
+ // Special case: an extension map entry with a value of type T
+ // passes a *T to the struct-handling code with a zero field,
+ // expecting that it will be treated as equivalent to *struct{ X T },
+ // which has the same memory layout. We have to handle that case
+ // specially, because reflect will panic if we call FieldByIndex on a
+ // non-struct.
+ if f == nil {
+ return p.v.Elem()
+ }
+
+ return p.v.Elem().FieldByIndex(f)
+}
+
+// ifield returns the given field in the struct as an interface value.
+func structPointer_ifield(p structPointer, f field) interface{} {
+ return structPointer_field(p, f).Addr().Interface()
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+ return structPointer_ifield(p, f).(*[]byte)
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+ return structPointer_ifield(p, f).(*[][]byte)
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+ return structPointer_ifield(p, f).(**bool)
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+ return structPointer_ifield(p, f).(*bool)
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+ return structPointer_ifield(p, f).(*[]bool)
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+ return structPointer_ifield(p, f).(**string)
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+ return structPointer_ifield(p, f).(*string)
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+ return structPointer_ifield(p, f).(*[]string)
+}
+
+// Extensions returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+ return structPointer_ifield(p, f).(*XXX_InternalExtensions)
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+ return structPointer_ifield(p, f).(*map[int32]Extension)
+}
+
+// NewAt returns the reflect.Value for a pointer to a field in the struct.
+func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
+ return structPointer_field(p, f).Addr()
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+ structPointer_field(p, f).Set(q.v)
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+ return structPointer{structPointer_field(p, f)}
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice {
+ return structPointerSlice{structPointer_field(p, f)}
+}
+
+// A structPointerSlice represents the address of a slice of pointers to structs
+// (themselves messages or groups). That is, v.Type() is *[]*struct{...}.
+type structPointerSlice struct {
+ v reflect.Value
+}
+
+func (p structPointerSlice) Len() int { return p.v.Len() }
+func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} }
+func (p structPointerSlice) Append(q structPointer) {
+ p.v.Set(reflect.Append(p.v, q.v))
+}
+
+var (
+ int32Type = reflect.TypeOf(int32(0))
+ uint32Type = reflect.TypeOf(uint32(0))
+ float32Type = reflect.TypeOf(float32(0))
+ int64Type = reflect.TypeOf(int64(0))
+ uint64Type = reflect.TypeOf(uint64(0))
+ float64Type = reflect.TypeOf(float64(0))
+)
+
+// A word32 represents a field of type *int32, *uint32, *float32, or *enum.
+// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable.
+type word32 struct {
+ v reflect.Value
+}
+
+// IsNil reports whether p is nil.
+func word32_IsNil(p word32) bool {
+ return p.v.IsNil()
+}
+
+// Set sets p to point at a newly allocated word with bits set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+ t := p.v.Type().Elem()
+ switch t {
+ case int32Type:
+ if len(o.int32s) == 0 {
+ o.int32s = make([]int32, uint32PoolSize)
+ }
+ o.int32s[0] = int32(x)
+ p.v.Set(reflect.ValueOf(&o.int32s[0]))
+ o.int32s = o.int32s[1:]
+ return
+ case uint32Type:
+ if len(o.uint32s) == 0 {
+ o.uint32s = make([]uint32, uint32PoolSize)
+ }
+ o.uint32s[0] = x
+ p.v.Set(reflect.ValueOf(&o.uint32s[0]))
+ o.uint32s = o.uint32s[1:]
+ return
+ case float32Type:
+ if len(o.float32s) == 0 {
+ o.float32s = make([]float32, uint32PoolSize)
+ }
+ o.float32s[0] = math.Float32frombits(x)
+ p.v.Set(reflect.ValueOf(&o.float32s[0]))
+ o.float32s = o.float32s[1:]
+ return
+ }
+
+ // must be enum
+ p.v.Set(reflect.New(t))
+ p.v.Elem().SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32_Get(p word32) uint32 {
+ elem := p.v.Elem()
+ switch elem.Kind() {
+ case reflect.Int32:
+ return uint32(elem.Int())
+ case reflect.Uint32:
+ return uint32(elem.Uint())
+ case reflect.Float32:
+ return math.Float32bits(float32(elem.Float()))
+ }
+ panic("unreachable")
+}
+
+// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+ return word32{structPointer_field(p, f)}
+}
+
+// A word32Val represents a field of type int32, uint32, float32, or enum.
+// That is, v.Type() is int32, uint32, float32, or enum and v is assignable.
+type word32Val struct {
+ v reflect.Value
+}
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+ switch p.v.Type() {
+ case int32Type:
+ p.v.SetInt(int64(x))
+ return
+ case uint32Type:
+ p.v.SetUint(uint64(x))
+ return
+ case float32Type:
+ p.v.SetFloat(float64(math.Float32frombits(x)))
+ return
+ }
+
+ // must be enum
+ p.v.SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32Val_Get(p word32Val) uint32 {
+ elem := p.v
+ switch elem.Kind() {
+ case reflect.Int32:
+ return uint32(elem.Int())
+ case reflect.Uint32:
+ return uint32(elem.Uint())
+ case reflect.Float32:
+ return math.Float32bits(float32(elem.Float()))
+ }
+ panic("unreachable")
+}
+
+// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+ return word32Val{structPointer_field(p, f)}
+}
+
+// A word32Slice is a slice of 32-bit values.
+// That is, v.Type() is []int32, []uint32, []float32, or []enum.
+type word32Slice struct {
+ v reflect.Value
+}
+
+func (p word32Slice) Append(x uint32) {
+ n, m := p.v.Len(), p.v.Cap()
+ if n < m {
+ p.v.SetLen(n + 1)
+ } else {
+ t := p.v.Type().Elem()
+ p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+ }
+ elem := p.v.Index(n)
+ switch elem.Kind() {
+ case reflect.Int32:
+ elem.SetInt(int64(int32(x)))
+ case reflect.Uint32:
+ elem.SetUint(uint64(x))
+ case reflect.Float32:
+ elem.SetFloat(float64(math.Float32frombits(x)))
+ }
+}
+
+func (p word32Slice) Len() int {
+ return p.v.Len()
+}
+
+func (p word32Slice) Index(i int) uint32 {
+ elem := p.v.Index(i)
+ switch elem.Kind() {
+ case reflect.Int32:
+ return uint32(elem.Int())
+ case reflect.Uint32:
+ return uint32(elem.Uint())
+ case reflect.Float32:
+ return math.Float32bits(float32(elem.Float()))
+ }
+ panic("unreachable")
+}
+
+// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) word32Slice {
+ return word32Slice{structPointer_field(p, f)}
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 struct {
+ v reflect.Value
+}
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+ t := p.v.Type().Elem()
+ switch t {
+ case int64Type:
+ if len(o.int64s) == 0 {
+ o.int64s = make([]int64, uint64PoolSize)
+ }
+ o.int64s[0] = int64(x)
+ p.v.Set(reflect.ValueOf(&o.int64s[0]))
+ o.int64s = o.int64s[1:]
+ return
+ case uint64Type:
+ if len(o.uint64s) == 0 {
+ o.uint64s = make([]uint64, uint64PoolSize)
+ }
+ o.uint64s[0] = x
+ p.v.Set(reflect.ValueOf(&o.uint64s[0]))
+ o.uint64s = o.uint64s[1:]
+ return
+ case float64Type:
+ if len(o.float64s) == 0 {
+ o.float64s = make([]float64, uint64PoolSize)
+ }
+ o.float64s[0] = math.Float64frombits(x)
+ p.v.Set(reflect.ValueOf(&o.float64s[0]))
+ o.float64s = o.float64s[1:]
+ return
+ }
+ panic("unreachable")
+}
+
+func word64_IsNil(p word64) bool {
+ return p.v.IsNil()
+}
+
+func word64_Get(p word64) uint64 {
+ elem := p.v.Elem()
+ switch elem.Kind() {
+ case reflect.Int64:
+ return uint64(elem.Int())
+ case reflect.Uint64:
+ return elem.Uint()
+ case reflect.Float64:
+ return math.Float64bits(elem.Float())
+ }
+ panic("unreachable")
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+ return word64{structPointer_field(p, f)}
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val struct {
+ v reflect.Value
+}
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+ switch p.v.Type() {
+ case int64Type:
+ p.v.SetInt(int64(x))
+ return
+ case uint64Type:
+ p.v.SetUint(x)
+ return
+ case float64Type:
+ p.v.SetFloat(math.Float64frombits(x))
+ return
+ }
+ panic("unreachable")
+}
+
+func word64Val_Get(p word64Val) uint64 {
+ elem := p.v
+ switch elem.Kind() {
+ case reflect.Int64:
+ return uint64(elem.Int())
+ case reflect.Uint64:
+ return elem.Uint()
+ case reflect.Float64:
+ return math.Float64bits(elem.Float())
+ }
+ panic("unreachable")
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+ return word64Val{structPointer_field(p, f)}
+}
+
+type word64Slice struct {
+ v reflect.Value
+}
+
+func (p word64Slice) Append(x uint64) {
+ n, m := p.v.Len(), p.v.Cap()
+ if n < m {
+ p.v.SetLen(n + 1)
+ } else {
+ t := p.v.Type().Elem()
+ p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+ }
+ elem := p.v.Index(n)
+ switch elem.Kind() {
+ case reflect.Int64:
+ elem.SetInt(int64(int64(x)))
+ case reflect.Uint64:
+ elem.SetUint(uint64(x))
+ case reflect.Float64:
+ elem.SetFloat(float64(math.Float64frombits(x)))
+ }
+}
+
+func (p word64Slice) Len() int {
+ return p.v.Len()
+}
+
+func (p word64Slice) Index(i int) uint64 {
+ elem := p.v.Index(i)
+ switch elem.Kind() {
+ case reflect.Int64:
+ return uint64(elem.Int())
+ case reflect.Uint64:
+ return uint64(elem.Uint())
+ case reflect.Float64:
+ return math.Float64bits(float64(elem.Float()))
+ }
+ panic("unreachable")
+}
+
+func structPointer_Word64Slice(p structPointer, f field) word64Slice {
+ return word64Slice{structPointer_field(p, f)}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b5567d47cd396b25370f8c06bad3b851776658f
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,270 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+ "reflect"
+ "unsafe"
+)
+
+// NOTE: These type_Foo functions would more idiomatically be methods,
+// but Go does not allow methods on pointer types, and we must preserve
+// some pointer type for the garbage collector. We use these
+// funcs with clunky names as our poor approximation to methods.
+//
+// An alternative would be
+// type structPointer struct { p unsafe.Pointer }
+// but that does not registerize as well.
+
+// A structPointer is a pointer to a struct.
+type structPointer unsafe.Pointer
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+func toStructPointer(v reflect.Value) structPointer {
+ return structPointer(unsafe.Pointer(v.Pointer()))
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+ return p == nil
+}
+
+// Interface returns the struct pointer, assumed to have element type t,
+// as an interface value.
+func structPointer_Interface(p structPointer, t reflect.Type) interface{} {
+ return reflect.NewAt(t, unsafe.Pointer(p)).Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+ return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+ return f != ^field(0)
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+ return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+ return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+ return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+ return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+ return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+ return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+ return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+ return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+ return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+ return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// NewAt returns the reflect.Value for a pointer to a field in the struct.
+func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
+ return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f)))
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+ *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+ return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice {
+ return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups).
+type structPointerSlice []structPointer
+
+func (v *structPointerSlice) Len() int { return len(*v) }
+func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] }
+func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) }
+
+// A word32 is the address of a "pointer to 32-bit value" field.
+type word32 **uint32
+
+// IsNil reports whether *v is nil.
+func word32_IsNil(p word32) bool {
+ return *p == nil
+}
+
+// Set sets *v to point at a newly allocated word set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+ if len(o.uint32s) == 0 {
+ o.uint32s = make([]uint32, uint32PoolSize)
+ }
+ o.uint32s[0] = x
+ *p = &o.uint32s[0]
+ o.uint32s = o.uint32s[1:]
+}
+
+// Get gets the value pointed at by *v.
+func word32_Get(p word32) uint32 {
+ return **p
+}
+
+// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+ return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Val is the address of a 32-bit value field.
+type word32Val *uint32
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+ *p = x
+}
+
+// Get gets the value pointed at by p.
+func word32Val_Get(p word32Val) uint32 {
+ return *p
+}
+
+// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+ return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Slice is a slice of 32-bit values.
+type word32Slice []uint32
+
+func (v *word32Slice) Append(x uint32) { *v = append(*v, x) }
+func (v *word32Slice) Len() int { return len(*v) }
+func (v *word32Slice) Index(i int) uint32 { return (*v)[i] }
+
+// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) *word32Slice {
+ return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 **uint64
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+ if len(o.uint64s) == 0 {
+ o.uint64s = make([]uint64, uint64PoolSize)
+ }
+ o.uint64s[0] = x
+ *p = &o.uint64s[0]
+ o.uint64s = o.uint64s[1:]
+}
+
+func word64_IsNil(p word64) bool {
+ return *p == nil
+}
+
+func word64_Get(p word64) uint64 {
+ return **p
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+ return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val *uint64
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+ *p = x
+}
+
+func word64Val_Get(p word64Val) uint64 {
+ return *p
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+ return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Slice is like word32Slice but for 64-bit values.
+type word64Slice []uint64
+
+func (v *word64Slice) Append(x uint64) { *v = append(*v, x) }
+func (v *word64Slice) Len() int { return len(*v) }
+func (v *word64Slice) Index(i int) uint64 { return (*v)[i] }
+
+func structPointer_Word64Slice(p structPointer, f field) *word64Slice {
+ return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
diff --git a/Godeps/_workspace/src/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
similarity index 94%
rename from Godeps/_workspace/src/github.com/golang/protobuf/proto/properties.go
rename to vendor/github.com/golang/protobuf/proto/properties.go
index d4531c05638476154df3c388fbae13406913c488..69ddda8d4ba04274e7829ff9f3a29392f4a241e8 100644
--- a/Godeps/_workspace/src/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -173,6 +173,7 @@ func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order
type Properties struct {
Name string // name of the field, for error messages
OrigName string // original name before protocol compiler (always set)
+ JSONName string // name to use for JSON; determined by protoc
Wire string
WireType int
Tag int
@@ -229,8 +230,9 @@ func (p *Properties) String() string {
if p.Packed {
s += ",packed"
}
- if p.OrigName != p.Name {
- s += ",name=" + p.OrigName
+ s += ",name=" + p.OrigName
+ if p.JSONName != p.OrigName {
+ s += ",json=" + p.JSONName
}
if p.proto3 {
s += ",proto3"
@@ -310,6 +312,8 @@ func (p *Properties) Parse(s string) {
p.Packed = true
case strings.HasPrefix(f, "name="):
p.OrigName = f[5:]
+ case strings.HasPrefix(f, "json="):
+ p.JSONName = f[5:]
case strings.HasPrefix(f, "enum="):
p.Enum = f[5:]
case f == "proto3":
@@ -469,17 +473,13 @@ func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lock
p.dec = (*Buffer).dec_slice_int64
p.packedDec = (*Buffer).dec_slice_packed_int64
case reflect.Uint8:
- p.enc = (*Buffer).enc_slice_byte
p.dec = (*Buffer).dec_slice_byte
- p.size = size_slice_byte
- // This is a []byte, which is either a bytes field,
- // or the value of a map field. In the latter case,
- // we always encode an empty []byte, so we should not
- // use the proto3 enc/size funcs.
- // f == nil iff this is the key/value of a map field.
- if p.proto3 && f != nil {
+ if p.proto3 {
p.enc = (*Buffer).enc_proto3_slice_byte
p.size = size_proto3_slice_byte
+ } else {
+ p.enc = (*Buffer).enc_slice_byte
+ p.size = size_slice_byte
}
case reflect.Float32, reflect.Float64:
switch t2.Bits() {
@@ -678,7 +678,8 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
propertiesMap[t] = prop
// build properties
- prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType)
+ prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ||
+ reflect.PtrTo(t).Implements(extendableProtoV1Type)
prop.unrecField = invalidField
prop.Prop = make([]*Properties, t.NumField())
prop.order = make([]int, t.NumField())
@@ -689,15 +690,22 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
name := f.Name
p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
- if f.Name == "XXX_extensions" { // special case
+ if f.Name == "XXX_InternalExtensions" { // special case
+ p.enc = (*Buffer).enc_exts
+ p.dec = nil // not needed
+ p.size = size_exts
+ } else if f.Name == "XXX_extensions" { // special case
p.enc = (*Buffer).enc_map
p.dec = nil // not needed
p.size = size_map
- }
- if f.Name == "XXX_unrecognized" { // special case
+ } else if f.Name == "XXX_unrecognized" { // special case
prop.unrecField = toField(&f)
}
- oneof := f.Tag.Get("protobuf_oneof") != "" // special case
+ oneof := f.Tag.Get("protobuf_oneof") // special case
+ if oneof != "" {
+ // Oneof fields don't use the traditional protobuf tag.
+ p.OrigName = oneof
+ }
prop.Prop[i] = p
prop.order[i] = i
if debug {
@@ -707,7 +715,7 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
}
print("\n")
}
- if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && !oneof {
+ if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" {
fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
}
}
@@ -840,3 +848,17 @@ func MessageName(x Message) string { return revProtoTypes[reflect.TypeOf(x)] }
// MessageType returns the message type (pointer to struct) for a named message.
func MessageType(name string) reflect.Type { return protoTypes[name] }
+
+// A registry of all linked proto files.
+var (
+ protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+ protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go
new file mode 100644
index 0000000000000000000000000000000000000000..965876bf033b64fac26deb2730244625d033fa41
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text.go
@@ -0,0 +1,854 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+ "bufio"
+ "bytes"
+ "encoding"
+ "errors"
+ "fmt"
+ "io"
+ "log"
+ "math"
+ "reflect"
+ "sort"
+ "strings"
+)
+
+var (
+ newline = []byte("\n")
+ spaces = []byte(" ")
+ gtNewline = []byte(">\n")
+ endBraceNewline = []byte("}\n")
+ backslashN = []byte{'\\', 'n'}
+ backslashR = []byte{'\\', 'r'}
+ backslashT = []byte{'\\', 't'}
+ backslashDQ = []byte{'\\', '"'}
+ backslashBS = []byte{'\\', '\\'}
+ posInf = []byte("inf")
+ negInf = []byte("-inf")
+ nan = []byte("nan")
+)
+
+type writer interface {
+ io.Writer
+ WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+ ind int
+ complete bool // if the current position is a complete line
+ compact bool // whether to write out as a one-liner
+ w writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+ if !strings.Contains(s, "\n") {
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ w.complete = false
+ return io.WriteString(w.w, s)
+ }
+ // WriteString is typically called without newlines, so this
+ // codepath and its copy are rare. We copy to avoid
+ // duplicating all of Write's logic here.
+ return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+ newlines := bytes.Count(p, newline)
+ if newlines == 0 {
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ n, err = w.w.Write(p)
+ w.complete = false
+ return n, err
+ }
+
+ frags := bytes.SplitN(p, newline, newlines+1)
+ if w.compact {
+ for i, frag := range frags {
+ if i > 0 {
+ if err := w.w.WriteByte(' '); err != nil {
+ return n, err
+ }
+ n++
+ }
+ nn, err := w.w.Write(frag)
+ n += nn
+ if err != nil {
+ return n, err
+ }
+ }
+ return n, nil
+ }
+
+ for i, frag := range frags {
+ if w.complete {
+ w.writeIndent()
+ }
+ nn, err := w.w.Write(frag)
+ n += nn
+ if err != nil {
+ return n, err
+ }
+ if i+1 < len(frags) {
+ if err := w.w.WriteByte('\n'); err != nil {
+ return n, err
+ }
+ n++
+ }
+ }
+ w.complete = len(frags[len(frags)-1]) == 0
+ return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+ if w.compact && c == '\n' {
+ c = ' '
+ }
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ err := w.w.WriteByte(c)
+ w.complete = c == '\n'
+ return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+ if w.ind == 0 {
+ log.Print("proto: textWriter unindented too far")
+ return
+ }
+ w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+ if _, err := w.WriteString(props.OrigName); err != nil {
+ return err
+ }
+ if props.Wire != "group" {
+ return w.WriteByte(':')
+ }
+ return nil
+}
+
+// raw is the interface satisfied by RawMessage.
+type raw interface {
+ Bytes() []byte
+}
+
+func requiresQuotes(u string) bool {
+ // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+ for _, ch := range u {
+ switch {
+ case ch == '.' || ch == '/' || ch == '_':
+ continue
+ case '0' <= ch && ch <= '9':
+ continue
+ case 'A' <= ch && ch <= 'Z':
+ continue
+ case 'a' <= ch && ch <= 'z':
+ continue
+ default:
+ return true
+ }
+ }
+ return false
+}
+
+// isAny reports whether sv is a google.protobuf.Any message
+func isAny(sv reflect.Value) bool {
+ type wkt interface {
+ XXX_WellKnownType() string
+ }
+ t, ok := sv.Addr().Interface().(wkt)
+ return ok && t.XXX_WellKnownType() == "Any"
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
+ turl := sv.FieldByName("TypeUrl")
+ val := sv.FieldByName("Value")
+ if !turl.IsValid() || !val.IsValid() {
+ return true, errors.New("proto: invalid google.protobuf.Any message")
+ }
+
+ b, ok := val.Interface().([]byte)
+ if !ok {
+ return true, errors.New("proto: invalid google.protobuf.Any message")
+ }
+
+ parts := strings.Split(turl.String(), "/")
+ mt := MessageType(parts[len(parts)-1])
+ if mt == nil {
+ return false, nil
+ }
+ m := reflect.New(mt.Elem())
+ if err := Unmarshal(b, m.Interface().(Message)); err != nil {
+ return false, nil
+ }
+ w.Write([]byte("["))
+ u := turl.String()
+ if requiresQuotes(u) {
+ writeString(w, u)
+ } else {
+ w.Write([]byte(u))
+ }
+ if w.compact {
+ w.Write([]byte("]:<"))
+ } else {
+ w.Write([]byte("]: <\n"))
+ w.ind++
+ }
+ if err := tm.writeStruct(w, m.Elem()); err != nil {
+ return true, err
+ }
+ if w.compact {
+ w.Write([]byte("> "))
+ } else {
+ w.ind--
+ w.Write([]byte(">\n"))
+ }
+ return true, nil
+}
+
+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
+ if tm.ExpandAny && isAny(sv) {
+ if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
+ return err
+ }
+ }
+ st := sv.Type()
+ sprops := GetProperties(st)
+ for i := 0; i < sv.NumField(); i++ {
+ fv := sv.Field(i)
+ props := sprops.Prop[i]
+ name := st.Field(i).Name
+
+ if strings.HasPrefix(name, "XXX_") {
+ // There are two XXX_ fields:
+ // XXX_unrecognized []byte
+ // XXX_extensions map[int32]proto.Extension
+ // The first is handled here;
+ // the second is handled at the bottom of this function.
+ if name == "XXX_unrecognized" && !fv.IsNil() {
+ if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if fv.Kind() == reflect.Ptr && fv.IsNil() {
+ // Field not filled in. This could be an optional field or
+ // a required field that wasn't filled in. Either way, there
+ // isn't anything we can show for it.
+ continue
+ }
+ if fv.Kind() == reflect.Slice && fv.IsNil() {
+ // Repeated field that is empty, or a bytes field that is unused.
+ continue
+ }
+
+ if props.Repeated && fv.Kind() == reflect.Slice {
+ // Repeated field.
+ for j := 0; j < fv.Len(); j++ {
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ v := fv.Index(j)
+ if v.Kind() == reflect.Ptr && v.IsNil() {
+ // A nil message in a repeated field is not valid,
+ // but we can handle that more gracefully than panicking.
+ if _, err := w.Write([]byte("<nil>\n")); err != nil {
+ return err
+ }
+ continue
+ }
+ if err := tm.writeAny(w, v, props); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if fv.Kind() == reflect.Map {
+ // Map fields are rendered as a repeated struct with key/value fields.
+ keys := fv.MapKeys()
+ sort.Sort(mapKeys(keys))
+ for _, key := range keys {
+ val := fv.MapIndex(key)
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ // open struct
+ if err := w.WriteByte('<'); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ w.indent()
+ // key
+ if _, err := w.WriteString("key:"); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, key, props.mkeyprop); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ // nil values aren't legal, but we can avoid panicking because of them.
+ if val.Kind() != reflect.Ptr || !val.IsNil() {
+ // value
+ if _, err := w.WriteString("value:"); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, val, props.mvalprop); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ // close struct
+ w.unindent()
+ if err := w.WriteByte('>'); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+ // empty bytes field
+ continue
+ }
+ if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+ // proto3 non-repeated scalar field; skip if zero value
+ if isProto3Zero(fv) {
+ continue
+ }
+ }
+
+ if fv.Kind() == reflect.Interface {
+ // Check if it is a oneof.
+ if st.Field(i).Tag.Get("protobuf_oneof") != "" {
+ // fv is nil, or holds a pointer to generated struct.
+ // That generated struct has exactly one field,
+ // which has a protobuf struct tag.
+ if fv.IsNil() {
+ continue
+ }
+ inner := fv.Elem().Elem() // interface -> *T -> T
+ tag := inner.Type().Field(0).Tag.Get("protobuf")
+ props = new(Properties) // Overwrite the outer props var, but not its pointee.
+ props.Parse(tag)
+ // Write the value in the oneof, not the oneof itself.
+ fv = inner.Field(0)
+
+ // Special case to cope with malformed messages gracefully:
+ // If the value in the oneof is a nil pointer, don't panic
+ // in writeAny.
+ if fv.Kind() == reflect.Ptr && fv.IsNil() {
+ // Use errors.New so writeAny won't render quotes.
+ msg := errors.New("/* nil */")
+ fv = reflect.ValueOf(&msg).Elem()
+ }
+ }
+ }
+
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if b, ok := fv.Interface().(raw); ok {
+ if err := writeRaw(w, b.Bytes()); err != nil {
+ return err
+ }
+ continue
+ }
+
+ // Enums have a String method, so writeAny will work fine.
+ if err := tm.writeAny(w, fv, props); err != nil {
+ return err
+ }
+
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+
+ // Extensions (the XXX_extensions field).
+ pv := sv.Addr()
+ if _, ok := extendable(pv.Interface()); ok {
+ if err := tm.writeExtensions(w, pv); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// writeRaw writes an uninterpreted raw message.
+func writeRaw(w *textWriter, b []byte) error {
+ if err := w.WriteByte('<'); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ w.indent()
+ if err := writeUnknownStruct(w, b); err != nil {
+ return err
+ }
+ w.unindent()
+ if err := w.WriteByte('>'); err != nil {
+ return err
+ }
+ return nil
+}
+
+// writeAny writes an arbitrary field.
+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+ v = reflect.Indirect(v)
+
+ // Floats have special cases.
+ if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+ x := v.Float()
+ var b []byte
+ switch {
+ case math.IsInf(x, 1):
+ b = posInf
+ case math.IsInf(x, -1):
+ b = negInf
+ case math.IsNaN(x):
+ b = nan
+ }
+ if b != nil {
+ _, err := w.Write(b)
+ return err
+ }
+ // Other values are handled below.
+ }
+
+ // We don't attempt to serialise every possible value type; only those
+ // that can occur in protocol buffers.
+ switch v.Kind() {
+ case reflect.Slice:
+ // Should only be a []byte; repeated fields are handled in writeStruct.
+ if err := writeString(w, string(v.Bytes())); err != nil {
+ return err
+ }
+ case reflect.String:
+ if err := writeString(w, v.String()); err != nil {
+ return err
+ }
+ case reflect.Struct:
+ // Required/optional group/message.
+ var bra, ket byte = '<', '>'
+ if props != nil && props.Wire == "group" {
+ bra, ket = '{', '}'
+ }
+ if err := w.WriteByte(bra); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ w.indent()
+ if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
+ text, err := etm.MarshalText()
+ if err != nil {
+ return err
+ }
+ if _, err = w.Write(text); err != nil {
+ return err
+ }
+ } else if err := tm.writeStruct(w, v); err != nil {
+ return err
+ }
+ w.unindent()
+ if err := w.WriteByte(ket); err != nil {
+ return err
+ }
+ default:
+ _, err := fmt.Fprint(w, v.Interface())
+ return err
+ }
+ return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+ return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+ // use WriteByte here to get any needed indent
+ if err := w.WriteByte('"'); err != nil {
+ return err
+ }
+ // Loop over the bytes, not the runes.
+ for i := 0; i < len(s); i++ {
+ var err error
+ // Divergence from C++: we don't escape apostrophes.
+ // There's no need to escape them, and the C++ parser
+ // copes with a naked apostrophe.
+ switch c := s[i]; c {
+ case '\n':
+ _, err = w.w.Write(backslashN)
+ case '\r':
+ _, err = w.w.Write(backslashR)
+ case '\t':
+ _, err = w.w.Write(backslashT)
+ case '"':
+ _, err = w.w.Write(backslashDQ)
+ case '\\':
+ _, err = w.w.Write(backslashBS)
+ default:
+ if isprint(c) {
+ err = w.w.WriteByte(c)
+ } else {
+ _, err = fmt.Fprintf(w.w, "\\%03o", c)
+ }
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return w.WriteByte('"')
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+ if !w.compact {
+ if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+ return err
+ }
+ }
+ b := NewBuffer(data)
+ for b.index < len(b.buf) {
+ x, err := b.DecodeVarint()
+ if err != nil {
+ _, err := fmt.Fprintf(w, "/* %v */\n", err)
+ return err
+ }
+ wire, tag := x&7, x>>3
+ if wire == WireEndGroup {
+ w.unindent()
+ if _, err := w.Write(endBraceNewline); err != nil {
+ return err
+ }
+ continue
+ }
+ if _, err := fmt.Fprint(w, tag); err != nil {
+ return err
+ }
+ if wire != WireStartGroup {
+ if err := w.WriteByte(':'); err != nil {
+ return err
+ }
+ }
+ if !w.compact || wire == WireStartGroup {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ switch wire {
+ case WireBytes:
+ buf, e := b.DecodeRawBytes(false)
+ if e == nil {
+ _, err = fmt.Fprintf(w, "%q", buf)
+ } else {
+ _, err = fmt.Fprintf(w, "/* %v */", e)
+ }
+ case WireFixed32:
+ x, err = b.DecodeFixed32()
+ err = writeUnknownInt(w, x, err)
+ case WireFixed64:
+ x, err = b.DecodeFixed64()
+ err = writeUnknownInt(w, x, err)
+ case WireStartGroup:
+ err = w.WriteByte('{')
+ w.indent()
+ case WireVarint:
+ x, err = b.DecodeVarint()
+ err = writeUnknownInt(w, x, err)
+ default:
+ _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+ }
+ if err != nil {
+ return err
+ }
+ if err = w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+ if err == nil {
+ _, err = fmt.Fprint(w, x)
+ } else {
+ _, err = fmt.Fprintf(w, "/* %v */", err)
+ }
+ return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
+ emap := extensionMaps[pv.Type().Elem()]
+ ep, _ := extendable(pv.Interface())
+
+ // Order the extensions by ID.
+ // This isn't strictly necessary, but it will give us
+ // canonical output, which will also make testing easier.
+ m, mu := ep.extensionsRead()
+ if m == nil {
+ return nil
+ }
+ mu.Lock()
+ ids := make([]int32, 0, len(m))
+ for id := range m {
+ ids = append(ids, id)
+ }
+ sort.Sort(int32Slice(ids))
+ mu.Unlock()
+
+ for _, extNum := range ids {
+ ext := m[extNum]
+ var desc *ExtensionDesc
+ if emap != nil {
+ desc = emap[extNum]
+ }
+ if desc == nil {
+ // Unknown extension.
+ if err := writeUnknownStruct(w, ext.enc); err != nil {
+ return err
+ }
+ continue
+ }
+
+ pb, err := GetExtension(ep, desc)
+ if err != nil {
+ return fmt.Errorf("failed getting extension: %v", err)
+ }
+
+ // Repeated extensions will appear as a slice.
+ if !desc.repeated() {
+ if err := tm.writeExtension(w, desc.Name, pb); err != nil {
+ return err
+ }
+ } else {
+ v := reflect.ValueOf(pb)
+ for i := 0; i < v.Len(); i++ {
+ if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+ return err
+ }
+ }
+ }
+ }
+ return nil
+}
+
+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
+ if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (w *textWriter) writeIndent() {
+ if !w.complete {
+ return
+ }
+ remain := w.ind * 2
+ for remain > 0 {
+ n := remain
+ if n > len(spaces) {
+ n = len(spaces)
+ }
+ w.w.Write(spaces[:n])
+ remain -= n
+ }
+ w.complete = false
+}
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+ Compact bool // use compact text format (one line).
+ ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
+ val := reflect.ValueOf(pb)
+ if pb == nil || val.IsNil() {
+ w.Write([]byte("<nil>"))
+ return nil
+ }
+ var bw *bufio.Writer
+ ww, ok := w.(writer)
+ if !ok {
+ bw = bufio.NewWriter(w)
+ ww = bw
+ }
+ aw := &textWriter{
+ w: ww,
+ complete: true,
+ compact: tm.Compact,
+ }
+
+ if etm, ok := pb.(encoding.TextMarshaler); ok {
+ text, err := etm.MarshalText()
+ if err != nil {
+ return err
+ }
+ if _, err = aw.Write(text); err != nil {
+ return err
+ }
+ if bw != nil {
+ return bw.Flush()
+ }
+ return nil
+ }
+ // Dereference the received pointer so we don't have outer < and >.
+ v := reflect.Indirect(val)
+ if err := tm.writeStruct(aw, v); err != nil {
+ return err
+ }
+ if bw != nil {
+ return bw.Flush()
+ }
+ return nil
+}
+
+// Text is the same as Marshal, but returns the string directly.
+func (tm *TextMarshaler) Text(pb Message) string {
+ var buf bytes.Buffer
+ tm.Marshal(&buf, pb)
+ return buf.String()
+}
+
+var (
+ defaultTextMarshaler = TextMarshaler{}
+ compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go
new file mode 100644
index 0000000000000000000000000000000000000000..7e6f145a10d632b434d2d96217c86a8802899cd0
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text_parser.go
@@ -0,0 +1,891 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+ "encoding"
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// Error string emitted when deserializing Any and fields are already set
+const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
+
+type ParseError struct {
+ Message string
+ Line int // 1-based line number
+ Offset int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+ if p.Line == 1 {
+ // show offset only for first line
+ return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+ }
+ return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+ value string
+ err *ParseError
+ line int // line number
+ offset int // byte number from start of input, not start of line
+ unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+ if t.err == nil {
+ return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+ }
+ return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+ s string // remaining input
+ done bool // whether the parsing is finished (success or error)
+ backed bool // whether back() was called
+ offset, line int
+ cur token
+}
+
+func newTextParser(s string) *textParser {
+ p := new(textParser)
+ p.s = s
+ p.line = 1
+ p.cur.line = 1
+ return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+ pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+ p.cur.err = pe
+ p.done = true
+ return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+ switch {
+ case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+ return true
+ case '0' <= c && c <= '9':
+ return true
+ }
+ switch c {
+ case '-', '+', '.', '_':
+ return true
+ }
+ return false
+}
+
+func isWhitespace(c byte) bool {
+ switch c {
+ case ' ', '\t', '\n', '\r':
+ return true
+ }
+ return false
+}
+
+func isQuote(c byte) bool {
+ switch c {
+ case '"', '\'':
+ return true
+ }
+ return false
+}
+
+func (p *textParser) skipWhitespace() {
+ i := 0
+ for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+ if p.s[i] == '#' {
+ // comment; skip to end of line or input
+ for i < len(p.s) && p.s[i] != '\n' {
+ i++
+ }
+ if i == len(p.s) {
+ break
+ }
+ }
+ if p.s[i] == '\n' {
+ p.line++
+ }
+ i++
+ }
+ p.offset += i
+ p.s = p.s[i:len(p.s)]
+ if len(p.s) == 0 {
+ p.done = true
+ }
+}
+
+func (p *textParser) advance() {
+ // Skip whitespace
+ p.skipWhitespace()
+ if p.done {
+ return
+ }
+
+ // Start of non-whitespace
+ p.cur.err = nil
+ p.cur.offset, p.cur.line = p.offset, p.line
+ p.cur.unquoted = ""
+ switch p.s[0] {
+ case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+ // Single symbol
+ p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+ case '"', '\'':
+ // Quoted string
+ i := 1
+ for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+ if p.s[i] == '\\' && i+1 < len(p.s) {
+ // skip escaped char
+ i++
+ }
+ i++
+ }
+ if i >= len(p.s) || p.s[i] != p.s[0] {
+ p.errorf("unmatched quote")
+ return
+ }
+ unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+ if err != nil {
+ p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+ return
+ }
+ p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+ p.cur.unquoted = unq
+ default:
+ i := 0
+ for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+ i++
+ }
+ if i == 0 {
+ p.errorf("unexpected byte %#x", p.s[0])
+ return
+ }
+ p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+ }
+ p.offset += len(p.cur.value)
+}
+
+var (
+ errBadUTF8 = errors.New("proto: bad UTF-8")
+ errBadHex = errors.New("proto: bad hexadecimal")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+ // This is based on C++'s tokenizer.cc.
+ // Despite its name, this is *not* parsing C syntax.
+ // For instance, "\0" is an invalid quoted string.
+
+ // Avoid allocation in trivial cases.
+ simple := true
+ for _, r := range s {
+ if r == '\\' || r == quote {
+ simple = false
+ break
+ }
+ }
+ if simple {
+ return s, nil
+ }
+
+ buf := make([]byte, 0, 3*len(s)/2)
+ for len(s) > 0 {
+ r, n := utf8.DecodeRuneInString(s)
+ if r == utf8.RuneError && n == 1 {
+ return "", errBadUTF8
+ }
+ s = s[n:]
+ if r != '\\' {
+ if r < utf8.RuneSelf {
+ buf = append(buf, byte(r))
+ } else {
+ buf = append(buf, string(r)...)
+ }
+ continue
+ }
+
+ ch, tail, err := unescape(s)
+ if err != nil {
+ return "", err
+ }
+ buf = append(buf, ch...)
+ s = tail
+ }
+ return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+ r, n := utf8.DecodeRuneInString(s)
+ if r == utf8.RuneError && n == 1 {
+ return "", "", errBadUTF8
+ }
+ s = s[n:]
+ switch r {
+ case 'a':
+ return "\a", s, nil
+ case 'b':
+ return "\b", s, nil
+ case 'f':
+ return "\f", s, nil
+ case 'n':
+ return "\n", s, nil
+ case 'r':
+ return "\r", s, nil
+ case 't':
+ return "\t", s, nil
+ case 'v':
+ return "\v", s, nil
+ case '?':
+ return "?", s, nil // trigraph workaround
+ case '\'', '"', '\\':
+ return string(r), s, nil
+ case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X':
+ if len(s) < 2 {
+ return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+ }
+ base := 8
+ ss := s[:2]
+ s = s[2:]
+ if r == 'x' || r == 'X' {
+ base = 16
+ } else {
+ ss = string(r) + ss
+ }
+ i, err := strconv.ParseUint(ss, base, 8)
+ if err != nil {
+ return "", "", err
+ }
+ return string([]byte{byte(i)}), s, nil
+ case 'u', 'U':
+ n := 4
+ if r == 'U' {
+ n = 8
+ }
+ if len(s) < n {
+ return "", "", fmt.Errorf(`\%c requires %d digits`, r, n)
+ }
+
+ bs := make([]byte, n/2)
+ for i := 0; i < n; i += 2 {
+ a, ok1 := unhex(s[i])
+ b, ok2 := unhex(s[i+1])
+ if !ok1 || !ok2 {
+ return "", "", errBadHex
+ }
+ bs[i/2] = a<<4 | b
+ }
+ s = s[n:]
+ return string(bs), s, nil
+ }
+ return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Adapted from src/pkg/strconv/quote.go.
+func unhex(b byte) (v byte, ok bool) {
+ switch {
+ case '0' <= b && b <= '9':
+ return b - '0', true
+ case 'a' <= b && b <= 'f':
+ return b - 'a' + 10, true
+ case 'A' <= b && b <= 'F':
+ return b - 'A' + 10, true
+ }
+ return 0, false
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+ if p.backed || p.done {
+ p.backed = false
+ return &p.cur
+ }
+ p.advance()
+ if p.done {
+ p.cur.value = ""
+ } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+ // Look for multiple quoted strings separated by whitespace,
+ // and concatenate them.
+ cat := p.cur
+ for {
+ p.skipWhitespace()
+ if p.done || !isQuote(p.s[0]) {
+ break
+ }
+ p.advance()
+ if p.cur.err != nil {
+ return &p.cur
+ }
+ cat.value += " " + p.cur.value
+ cat.unquoted += p.cur.unquoted
+ }
+ p.done = false // parser may have seen EOF, but we want to return cat
+ p.cur = cat
+ }
+ return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != s {
+ p.back()
+ return p.errorf("expected %q, found %q", s, tok.value)
+ }
+ return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+ st := sv.Type()
+ sprops := GetProperties(st)
+ for i := 0; i < st.NumField(); i++ {
+ if !isNil(sv.Field(i)) {
+ continue
+ }
+
+ props := sprops.Prop[i]
+ if props.Required {
+ return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+ }
+ }
+ return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
+ i, ok := sprops.decoderOrigNames[name]
+ if ok {
+ return i, sprops.Prop[i], true
+ }
+ return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != ":" {
+ // Colon is optional when the field is a group or message.
+ needColon := true
+ switch props.Wire {
+ case "group":
+ needColon = false
+ case "bytes":
+ // A "bytes" field is either a message, a string, or a repeated field;
+ // those three become *T, *string and []T respectively, so we can check for
+ // this field being a pointer to a non-string.
+ if typ.Kind() == reflect.Ptr {
+ // *T or *string
+ if typ.Elem().Kind() == reflect.String {
+ break
+ }
+ } else if typ.Kind() == reflect.Slice {
+ // []T or []*T
+ if typ.Elem().Kind() != reflect.Ptr {
+ break
+ }
+ } else if typ.Kind() == reflect.String {
+ // The proto3 exception is for a string field,
+ // which requires a colon.
+ break
+ }
+ needColon = false
+ }
+ if needColon {
+ return p.errorf("expected ':', found %q", tok.value)
+ }
+ p.back()
+ }
+ return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+ st := sv.Type()
+ sprops := GetProperties(st)
+ reqCount := sprops.reqCount
+ var reqFieldErr error
+ fieldSet := make(map[string]bool)
+ // A struct is a sequence of "name: value", terminated by one of
+ // '>' or '}', or the end of the input. A name may also be
+ // "[extension]" or "[type/url]".
+ //
+ // The whole struct can also be an expanded Any message, like:
+ // [type/url] < ... struct contents ... >
+ for {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == terminator {
+ break
+ }
+ if tok.value == "[" {
+ // Looks like an extension or an Any.
+ //
+ // TODO: Check whether we need to handle
+ // namespace rooted names (e.g. ".something.Foo").
+ extName, err := p.consumeExtName()
+ if err != nil {
+ return err
+ }
+
+ if s := strings.LastIndex(extName, "/"); s >= 0 {
+ // If it contains a slash, it's an Any type URL.
+ messageName := extName[s+1:]
+ mt := MessageType(messageName)
+ if mt == nil {
+ return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
+ }
+ tok = p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ // consume an optional colon
+ if tok.value == ":" {
+ tok = p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ }
+ var terminator string
+ switch tok.value {
+ case "<":
+ terminator = ">"
+ case "{":
+ terminator = "}"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ v := reflect.New(mt.Elem())
+ if pe := p.readStruct(v.Elem(), terminator); pe != nil {
+ return pe
+ }
+ b, err := Marshal(v.Interface().(Message))
+ if err != nil {
+ return p.errorf("failed to marshal message of type %q: %v", messageName, err)
+ }
+ if fieldSet["type_url"] {
+ return p.errorf(anyRepeatedlyUnpacked, "type_url")
+ }
+ if fieldSet["value"] {
+ return p.errorf(anyRepeatedlyUnpacked, "value")
+ }
+ sv.FieldByName("TypeUrl").SetString(extName)
+ sv.FieldByName("Value").SetBytes(b)
+ fieldSet["type_url"] = true
+ fieldSet["value"] = true
+ continue
+ }
+
+ var desc *ExtensionDesc
+ // This could be faster, but it's functional.
+ // TODO: Do something smarter than a linear scan.
+ for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+ if d.Name == extName {
+ desc = d
+ break
+ }
+ }
+ if desc == nil {
+ return p.errorf("unrecognized extension %q", extName)
+ }
+
+ props := &Properties{}
+ props.Parse(desc.Tag)
+
+ typ := reflect.TypeOf(desc.ExtensionType)
+ if err := p.checkForColon(props, typ); err != nil {
+ return err
+ }
+
+ rep := desc.repeated()
+
+ // Read the extension structure, and set it in
+ // the value we're constructing.
+ var ext reflect.Value
+ if !rep {
+ ext = reflect.New(typ).Elem()
+ } else {
+ ext = reflect.New(typ.Elem()).Elem()
+ }
+ if err := p.readAny(ext, props); err != nil {
+ if _, ok := err.(*RequiredNotSetError); !ok {
+ return err
+ }
+ reqFieldErr = err
+ }
+ ep := sv.Addr().Interface().(Message)
+ if !rep {
+ SetExtension(ep, desc, ext.Interface())
+ } else {
+ old, err := GetExtension(ep, desc)
+ var sl reflect.Value
+ if err == nil {
+ sl = reflect.ValueOf(old) // existing slice
+ } else {
+ sl = reflect.MakeSlice(typ, 0, 1)
+ }
+ sl = reflect.Append(sl, ext)
+ SetExtension(ep, desc, sl.Interface())
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ continue
+ }
+
+ // This is a normal, non-extension field.
+ name := tok.value
+ var dst reflect.Value
+ fi, props, ok := structFieldByName(sprops, name)
+ if ok {
+ dst = sv.Field(fi)
+ } else if oop, ok := sprops.OneofTypes[name]; ok {
+ // It is a oneof.
+ props = oop.Prop
+ nv := reflect.New(oop.Type.Elem())
+ dst = nv.Elem().Field(0)
+ sv.Field(oop.Field).Set(nv)
+ }
+ if !dst.IsValid() {
+ return p.errorf("unknown field name %q in %v", name, st)
+ }
+
+ if dst.Kind() == reflect.Map {
+ // Consume any colon.
+ if err := p.checkForColon(props, dst.Type()); err != nil {
+ return err
+ }
+
+ // Construct the map if it doesn't already exist.
+ if dst.IsNil() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ }
+ key := reflect.New(dst.Type().Key()).Elem()
+ val := reflect.New(dst.Type().Elem()).Elem()
+
+ // The map entry should be this sequence of tokens:
+ // < key : KEY value : VALUE >
+ // However, implementations may omit key or value, and technically
+ // we should support them in any order. See b/28924776 for a time
+ // this went wrong.
+
+ tok := p.next()
+ var terminator string
+ switch tok.value {
+ case "<":
+ terminator = ">"
+ case "{":
+ terminator = "}"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ for {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == terminator {
+ break
+ }
+ switch tok.value {
+ case "key":
+ if err := p.consumeToken(":"); err != nil {
+ return err
+ }
+ if err := p.readAny(key, props.mkeyprop); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ case "value":
+ if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
+ return err
+ }
+ if err := p.readAny(val, props.mvalprop); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ default:
+ p.back()
+ return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+ }
+ }
+
+ dst.SetMapIndex(key, val)
+ continue
+ }
+
+ // Check that it's not already set if it's not a repeated field.
+ if !props.Repeated && fieldSet[name] {
+ return p.errorf("non-repeated field %q was repeated", name)
+ }
+
+ if err := p.checkForColon(props, dst.Type()); err != nil {
+ return err
+ }
+
+ // Parse into the field.
+ fieldSet[name] = true
+ if err := p.readAny(dst, props); err != nil {
+ if _, ok := err.(*RequiredNotSetError); !ok {
+ return err
+ }
+ reqFieldErr = err
+ }
+ if props.Required {
+ reqCount--
+ }
+
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+
+ }
+
+ if reqCount > 0 {
+ return p.missingRequiredFieldError(sv)
+ }
+ return reqFieldErr
+}
+
+// consumeExtName consumes extension name or expanded Any type URL and the
+// following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtName() (string, error) {
+ tok := p.next()
+ if tok.err != nil {
+ return "", tok.err
+ }
+
+ // If extension name or type url is quoted, it's a single token.
+ if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+ name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+ if err != nil {
+ return "", err
+ }
+ return name, p.consumeToken("]")
+ }
+
+ // Consume everything up to "]"
+ var parts []string
+ for tok.value != "]" {
+ parts = append(parts, tok.value)
+ tok = p.next()
+ if tok.err != nil {
+ return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+ }
+ }
+ return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in readStruct to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != ";" && tok.value != "," {
+ p.back()
+ }
+ return nil
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == "" {
+ return p.errorf("unexpected EOF")
+ }
+
+ switch fv := v; fv.Kind() {
+ case reflect.Slice:
+ at := v.Type()
+ if at.Elem().Kind() == reflect.Uint8 {
+ // Special case for []byte
+ if tok.value[0] != '"' && tok.value[0] != '\'' {
+ // Deliberately written out here, as the error after
+ // this switch statement would write "invalid []byte: ...",
+ // which is not as user-friendly.
+ return p.errorf("invalid string: %v", tok.value)
+ }
+ bytes := []byte(tok.unquoted)
+ fv.Set(reflect.ValueOf(bytes))
+ return nil
+ }
+ // Repeated field.
+ if tok.value == "[" {
+ // Repeated field with list notation, like [1,2,3].
+ for {
+ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+ err := p.readAny(fv.Index(fv.Len()-1), props)
+ if err != nil {
+ return err
+ }
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == "]" {
+ break
+ }
+ if tok.value != "," {
+ return p.errorf("Expected ']' or ',' found %q", tok.value)
+ }
+ }
+ return nil
+ }
+ // One value of the repeated field.
+ p.back()
+ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+ return p.readAny(fv.Index(fv.Len()-1), props)
+ case reflect.Bool:
+ // Either "true", "false", 1 or 0.
+ switch tok.value {
+ case "true", "1":
+ fv.SetBool(true)
+ return nil
+ case "false", "0":
+ fv.SetBool(false)
+ return nil
+ }
+ case reflect.Float32, reflect.Float64:
+ v := tok.value
+ // Ignore 'f' for compatibility with output generated by C++, but don't
+ // remove 'f' when the value is "-inf" or "inf".
+ if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+ v = v[:len(v)-1]
+ }
+ if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+ fv.SetFloat(f)
+ return nil
+ }
+ case reflect.Int32:
+ if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+ fv.SetInt(x)
+ return nil
+ }
+
+ if len(props.Enum) == 0 {
+ break
+ }
+ m, ok := enumValueMaps[props.Enum]
+ if !ok {
+ break
+ }
+ x, ok := m[tok.value]
+ if !ok {
+ break
+ }
+ fv.SetInt(int64(x))
+ return nil
+ case reflect.Int64:
+ if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+ fv.SetInt(x)
+ return nil
+ }
+
+ case reflect.Ptr:
+ // A basic field (indirected through pointer), or a repeated message/group
+ p.back()
+ fv.Set(reflect.New(fv.Type().Elem()))
+ return p.readAny(fv.Elem(), props)
+ case reflect.String:
+ if tok.value[0] == '"' || tok.value[0] == '\'' {
+ fv.SetString(tok.unquoted)
+ return nil
+ }
+ case reflect.Struct:
+ var terminator string
+ switch tok.value {
+ case "{":
+ terminator = "}"
+ case "<":
+ terminator = ">"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ // TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+ return p.readStruct(fv, terminator)
+ case reflect.Uint32:
+ if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+ fv.SetUint(uint64(x))
+ return nil
+ }
+ case reflect.Uint64:
+ if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+ fv.SetUint(x)
+ return nil
+ }
+ }
+ return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+ if um, ok := pb.(encoding.TextUnmarshaler); ok {
+ err := um.UnmarshalText([]byte(s))
+ return err
+ }
+ pb.Reset()
+ v := reflect.ValueOf(pb)
+ if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil {
+ return pe
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/LICENSE b/vendor/github.com/google/cadvisor/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/google/cadvisor/LICENSE
rename to vendor/github.com/google/cadvisor/LICENSE
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/v1/container.go b/vendor/github.com/google/cadvisor/info/v1/container.go
similarity index 94%
rename from Godeps/_workspace/src/github.com/google/cadvisor/info/v1/container.go
rename to vendor/github.com/google/cadvisor/info/v1/container.go
index bb4fc322e2302a7d5b3514f0cb610423768cf447..21c85bd2a9d0d17155c1e33b7e1175e7ba92658e 100644
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/v1/container.go
+++ b/vendor/github.com/google/cadvisor/info/v1/container.go
@@ -23,6 +23,8 @@ type CpuSpec struct {
Limit uint64 `json:"limit"`
MaxLimit uint64 `json:"max_limit"`
Mask string `json:"mask,omitempty"`
+ Quota uint64 `json:"quota,omitempty"`
+ Period uint64 `json:"period,omitempty"`
}
type MemorySpec struct {
@@ -264,7 +266,7 @@ type LoadStats struct {
// CPU usage time statistics.
type CpuUsage struct {
// Total CPU usage.
- // Units: nanoseconds
+ // Unit: nanoseconds.
Total uint64 `json:"total"`
// Per CPU/core usage of the container.
@@ -272,17 +274,31 @@ type CpuUsage struct {
PerCpu []uint64 `json:"per_cpu_usage,omitempty"`
// Time spent in user space.
- // Unit: nanoseconds
+ // Unit: nanoseconds.
User uint64 `json:"user"`
// Time spent in kernel space.
- // Unit: nanoseconds
+ // Unit: nanoseconds.
System uint64 `json:"system"`
}
+// Cpu Completely Fair Scheduler statistics.
+type CpuCFS struct {
+ // Total number of elapsed enforcement intervals.
+ Periods uint64 `json:"periods"`
+
+ // Total number of times tasks in the cgroup have been throttled.
+ ThrottledPeriods uint64 `json:"throttled_periods"`
+
+ // Total time duration for which tasks in the cgroup have been throttled.
+ // Unit: nanoseconds.
+ ThrottledTime uint64 `json:"throttled_time"`
+}
+
// All CPU usage metrics are cumulative from the creation of the container
type CpuStats struct {
Usage CpuUsage `json:"usage"`
+ CFS CpuCFS `json:"cfs"`
// Smoothed average of number of runnable threads x 1000.
// We multiply by thousand to avoid using floats, but preserving precision.
// Load is smoothed over the last 10 seconds. Instantaneous value can be read
@@ -322,6 +338,10 @@ type MemoryStats struct {
// Units: Bytes.
RSS uint64 `json:"rss"`
+ // The amount of swap currently used by the processes in this cgroup
+ // Units: Bytes.
+ Swap uint64 `json:"swap"`
+
// The amount of working set memory, this includes recently accessed memory,
// dirty memory, and kernel memory. Working set is <= "usage".
// Units: Bytes.
@@ -397,6 +417,9 @@ type FsStats struct {
// The block device name associated with the filesystem.
Device string `json:"device,omitempty"`
+ // Type of the filesytem.
+ Type string `json:"type"`
+
// Number of bytes that can be consumed by the container on this filesystem.
Limit uint64 `json:"capacity"`
@@ -410,6 +433,15 @@ type FsStats struct {
// Number of bytes available for non-root user.
Available uint64 `json:"available"`
+ // HasInodes when true, indicates that Inodes info will be available.
+ HasInodes bool `json:"has_inodes"`
+
+ // Number of Inodes
+ Inodes uint64 `json:"inodes"`
+
+ // Number of available Inodes
+ InodesFree uint64 `json:"inodes_free"`
+
// Number of reads completed
// This is the total number of reads completed successfully.
ReadsCompleted uint64 `json:"reads_completed"`
diff --git a/vendor/github.com/google/cadvisor/info/v1/docker.go b/vendor/github.com/google/cadvisor/info/v1/docker.go
new file mode 100644
index 0000000000000000000000000000000000000000..2703c53424c44cff2f7d1864103f479c1784a577
--- /dev/null
+++ b/vendor/github.com/google/cadvisor/info/v1/docker.go
@@ -0,0 +1,37 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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.
+
+// Types used for docker containers.
+package v1
+
+type DockerStatus struct {
+ Version string `json:"version"`
+ KernelVersion string `json:"kernel_version"`
+ OS string `json:"os"`
+ Hostname string `json:"hostname"`
+ RootDir string `json:"root_dir"`
+ Driver string `json:"driver"`
+ DriverStatus map[string]string `json:"driver_status"`
+ ExecDriver string `json:"exec_driver"`
+ NumImages int `json:"num_images"`
+ NumContainers int `json:"num_containers"`
+}
+
+type DockerImage struct {
+ ID string `json:"id"`
+ RepoTags []string `json:"repo_tags"` // repository name and tags.
+ Created int64 `json:"created"` // unix time since creation.
+ VirtualSize int64 `json:"virtual_size"`
+ Size int64 `json:"size"`
+}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/v1/machine.go b/vendor/github.com/google/cadvisor/info/v1/machine.go
similarity index 87%
rename from Godeps/_workspace/src/github.com/google/cadvisor/info/v1/machine.go
rename to vendor/github.com/google/cadvisor/info/v1/machine.go
index f26291c11254e784b9f6327e89d76af2893a745a..933b6f302043a8c32fb9aeef723f3ee6da7e17dc 100644
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/v1/machine.go
+++ b/vendor/github.com/google/cadvisor/info/v1/machine.go
@@ -20,6 +20,15 @@ type FsInfo struct {
// Total number of bytes available on the filesystem.
Capacity uint64 `json:"capacity"`
+
+ // Type of device.
+ Type string `json:"type"`
+
+ // Total number of inodes available on the filesystem.
+ Inodes uint64 `json:"inodes"`
+
+ // HasInodes when true, indicates that Inodes info will be available.
+ HasInodes bool `json:"has_inodes"`
}
type Node struct {
@@ -115,10 +124,11 @@ type NetInfo struct {
type CloudProvider string
const (
- GCE CloudProvider = "GCE"
- AWS = "AWS"
- Baremetal = "Baremetal"
- UnkownProvider = "Unknown"
+ GCE CloudProvider = "GCE"
+ AWS = "AWS"
+ Azure = "Azure"
+ Baremetal = "Baremetal"
+ UnknownProvider = "Unknown"
)
type InstanceType string
@@ -128,6 +138,12 @@ const (
UnknownInstance = "Unknown"
)
+type InstanceID string
+
+const (
+ UnNamedInstance InstanceID = "None"
+)
+
type MachineInfo struct {
// The number of cores in this machine.
NumCores int `json:"num_cores"`
@@ -165,6 +181,9 @@ type MachineInfo struct {
// Type of cloud instance (e.g. GCE standard) the machine is.
InstanceType InstanceType `json:"instance_type"`
+
+ // ID of cloud instance (e.g. instance-1) given to it by the cloud provider.
+ InstanceID InstanceID `json:"instance_id"`
}
type VersionInfo struct {
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/v1/metric.go b/vendor/github.com/google/cadvisor/info/v1/metric.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/google/cadvisor/info/v1/metric.go
rename to vendor/github.com/google/cadvisor/info/v1/metric.go
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/.travis.yml b/vendor/github.com/google/gofuzz/.travis.yml
similarity index 100%
rename from Godeps/_workspace/src/github.com/google/gofuzz/.travis.yml
rename to vendor/github.com/google/gofuzz/.travis.yml
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/CONTRIBUTING.md b/vendor/github.com/google/gofuzz/CONTRIBUTING.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/google/gofuzz/CONTRIBUTING.md
rename to vendor/github.com/google/gofuzz/CONTRIBUTING.md
diff --git a/Godeps/_workspace/src/github.com/golang/mock/LICENSE b/vendor/github.com/google/gofuzz/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/golang/mock/LICENSE
rename to vendor/github.com/google/gofuzz/LICENSE
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/README.md b/vendor/github.com/google/gofuzz/README.md
similarity index 98%
rename from Godeps/_workspace/src/github.com/google/gofuzz/README.md
rename to vendor/github.com/google/gofuzz/README.md
index 68fcf2cabb298cff2777d2ff8a5546bf9dcd9cba..64869af347a56b736e9d230bff4231aeb62d7f88 100644
--- a/Godeps/_workspace/src/github.com/google/gofuzz/README.md
+++ b/vendor/github.com/google/gofuzz/README.md
@@ -14,21 +14,21 @@ This is useful for testing:
Import with ```import "github.com/google/gofuzz"```
You can use it on single variables:
-```
+```go
f := fuzz.New()
var myInt int
f.Fuzz(&myInt) // myInt gets a random value.
```
You can use it on maps:
-```
+```go
f := fuzz.New().NilChance(0).NumElements(1, 1)
var myMap map[ComplexKeyType]string
f.Fuzz(&myMap) // myMap will have exactly one element.
```
Customize the chance of getting a nil pointer:
-```
+```go
f := fuzz.New().NilChance(.5)
var fancyStruct struct {
A, B, C, D *string
@@ -37,7 +37,7 @@ f.Fuzz(&fancyStruct) // About half the pointers should be set.
```
You can even customize the randomization completely if needed:
-```
+```go
type MyEnum string
const (
A MyEnum = "A"
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/doc.go b/vendor/github.com/google/gofuzz/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/google/gofuzz/doc.go
rename to vendor/github.com/google/gofuzz/doc.go
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/fuzz.go b/vendor/github.com/google/gofuzz/fuzz.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/google/gofuzz/fuzz.go
rename to vendor/github.com/google/gofuzz/fuzz.go
index 42d9a48b3e2b7ba5a6b57c6a90c39c34d9188c7b..b3e4e6f8324d28f6dea426e24eef2c5e2bba5a6d 100644
--- a/Godeps/_workspace/src/github.com/google/gofuzz/fuzz.go
+++ b/vendor/github.com/google/gofuzz/fuzz.go
@@ -229,12 +229,19 @@ func (f *Fuzzer) doFuzz(v reflect.Value, flags uint64) {
return
}
v.Set(reflect.Zero(v.Type()))
+ case reflect.Array:
+ if f.genShouldFill() {
+ n := v.Len()
+ for i := 0; i < n; i++ {
+ f.doFuzz(v.Index(i), 0)
+ }
+ return
+ }
+ v.Set(reflect.Zero(v.Type()))
case reflect.Struct:
for i := 0; i < v.NumField(); i++ {
f.doFuzz(v.Field(i), 0)
}
- case reflect.Array:
- fallthrough
case reflect.Chan:
fallthrough
case reflect.Func:
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/mousetrap/LICENSE b/vendor/github.com/inconshreveable/mousetrap/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/inconshreveable/mousetrap/LICENSE
rename to vendor/github.com/inconshreveable/mousetrap/LICENSE
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/mousetrap/README.md b/vendor/github.com/inconshreveable/mousetrap/README.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/inconshreveable/mousetrap/README.md
rename to vendor/github.com/inconshreveable/mousetrap/README.md
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_others.go b/vendor/github.com/inconshreveable/mousetrap/trap_others.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_others.go
rename to vendor/github.com/inconshreveable/mousetrap/trap_others.go
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_windows.go b/vendor/github.com/inconshreveable/mousetrap/trap_windows.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_windows.go
rename to vendor/github.com/inconshreveable/mousetrap/trap_windows.go
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_windows_1.4.go b/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
rename to vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore b/vendor/github.com/jonboulle/clockwork/.gitignore
similarity index 95%
rename from Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
rename to vendor/github.com/jonboulle/clockwork/.gitignore
index 36d1a84d392e08d582b1f94b090dc5be1ce07deb..010c242bd8a9865d808ec05c653f8575e4faa2a3 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
+++ b/vendor/github.com/jonboulle/clockwork/.gitignore
@@ -20,5 +20,6 @@ _cgo_export.*
_testmain.go
*.exe
+*.test
-cobra.test
+*.swp
diff --git a/vendor/github.com/jonboulle/clockwork/.travis.yml b/vendor/github.com/jonboulle/clockwork/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..aefda90bfa811b436a985206be753bb55874d1c5
--- /dev/null
+++ b/vendor/github.com/jonboulle/clockwork/.travis.yml
@@ -0,0 +1,5 @@
+language: go
+go:
+ - 1.3
+
+sudo: false
diff --git a/vendor/github.com/jonboulle/clockwork/LICENSE b/vendor/github.com/jonboulle/clockwork/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..5c304d1a4a7b439f767990bf1360d3283e45d0ee
--- /dev/null
+++ b/vendor/github.com/jonboulle/clockwork/LICENSE
@@ -0,0 +1,201 @@
+Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/jonboulle/clockwork/README.md b/vendor/github.com/jonboulle/clockwork/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d43a6c799a0c86a2cc436807273d53afce417635
--- /dev/null
+++ b/vendor/github.com/jonboulle/clockwork/README.md
@@ -0,0 +1,61 @@
+clockwork
+=========
+
+[](https://travis-ci.org/jonboulle/clockwork)
+[](http://godoc.org/github.com/jonboulle/clockwork)
+
+a simple fake clock for golang
+
+# Usage
+
+Replace uses of the `time` package with the `clockwork.Clock` interface instead.
+
+For example, instead of using `time.Sleep` directly:
+
+```
+func my_func() {
+ time.Sleep(3 * time.Second)
+ do_something()
+}
+```
+
+inject a clock and use its `Sleep` method instead:
+
+```
+func my_func(clock clockwork.Clock) {
+ clock.Sleep(3 * time.Second)
+ do_something()
+}
+```
+
+Now you can easily test `my_func` with a `FakeClock`:
+
+```
+func TestMyFunc(t *testing.T) {
+ c := clockwork.NewFakeClock()
+
+ // Start our sleepy function
+ my_func(c)
+
+ // Ensure we wait until my_func is sleeping
+ c.BlockUntil(1)
+
+ assert_state()
+
+ // Advance the FakeClock forward in time
+ c.Advance(3)
+
+ assert_state()
+}
+```
+
+and in production builds, simply inject the real clock instead:
+```
+my_func(clockwork.NewRealClock())
+```
+
+See [example_test.go](example_test.go) for a full example.
+
+# Credits
+
+clockwork is inspired by @wickman's [threaded fake clock](https://gist.github.com/wickman/3840816), and the [Golang playground](http://blog.golang.org/playground#Faking time)
diff --git a/vendor/github.com/jonboulle/clockwork/clockwork.go b/vendor/github.com/jonboulle/clockwork/clockwork.go
new file mode 100644
index 0000000000000000000000000000000000000000..999fddd51a4c395fa41637740f32275dd2fa435c
--- /dev/null
+++ b/vendor/github.com/jonboulle/clockwork/clockwork.go
@@ -0,0 +1,179 @@
+package clockwork
+
+import (
+ "sync"
+ "time"
+)
+
+// Clock provides an interface that packages can use instead of directly
+// using the time module, so that chronology-related behavior can be tested
+type Clock interface {
+ After(d time.Duration) <-chan time.Time
+ Sleep(d time.Duration)
+ Now() time.Time
+ Since(t time.Time) time.Duration
+}
+
+// FakeClock provides an interface for a clock which can be
+// manually advanced through time
+type FakeClock interface {
+ Clock
+ // Advance advances the FakeClock to a new point in time, ensuring any existing
+ // sleepers are notified appropriately before returning
+ Advance(d time.Duration)
+ // BlockUntil will block until the FakeClock has the given number of
+ // sleepers (callers of Sleep or After)
+ BlockUntil(n int)
+}
+
+// NewRealClock returns a Clock which simply delegates calls to the actual time
+// package; it should be used by packages in production.
+func NewRealClock() Clock {
+ return &realClock{}
+}
+
+// NewFakeClock returns a FakeClock implementation which can be
+// manually advanced through time for testing. The initial time of the
+// FakeClock will be an arbitrary non-zero time.
+func NewFakeClock() FakeClock {
+ // use a fixture that does not fulfill Time.IsZero()
+ return NewFakeClockAt(time.Date(1984, time.April, 4, 0, 0, 0, 0, time.UTC))
+}
+
+// NewFakeClockAt returns a FakeClock initialised at the given time.Time.
+func NewFakeClockAt(t time.Time) FakeClock {
+ return &fakeClock{
+ time: t,
+ }
+}
+
+type realClock struct{}
+
+func (rc *realClock) After(d time.Duration) <-chan time.Time {
+ return time.After(d)
+}
+
+func (rc *realClock) Sleep(d time.Duration) {
+ time.Sleep(d)
+}
+
+func (rc *realClock) Now() time.Time {
+ return time.Now()
+}
+
+func (rc *realClock) Since(t time.Time) time.Duration {
+ return rc.Now().Sub(t)
+}
+
+type fakeClock struct {
+ sleepers []*sleeper
+ blockers []*blocker
+ time time.Time
+
+ l sync.RWMutex
+}
+
+// sleeper represents a caller of After or Sleep
+type sleeper struct {
+ until time.Time
+ done chan time.Time
+}
+
+// blocker represents a caller of BlockUntil
+type blocker struct {
+ count int
+ ch chan struct{}
+}
+
+// After mimics time.After; it waits for the given duration to elapse on the
+// fakeClock, then sends the current time on the returned channel.
+func (fc *fakeClock) After(d time.Duration) <-chan time.Time {
+ fc.l.Lock()
+ defer fc.l.Unlock()
+ now := fc.time
+ done := make(chan time.Time, 1)
+ if d.Nanoseconds() == 0 {
+ // special case - trigger immediately
+ done <- now
+ } else {
+ // otherwise, add to the set of sleepers
+ s := &sleeper{
+ until: now.Add(d),
+ done: done,
+ }
+ fc.sleepers = append(fc.sleepers, s)
+ // and notify any blockers
+ fc.blockers = notifyBlockers(fc.blockers, len(fc.sleepers))
+ }
+ return done
+}
+
+// notifyBlockers notifies all the blockers waiting until the
+// given number of sleepers are waiting on the fakeClock. It
+// returns an updated slice of blockers (i.e. those still waiting)
+func notifyBlockers(blockers []*blocker, count int) (newBlockers []*blocker) {
+ for _, b := range blockers {
+ if b.count == count {
+ close(b.ch)
+ } else {
+ newBlockers = append(newBlockers, b)
+ }
+ }
+ return
+}
+
+// Sleep blocks until the given duration has passed on the fakeClock
+func (fc *fakeClock) Sleep(d time.Duration) {
+ <-fc.After(d)
+}
+
+// Time returns the current time of the fakeClock
+func (fc *fakeClock) Now() time.Time {
+ fc.l.RLock()
+ t := fc.time
+ fc.l.RUnlock()
+ return t
+}
+
+// Since returns the duration that has passed since the given time on the fakeClock
+func (fc *fakeClock) Since(t time.Time) time.Duration {
+ return fc.Now().Sub(t)
+}
+
+// Advance advances fakeClock to a new point in time, ensuring channels from any
+// previous invocations of After are notified appropriately before returning
+func (fc *fakeClock) Advance(d time.Duration) {
+ fc.l.Lock()
+ defer fc.l.Unlock()
+ end := fc.time.Add(d)
+ var newSleepers []*sleeper
+ for _, s := range fc.sleepers {
+ if end.Sub(s.until) >= 0 {
+ s.done <- end
+ } else {
+ newSleepers = append(newSleepers, s)
+ }
+ }
+ fc.sleepers = newSleepers
+ fc.blockers = notifyBlockers(fc.blockers, len(fc.sleepers))
+ fc.time = end
+}
+
+// BlockUntil will block until the fakeClock has the given number of sleepers
+// (callers of Sleep or After)
+func (fc *fakeClock) BlockUntil(n int) {
+ fc.l.Lock()
+ // Fast path: current number of sleepers is what we're looking for
+ if len(fc.sleepers) == n {
+ fc.l.Unlock()
+ return
+ }
+ // Otherwise, set up a new blocker
+ b := &blocker{
+ count: n,
+ ch: make(chan struct{}),
+ }
+ fc.blockers = append(fc.blockers, b)
+ fc.l.Unlock()
+ <-b.ch
+}
diff --git a/Godeps/_workspace/src/github.com/juju/ratelimit/LICENSE b/vendor/github.com/juju/ratelimit/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/juju/ratelimit/LICENSE
rename to vendor/github.com/juju/ratelimit/LICENSE
diff --git a/Godeps/_workspace/src/github.com/juju/ratelimit/README.md b/vendor/github.com/juju/ratelimit/README.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/juju/ratelimit/README.md
rename to vendor/github.com/juju/ratelimit/README.md
diff --git a/Godeps/_workspace/src/github.com/juju/ratelimit/ratelimit.go b/vendor/github.com/juju/ratelimit/ratelimit.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/juju/ratelimit/ratelimit.go
rename to vendor/github.com/juju/ratelimit/ratelimit.go
diff --git a/Godeps/_workspace/src/github.com/juju/ratelimit/reader.go b/vendor/github.com/juju/ratelimit/reader.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/juju/ratelimit/reader.go
rename to vendor/github.com/juju/ratelimit/reader.go
diff --git a/vendor/github.com/matttproud/golang_protobuf_extensions/LICENSE b/vendor/github.com/matttproud/golang_protobuf_extensions/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..8dada3edaf50dbc082c9a125058f25def75e625a
--- /dev/null
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE b/vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..5d8cb5b72e730c77fe7a890cbb269282caaae34e
--- /dev/null
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE
@@ -0,0 +1 @@
+Copyright 2012 Matt T. Proud (matt.proud@gmail.com)
diff --git a/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/.gitignore b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e16fb946bb9bb3a2d5ad2442ffa1469d28ef066c
--- /dev/null
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/.gitignore
@@ -0,0 +1 @@
+cover.dat
diff --git a/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/Makefile b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..81be214370d433d0aef7881d46c0264b5880fa60
--- /dev/null
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/Makefile
@@ -0,0 +1,7 @@
+all:
+
+cover:
+ go test -cover -v -coverprofile=cover.dat ./...
+ go tool cover -func cover.dat
+
+.PHONY: cover
diff --git a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go
rename to vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go
index 66d9b5458f8ea3dceb8e62e0f6b603f49379d3fb..258c0636aac8c50be39cca1364c2357cbda33327 100644
--- a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/decode.go
@@ -38,7 +38,7 @@ var errInvalidVarint = errors.New("invalid varint32 encountered")
func ReadDelimited(r io.Reader, m proto.Message) (n int, err error) {
// Per AbstractParser#parsePartialDelimitedFrom with
// CodedInputStream#readRawVarint32.
- headerBuf := make([]byte, binary.MaxVarintLen32)
+ var headerBuf [binary.MaxVarintLen32]byte
var bytesRead, varIntBytes int
var messageLength uint64
for varIntBytes == 0 { // i.e. no varint has been decoded yet.
diff --git a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go
rename to vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go
diff --git a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go
similarity index 92%
rename from Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go
rename to vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go
index 4b76ea9a1d8a1d8e5c8bb7e89b000b21316d1b2c..8fb59ad226ff0962630d2539bd4d3ae9a53ea58c 100644
--- a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go
+++ b/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/encode.go
@@ -33,8 +33,8 @@ func WriteDelimited(w io.Writer, m proto.Message) (n int, err error) {
return 0, err
}
- buf := make([]byte, binary.MaxVarintLen32)
- encodedLength := binary.PutUvarint(buf, uint64(len(buffer)))
+ var buf [binary.MaxVarintLen32]byte
+ encodedLength := binary.PutUvarint(buf[:], uint64(len(buffer)))
sync, err := w.Write(buf[:encodedLength])
if err != nil {
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/cgroups_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/cgroups_unsupported.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups_unsupported.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/apply_raw.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/apply_raw.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/apply_raw.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/apply_raw.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/blkio.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/blkio.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/blkio.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/blkio.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuacct.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuacct.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuacct.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuacct.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/freezer.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/freezer.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/freezer.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/freezer.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs_unsupported.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs_unsupported.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/hugetlb.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/hugetlb.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/hugetlb.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/hugetlb.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/memory.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/memory.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/memory.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/memory.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/name.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/name.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/name.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/name.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_cls.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_cls.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_cls.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_cls.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_prio.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_prio.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_prio.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/net_prio.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/perf_event.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/perf_event.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/perf_event.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/perf_event.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/pids.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/pids.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/pids.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/pids.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/utils.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/utils.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/fs/utils.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/utils.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/stats.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/utils.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
rename to vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unix.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_unix.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unix.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_windows.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_windows.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/cgroup_windows.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_windows.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/config.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/config.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/config.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/config.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/config_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/config_unix.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/config_unix.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/config_unix.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/device.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/device.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/device.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/device.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/device_defaults.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/device_defaults.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/device_defaults.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/device_defaults.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/hugepage_limit.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/hugepage_limit.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/hugepage_limit.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/hugepage_limit.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/interface_priority_map.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/interface_priority_map.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/interface_priority_map.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/interface_priority_map.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/mount.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/mount.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unix.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_unix.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unix.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/network.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/network.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/configs/network.go
rename to vendor/github.com/opencontainers/runc/libcontainer/configs/network.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/linux.go b/vendor/github.com/opencontainers/runc/libcontainer/system/linux.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/linux.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/linux.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/proc.go b/vendor/github.com/opencontainers/runc/libcontainer/system/proc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/proc.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/proc.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/setns_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/system/setns_linux.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/setns_linux.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/setns_linux.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_386.go b/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_386.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_386.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_386.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go b/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_arm.go b/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_arm.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/syscall_linux_arm.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_arm.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/sysconfig.go b/vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/sysconfig.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/sysconfig_notcgo.go b/vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig_notcgo.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/sysconfig_notcgo.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig_notcgo.go
diff --git a/Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/xattrs_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/system/xattrs_linux.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/opencontainers/runc/libcontainer/system/xattrs_linux.go
rename to vendor/github.com/opencontainers/runc/libcontainer/system/xattrs_linux.go
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml b/vendor/github.com/pborman/uuid/.travis.yml
similarity index 55%
rename from Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
rename to vendor/github.com/pborman/uuid/.travis.yml
index 7a6cb7fdbe443e65c50f663d6eb5fb1a8e0abcaa..a6a98db8a3f3043e688463b1ebc27b8e2c39562b 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
+++ b/vendor/github.com/pborman/uuid/.travis.yml
@@ -1,9 +1,10 @@
language: go
+
go:
- - 1.3.3
- - 1.4.2
- - 1.5.1
+ - 1.4.3
+ - 1.5.3
+ - release
- tip
+
script:
- go test -v ./...
- - go build
diff --git a/vendor/github.com/pborman/uuid/CONTRIBUTING.md b/vendor/github.com/pborman/uuid/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..04fdf09f136bbbb8687d537c1e5967800c0177a8
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/CONTRIBUTING.md
@@ -0,0 +1,10 @@
+# How to contribute
+
+We definitely welcome patches and contribution to this project!
+
+### Legal requirements
+
+In order to protect both you and ourselves, you will need to sign the
+[Contributor License Agreement](https://cla.developers.google.com/clas).
+
+You may have already signed it for other Google projects.
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/CONTRIBUTORS b/vendor/github.com/pborman/uuid/CONTRIBUTORS
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/CONTRIBUTORS
rename to vendor/github.com/pborman/uuid/CONTRIBUTORS
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/LICENSE b/vendor/github.com/pborman/uuid/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/LICENSE
rename to vendor/github.com/pborman/uuid/LICENSE
diff --git a/vendor/github.com/pborman/uuid/README.md b/vendor/github.com/pborman/uuid/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f023d47ca80a10644145460044fd9386d010e1f8
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/README.md
@@ -0,0 +1,13 @@
+This project was automatically exported from code.google.com/p/go-uuid
+
+# uuid 
+The uuid package generates and inspects UUIDs based on [RFC 412](http://tools.ietf.org/html/rfc4122) and DCE 1.1: Authentication and Security Services.
+
+###### Install
+`go get github.com/pborman/uuid`
+
+###### Documentation
+[](http://godoc.org/github.com/pborman/uuid)
+
+Full `go doc` style documentation for the package can be viewed online without installing this package by using the GoDoc site here:
+http://godoc.org/github.com/pborman/uuid
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/dce.go b/vendor/github.com/pborman/uuid/dce.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/dce.go
rename to vendor/github.com/pborman/uuid/dce.go
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/doc.go b/vendor/github.com/pborman/uuid/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/doc.go
rename to vendor/github.com/pborman/uuid/doc.go
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/hash.go b/vendor/github.com/pborman/uuid/hash.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/pborman/uuid/hash.go
rename to vendor/github.com/pborman/uuid/hash.go
index cdd4192fd9b9dc0346e828ad6de9f8b8c5b476eb..a0420c1ef3a9e75a841a0211a9c67b15c64573ef 100644
--- a/Godeps/_workspace/src/github.com/pborman/uuid/hash.go
+++ b/vendor/github.com/pborman/uuid/hash.go
@@ -19,7 +19,7 @@ var (
NIL = Parse("00000000-0000-0000-0000-000000000000")
)
-// NewHash returns a new UUID dervied from the hash of space concatenated with
+// NewHash returns a new UUID derived from the hash of space concatenated with
// data generated by h. The hash should be at least 16 byte in length. The
// first 16 bytes of the hash are used to form the UUID. The version of the
// UUID will be the lower 4 bits of version. NewHash is used to implement
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/json.go b/vendor/github.com/pborman/uuid/json.go
similarity index 75%
rename from Godeps/_workspace/src/github.com/pborman/uuid/json.go
rename to vendor/github.com/pborman/uuid/json.go
index 760580a504f4e06df4934e2259466b950fc92605..9dda1dfba97c41f355651ced68a21e1f7d86064c 100644
--- a/Godeps/_workspace/src/github.com/pborman/uuid/json.go
+++ b/vendor/github.com/pborman/uuid/json.go
@@ -7,17 +7,21 @@ package uuid
import "errors"
func (u UUID) MarshalJSON() ([]byte, error) {
- if len(u) == 0 {
+ if len(u) != 16 {
return []byte(`""`), nil
}
- return []byte(`"` + u.String() + `"`), nil
+ var js [38]byte
+ js[0] = '"'
+ encodeHex(js[1:], u)
+ js[37] = '"'
+ return js[:], nil
}
func (u *UUID) UnmarshalJSON(data []byte) error {
- if len(data) == 0 || string(data) == `""` {
+ if string(data) == `""` {
return nil
}
- if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+ if data[0] != '"' {
return errors.New("invalid UUID format")
}
data = data[1 : len(data)-1]
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/node.go b/vendor/github.com/pborman/uuid/node.go
similarity index 89%
rename from Godeps/_workspace/src/github.com/pborman/uuid/node.go
rename to vendor/github.com/pborman/uuid/node.go
index dd0a8ac189a30f2b5473de07332f35658e163409..42d60da8f10f841eccba705dade8c57194a69db0 100755
--- a/Godeps/_workspace/src/github.com/pborman/uuid/node.go
+++ b/vendor/github.com/pborman/uuid/node.go
@@ -4,9 +4,13 @@
package uuid
-import "net"
+import (
+ "net"
+ "sync"
+)
var (
+ nodeMu sync.Mutex
interfaces []net.Interface // cached list of interfaces
ifname string // name of interface being used
nodeID []byte // hardware for version 1 UUIDs
@@ -16,6 +20,8 @@ var (
// derived. The interface "user" is returned if the NodeID was set by
// SetNodeID.
func NodeInterface() string {
+ defer nodeMu.Unlock()
+ nodeMu.Lock()
return ifname
}
@@ -26,6 +32,12 @@ func NodeInterface() string {
//
// SetNodeInterface never fails when name is "".
func SetNodeInterface(name string) bool {
+ defer nodeMu.Unlock()
+ nodeMu.Lock()
+ return setNodeInterface(name)
+}
+
+func setNodeInterface(name string) bool {
if interfaces == nil {
var err error
interfaces, err = net.Interfaces()
@@ -59,8 +71,10 @@ func SetNodeInterface(name string) bool {
// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
// if not already set.
func NodeID() []byte {
+ defer nodeMu.Unlock()
+ nodeMu.Lock()
if nodeID == nil {
- SetNodeInterface("")
+ setNodeInterface("")
}
nid := make([]byte, 6)
copy(nid, nodeID)
@@ -71,6 +85,8 @@ func NodeID() []byte {
// of id are used. If id is less than 6 bytes then false is returned and the
// Node ID is not set.
func SetNodeID(id []byte) bool {
+ defer nodeMu.Unlock()
+ nodeMu.Lock()
if setNodeID(id) {
ifname = "user"
return true
diff --git a/vendor/github.com/pborman/uuid/sql.go b/vendor/github.com/pborman/uuid/sql.go
new file mode 100644
index 0000000000000000000000000000000000000000..d015bfd1327832d47e16a5996bbed60e93d15486
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/sql.go
@@ -0,0 +1,66 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+ "database/sql/driver"
+ "errors"
+ "fmt"
+)
+
+// Scan implements sql.Scanner so UUIDs can be read from databases transparently
+// Currently, database types that map to string and []byte are supported. Please
+// consult database-specific driver documentation for matching types.
+func (uuid *UUID) Scan(src interface{}) error {
+ switch src.(type) {
+ case string:
+ // if an empty UUID comes from a table, we return a null UUID
+ if src.(string) == "" {
+ return nil
+ }
+
+ // see uuid.Parse for required string format
+ parsed := Parse(src.(string))
+
+ if parsed == nil {
+ return errors.New("Scan: invalid UUID format")
+ }
+
+ *uuid = parsed
+ case []byte:
+ b := src.([]byte)
+
+ // if an empty UUID comes from a table, we return a null UUID
+ if len(b) == 0 {
+ return nil
+ }
+
+ // assumes a simple slice of bytes if 16 bytes
+ // otherwise attempts to parse
+ if len(b) == 16 {
+ *uuid = UUID(b)
+ } else {
+ u := Parse(string(b))
+
+ if u == nil {
+ return errors.New("Scan: invalid UUID format")
+ }
+
+ *uuid = u
+ }
+
+ default:
+ return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
+ }
+
+ return nil
+}
+
+// Value implements sql.Valuer so that UUIDs can be written to databases
+// transparently. Currently, UUIDs map to strings. Please consult
+// database-specific driver documentation for matching types.
+func (uuid UUID) Value() (driver.Value, error) {
+ return uuid.String(), nil
+}
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/time.go b/vendor/github.com/pborman/uuid/time.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/pborman/uuid/time.go
rename to vendor/github.com/pborman/uuid/time.go
index 7ebc9bef109067a2e969eacc8d38cb3262b3299a..eedf242194b2cfd1b8e3e9c5e43e09d4eb2cd0a7 100755
--- a/Godeps/_workspace/src/github.com/pborman/uuid/time.go
+++ b/vendor/github.com/pborman/uuid/time.go
@@ -23,7 +23,7 @@ const (
)
var (
- mu sync.Mutex
+ timeMu sync.Mutex
lasttime uint64 // last time we returned
clock_seq uint16 // clock sequence for this run
@@ -43,8 +43,8 @@ func (t Time) UnixTime() (sec, nsec int64) {
// clock sequence as well as adjusting the clock sequence as needed. An error
// is returned if the current time cannot be determined.
func GetTime() (Time, uint16, error) {
- defer mu.Unlock()
- mu.Lock()
+ defer timeMu.Unlock()
+ timeMu.Lock()
return getTime()
}
@@ -75,8 +75,8 @@ func getTime() (Time, uint16, error) {
// ClockSequence, GetTime, or NewUUID. (section 4.2.1.1) sequence is generated
// for
func ClockSequence() int {
- defer mu.Unlock()
- mu.Lock()
+ defer timeMu.Unlock()
+ timeMu.Lock()
return clockSequence()
}
@@ -90,8 +90,8 @@ func clockSequence() int {
// SetClockSeq sets the clock sequence to the lower 14 bits of seq. Setting to
// -1 causes a new sequence to be generated.
func SetClockSequence(seq int) {
- defer mu.Unlock()
- mu.Lock()
+ defer timeMu.Unlock()
+ timeMu.Lock()
setClockSequence(seq)
}
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/util.go b/vendor/github.com/pborman/uuid/util.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/pborman/uuid/util.go
rename to vendor/github.com/pborman/uuid/util.go
index de40b102c4bedd187b364c8cad7a2fe0a1f6cafc..fc8e052c7a6b0ed85fa94d5c7a0d73ab4deab356 100644
--- a/Godeps/_workspace/src/github.com/pborman/uuid/util.go
+++ b/vendor/github.com/pborman/uuid/util.go
@@ -16,7 +16,7 @@ func randomBits(b []byte) {
}
// xvalues returns the value of a byte as a hexadecimal digit or 255.
-var xvalues = []byte{
+var xvalues = [256]byte{
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/uuid.go b/vendor/github.com/pborman/uuid/uuid.go
old mode 100755
new mode 100644
similarity index 73%
rename from Godeps/_workspace/src/github.com/pborman/uuid/uuid.go
rename to vendor/github.com/pborman/uuid/uuid.go
index 2920fae632671d9827f4d445c1046415197857aa..82c9e7ee7be2048e91a6a36a9f008ddc23525c03
--- a/Godeps/_workspace/src/github.com/pborman/uuid/uuid.go
+++ b/vendor/github.com/pborman/uuid/uuid.go
@@ -7,11 +7,26 @@ package uuid
import (
"bytes"
"crypto/rand"
+ "encoding/hex"
"fmt"
"io"
"strings"
)
+// Array is a pass-by-value UUID that can be used as an effecient key in a map.
+type Array [16]byte
+
+// UUID converts uuid into a slice.
+func (uuid Array) UUID() UUID {
+ return uuid[:]
+}
+
+// String returns the string representation of uuid,
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (uuid Array) String() string {
+ return uuid.UUID().String()
+}
+
// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
// 4122.
type UUID []byte
@@ -54,8 +69,8 @@ func Parse(s string) UUID {
if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
return nil
}
- uuid := make([]byte, 16)
- for i, x := range []int{
+ var uuid [16]byte
+ for i, x := range [16]int{
0, 2, 4, 6,
9, 11,
14, 16,
@@ -67,7 +82,7 @@ func Parse(s string) UUID {
uuid[i] = v
}
}
- return uuid
+ return uuid[:]
}
// Equal returns true if uuid1 and uuid2 are equal.
@@ -75,26 +90,50 @@ func Equal(uuid1, uuid2 UUID) bool {
return bytes.Equal(uuid1, uuid2)
}
+// Array returns an array representation of uuid that can be used as a map key.
+// Array panics if uuid is not valid.
+func (uuid UUID) Array() Array {
+ if len(uuid) != 16 {
+ panic("invalid uuid")
+ }
+ var a Array
+ copy(a[:], uuid)
+ return a
+}
+
// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
// , or "" if uuid is invalid.
func (uuid UUID) String() string {
- if uuid == nil || len(uuid) != 16 {
+ if len(uuid) != 16 {
return ""
}
- b := []byte(uuid)
- return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
- b[:4], b[4:6], b[6:8], b[8:10], b[10:])
+ var buf [36]byte
+ encodeHex(buf[:], uuid)
+ return string(buf[:])
}
// URN returns the RFC 2141 URN form of uuid,
// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, or "" if uuid is invalid.
func (uuid UUID) URN() string {
- if uuid == nil || len(uuid) != 16 {
+ if len(uuid) != 16 {
return ""
}
- b := []byte(uuid)
- return fmt.Sprintf("urn:uuid:%08x-%04x-%04x-%04x-%012x",
- b[:4], b[4:6], b[6:8], b[8:10], b[10:])
+ var buf [36 + 9]byte
+ copy(buf[:], "urn:uuid:")
+ encodeHex(buf[9:], uuid)
+ return string(buf[:])
+}
+
+func encodeHex(dst []byte, uuid UUID) {
+ hex.Encode(dst[:], uuid[:4])
+ dst[8] = '-'
+ hex.Encode(dst[9:13], uuid[4:6])
+ dst[13] = '-'
+ hex.Encode(dst[14:18], uuid[6:8])
+ dst[18] = '-'
+ hex.Encode(dst[19:23], uuid[8:10])
+ dst[23] = '-'
+ hex.Encode(dst[24:], uuid[10:])
}
// Variant returns the variant encoded in uuid. It returns Invalid if
@@ -113,10 +152,9 @@ func (uuid UUID) Variant() Variant {
default:
return Reserved
}
- panic("unreachable")
}
-// Version returns the verison of uuid. It returns false if uuid is not
+// Version returns the version of uuid. It returns false if uuid is not
// valid.
func (uuid UUID) Version() (Version, bool) {
if len(uuid) != 16 {
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/version1.go b/vendor/github.com/pborman/uuid/version1.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/version1.go
rename to vendor/github.com/pborman/uuid/version1.go
diff --git a/Godeps/_workspace/src/github.com/pborman/uuid/version4.go b/vendor/github.com/pborman/uuid/version4.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/pborman/uuid/version4.go
rename to vendor/github.com/pborman/uuid/version4.go
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/LICENSE b/vendor/github.com/prometheus/client_golang/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/LICENSE
rename to vendor/github.com/prometheus/client_golang/LICENSE
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/NOTICE b/vendor/github.com/prometheus/client_golang/NOTICE
similarity index 86%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/NOTICE
rename to vendor/github.com/prometheus/client_golang/NOTICE
index 37e4a7d410e5e55f648c53c005b49c6b0bdc3031..dd878a30ee9a67104c21dc626c30ae2f827277ac 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/NOTICE
+++ b/vendor/github.com/prometheus/client_golang/NOTICE
@@ -7,11 +7,6 @@ SoundCloud Ltd. (http://soundcloud.com/).
The following components are included in this product:
-goautoneg
-http://bitbucket.org/ww/goautoneg
-Copyright 2011, Open Knowledge Foundation Ltd.
-See README.txt for license details.
-
perks - a fork of https://github.com/bmizerany/perks
https://github.com/beorn7/perks
Copyright 2013-2015 Blake Mizerany, Björn Rabenstein
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/.gitignore b/vendor/github.com/prometheus/client_golang/prometheus/.gitignore
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/.gitignore
rename to vendor/github.com/prometheus/client_golang/prometheus/.gitignore
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/README.md b/vendor/github.com/prometheus/client_golang/prometheus/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..44986bff06bada4bac884138d5d362c72c926b51
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/README.md
@@ -0,0 +1 @@
+See [](https://godoc.org/github.com/prometheus/client_golang/prometheus).
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/collector.go b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
similarity index 52%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/collector.go
rename to vendor/github.com/prometheus/client_golang/prometheus/collector.go
index c04688009f508314fcdbdecdfb5169852a33a625..623d3d83fefc849444c4efcb18c4db7a27f8affa 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/collector.go
@@ -15,15 +15,15 @@ package prometheus
// Collector is the interface implemented by anything that can be used by
// Prometheus to collect metrics. A Collector has to be registered for
-// collection. See Register, MustRegister, RegisterOrGet, and MustRegisterOrGet.
+// collection. See Registerer.Register.
//
-// The stock metrics provided by this package (like Gauge, Counter, Summary) are
-// also Collectors (which only ever collect one metric, namely itself). An
-// implementer of Collector may, however, collect multiple metrics in a
-// coordinated fashion and/or create metrics on the fly. Examples for collectors
-// already implemented in this library are the metric vectors (i.e. collection
-// of multiple instances of the same Metric but with different label values)
-// like GaugeVec or SummaryVec, and the ExpvarCollector.
+// The stock metrics provided by this package (Gauge, Counter, Summary,
+// Histogram, Untyped) are also Collectors (which only ever collect one metric,
+// namely itself). An implementer of Collector may, however, collect multiple
+// metrics in a coordinated fashion and/or create metrics on the fly. Examples
+// for collectors already implemented in this library are the metric vectors
+// (i.e. collection of multiple instances of the same Metric but with different
+// label values) like GaugeVec or SummaryVec, and the ExpvarCollector.
type Collector interface {
// Describe sends the super-set of all possible descriptors of metrics
// collected by this Collector to the provided channel and returns once
@@ -37,39 +37,39 @@ type Collector interface {
// executing this method, it must send an invalid descriptor (created
// with NewInvalidDesc) to signal the error to the registry.
Describe(chan<- *Desc)
- // Collect is called by Prometheus when collecting metrics. The
- // implementation sends each collected metric via the provided channel
- // and returns once the last metric has been sent. The descriptor of
- // each sent metric is one of those returned by Describe. Returned
- // metrics that share the same descriptor must differ in their variable
- // label values. This method may be called concurrently and must
- // therefore be implemented in a concurrency safe way. Blocking occurs
- // at the expense of total performance of rendering all registered
- // metrics. Ideally, Collector implementations support concurrent
- // readers.
+ // Collect is called by the Prometheus registry when collecting
+ // metrics. The implementation sends each collected metric via the
+ // provided channel and returns once the last metric has been sent. The
+ // descriptor of each sent metric is one of those returned by
+ // Describe. Returned metrics that share the same descriptor must differ
+ // in their variable label values. This method may be called
+ // concurrently and must therefore be implemented in a concurrency safe
+ // way. Blocking occurs at the expense of total performance of rendering
+ // all registered metrics. Ideally, Collector implementations support
+ // concurrent readers.
Collect(chan<- Metric)
}
-// SelfCollector implements Collector for a single Metric so that that the
-// Metric collects itself. Add it as an anonymous field to a struct that
-// implements Metric, and call Init with the Metric itself as an argument.
-type SelfCollector struct {
+// selfCollector implements Collector for a single Metric so that the Metric
+// collects itself. Add it as an anonymous field to a struct that implements
+// Metric, and call init with the Metric itself as an argument.
+type selfCollector struct {
self Metric
}
-// Init provides the SelfCollector with a reference to the metric it is supposed
+// init provides the selfCollector with a reference to the metric it is supposed
// to collect. It is usually called within the factory function to create a
// metric. See example.
-func (c *SelfCollector) Init(self Metric) {
+func (c *selfCollector) init(self Metric) {
c.self = self
}
// Describe implements Collector.
-func (c *SelfCollector) Describe(ch chan<- *Desc) {
+func (c *selfCollector) Describe(ch chan<- *Desc) {
ch <- c.self.Desc()
}
// Collect implements Collector.
-func (c *SelfCollector) Collect(ch chan<- Metric) {
+func (c *selfCollector) Collect(ch chan<- Metric) {
ch <- c.self
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/counter.go b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
similarity index 92%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/counter.go
rename to vendor/github.com/prometheus/client_golang/prometheus/counter.go
index a2952d1c8819a98545e20271695ca3aa5f6d0b29..ee37949ada1d6a2845c4894db8ecab463bb16105 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/counter.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
@@ -15,7 +15,6 @@ package prometheus
import (
"errors"
- "hash/fnv"
)
// Counter is a Metric that represents a single numerical value that only ever
@@ -36,6 +35,9 @@ type Counter interface {
// Prometheus metric. Do not use it for regular handling of a
// Prometheus counter (as it can be used to break the contract of
// monotonically increasing values).
+ //
+ // Deprecated: Use NewConstMetric to create a counter for an external
+ // value. A Counter should never be set.
Set(float64)
// Inc increments the counter by 1.
Inc()
@@ -56,7 +58,7 @@ func NewCounter(opts CounterOpts) Counter {
opts.ConstLabels,
)
result := &counter{value: value{desc: desc, valType: CounterValue, labelPairs: desc.constLabelPairs}}
- result.Init(result) // Init self-collection.
+ result.init(result) // Init self-collection.
return result
}
@@ -80,7 +82,7 @@ func (c *counter) Add(v float64) {
// CounterVec embeds MetricVec. See there for a full list of methods with
// detailed documentation.
type CounterVec struct {
- MetricVec
+ *MetricVec
}
// NewCounterVec creates a new CounterVec based on the provided CounterOpts and
@@ -94,20 +96,15 @@ func NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec {
opts.ConstLabels,
)
return &CounterVec{
- MetricVec: MetricVec{
- children: map[uint64]Metric{},
- desc: desc,
- hash: fnv.New64a(),
- newMetric: func(lvs ...string) Metric {
- result := &counter{value: value{
- desc: desc,
- valType: CounterValue,
- labelPairs: makeLabelPairs(desc, lvs),
- }}
- result.Init(result) // Init self-collection.
- return result
- },
- },
+ MetricVec: newMetricVec(desc, func(lvs ...string) Metric {
+ result := &counter{value: value{
+ desc: desc,
+ valType: CounterValue,
+ labelPairs: makeLabelPairs(desc, lvs),
+ }}
+ result.init(result) // Init self-collection.
+ return result
+ }),
}
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/desc.go b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
similarity index 88%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/desc.go
rename to vendor/github.com/prometheus/client_golang/prometheus/desc.go
index fcde784d64053d9167489ca35f3c591ab94d4274..77f4b30e8478e763e505065164be7110253beb99 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/desc.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
@@ -1,10 +1,21 @@
+// Copyright 2016 The Prometheus 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 prometheus
import (
- "bytes"
"errors"
"fmt"
- "hash/fnv"
"regexp"
"sort"
"strings"
@@ -131,31 +142,24 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
d.err = errors.New("duplicate label names")
return d
}
- h := fnv.New64a()
- var b bytes.Buffer // To copy string contents into, avoiding []byte allocations.
+ vh := hashNew()
for _, val := range labelValues {
- b.Reset()
- b.WriteString(val)
- b.WriteByte(separatorByte)
- h.Write(b.Bytes())
+ vh = hashAdd(vh, val)
+ vh = hashAddByte(vh, separatorByte)
}
- d.id = h.Sum64()
+ d.id = vh
// Sort labelNames so that order doesn't matter for the hash.
sort.Strings(labelNames)
// Now hash together (in this order) the help string and the sorted
// label names.
- h.Reset()
- b.Reset()
- b.WriteString(help)
- b.WriteByte(separatorByte)
- h.Write(b.Bytes())
+ lh := hashNew()
+ lh = hashAdd(lh, help)
+ lh = hashAddByte(lh, separatorByte)
for _, labelName := range labelNames {
- b.Reset()
- b.WriteString(labelName)
- b.WriteByte(separatorByte)
- h.Write(b.Bytes())
+ lh = hashAdd(lh, labelName)
+ lh = hashAddByte(lh, separatorByte)
}
- d.dimHash = h.Sum64()
+ d.dimHash = lh
d.constLabelPairs = make([]*dto.LabelPair, 0, len(constLabels))
for n, v := range constLabels {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/doc.go b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..b15a2d3b9864f8c8c2d24b313a287e984bd8b0d8
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/doc.go
@@ -0,0 +1,181 @@
+// Copyright 2014 The Prometheus 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 prometheus provides metrics primitives to instrument code for
+// monitoring. It also offers a registry for metrics. Sub-packages allow to
+// expose the registered metrics via HTTP (package promhttp) or push them to a
+// Pushgateway (package push).
+//
+// All exported functions and methods are safe to be used concurrently unless
+//specified otherwise.
+//
+// A Basic Example
+//
+// As a starting point, a very basic usage example:
+//
+// package main
+//
+// import (
+// "net/http"
+//
+// "github.com/prometheus/client_golang/prometheus"
+// "github.com/prometheus/client_golang/prometheus/promhttp"
+// )
+//
+// var (
+// cpuTemp = prometheus.NewGauge(prometheus.GaugeOpts{
+// Name: "cpu_temperature_celsius",
+// Help: "Current temperature of the CPU.",
+// })
+// hdFailures = prometheus.NewCounterVec(
+// prometheus.CounterOpts{
+// Name: "hd_errors_total",
+// Help: "Number of hard-disk errors.",
+// },
+// []string{"device"},
+// )
+// )
+//
+// func init() {
+// // Metrics have to be registered to be exposed:
+// prometheus.MustRegister(cpuTemp)
+// prometheus.MustRegister(hdFailures)
+// }
+//
+// func main() {
+// cpuTemp.Set(65.3)
+// hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
+//
+// // The Handler function provides a default handler to expose metrics
+// // via an HTTP server. "/metrics" is the usual endpoint for that.
+// http.Handle("/metrics", promhttp.Handler())
+// http.ListenAndServe(":8080", nil)
+// }
+//
+//
+// This is a complete program that exports two metrics, a Gauge and a Counter,
+// the latter with a label attached to turn it into a (one-dimensional) vector.
+//
+// Metrics
+//
+// The number of exported identifiers in this package might appear a bit
+// overwhelming. Hovever, in addition to the basic plumbing shown in the example
+// above, you only need to understand the different metric types and their
+// vector versions for basic usage.
+//
+// Above, you have already touched the Counter and the Gauge. There are two more
+// advanced metric types: the Summary and Histogram. A more thorough description
+// of those four metric types can be found in the Prometheus docs:
+// https://prometheus.io/docs/concepts/metric_types/
+//
+// A fifth "type" of metric is Untyped. It behaves like a Gauge, but signals the
+// Prometheus server not to assume anything about its type.
+//
+// In addition to the fundamental metric types Gauge, Counter, Summary,
+// Histogram, and Untyped, a very important part of the Prometheus data model is
+// the partitioning of samples along dimensions called labels, which results in
+// metric vectors. The fundamental types are GaugeVec, CounterVec, SummaryVec,
+// HistogramVec, and UntypedVec.
+//
+// While only the fundamental metric types implement the Metric interface, both
+// the metrics and their vector versions implement the Collector interface. A
+// Collector manages the collection of a number of Metrics, but for convenience,
+// a Metric can also “collect itself”. Note that Gauge, Counter, Summary,
+// Histogram, and Untyped are interfaces themselves while GaugeVec, CounterVec,
+// SummaryVec, HistogramVec, and UntypedVec are not.
+//
+// To create instances of Metrics and their vector versions, you need a suitable
+// …Opts struct, i.e. GaugeOpts, CounterOpts, SummaryOpts,
+// HistogramOpts, or UntypedOpts.
+//
+// Custom Collectors and constant Metrics
+//
+// While you could create your own implementations of Metric, most likely you
+// will only ever implement the Collector interface on your own. At a first
+// glance, a custom Collector seems handy to bundle Metrics for common
+// registration (with the prime example of the different metric vectors above,
+// which bundle all the metrics of the same name but with different labels).
+//
+// There is a more involved use case, too: If you already have metrics
+// available, created outside of the Prometheus context, you don't need the
+// interface of the various Metric types. You essentially want to mirror the
+// existing numbers into Prometheus Metrics during collection. An own
+// implementation of the Collector interface is perfect for that. You can create
+// Metric instances “on the fly” using NewConstMetric, NewConstHistogram, and
+// NewConstSummary (and their respective Must… versions). That will happen in
+// the Collect method. The Describe method has to return separate Desc
+// instances, representative of the “throw-away” metrics to be created
+// later. NewDesc comes in handy to create those Desc instances.
+//
+// The Collector example illustrates the use case. You can also look at the
+// source code of the processCollector (mirroring process metrics), the
+// goCollector (mirroring Go metrics), or the expvarCollector (mirroring expvar
+// metrics) as examples that are used in this package itself.
+//
+// If you just need to call a function to get a single float value to collect as
+// a metric, GaugeFunc, CounterFunc, or UntypedFunc might be interesting
+// shortcuts.
+//
+// Advanced Uses of the Registry
+//
+// While MustRegister is the by far most common way of registering a Collector,
+// sometimes you might want to handle the errors the registration might
+// cause. As suggested by the name, MustRegister panics if an error occurs. With
+// the Register function, the error is returned and can be handled.
+//
+// An error is returned if the registered Collector is incompatible or
+// inconsistent with already registered metrics. The registry aims for
+// consistency of the collected metrics according to the Prometheus data
+// model. Inconsistencies are ideally detected at registration time, not at
+// collect time. The former will usually be detected at start-up time of a
+// program, while the latter will only happen at scrape time, possibly not even
+// on the first scrape if the inconsistency only becomes relevant later. That is
+// the main reason why a Collector and a Metric have to describe themselves to
+// the registry.
+//
+// So far, everything we did operated on the so-called default registry, as it
+// can be found in the global DefaultRegistry variable. With NewRegistry, you
+// can create a custom registry, or you can even implement the Registerer or
+// Gatherer interfaces yourself. The methods Register and Unregister work in
+// the same way on a custom registry as the global functions Register and
+// Unregister on the default registry.
+//
+// There are a number of uses for custom registries: You can use registries
+// with special properties, see NewPedanticRegistry. You can avoid global state,
+// as it is imposed by the DefaultRegistry. You can use multiple registries at
+// the same time to expose different metrics in different ways. You can use
+// separate registries for testing purposes.
+//
+// Also note that the DefaultRegistry comes registered with a Collector for Go
+// runtime metrics (via NewGoCollector) and a Collector for process metrics (via
+// NewProcessCollector). With a custom registry, you are in control and decide
+// yourself about the Collectors to register.
+//
+// HTTP Exposition
+//
+// The Registry implements the Gatherer interface. The caller of the Gather
+// method can then expose the gathered metrics in some way. Usually, the metrics
+// are served via HTTP on the /metrics endpoint. That's happening in the example
+// above. The tools to expose metrics via HTTP are in the promhttp
+// sub-package. (The top-level functions in the prometheus package are
+// deprecated.)
+//
+// Pushing to the Pushgateway
+//
+// Function for pushing to the Pushgateway can be found in the push sub-package.
+//
+// Other Means of Exposition
+//
+// More ways of exposing metrics can easily be added. Sending metrics to
+// Graphite would be an example that will soon be implemented.
+package prometheus
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/expvar.go b/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
similarity index 81%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/expvar.go
rename to vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
index 0f7630d53f5a75acc0124177c704cadc01d71106..18a99d5faaa5b1ab812c4a16e679b9675a2928d7 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/expvar.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
@@ -18,21 +18,21 @@ import (
"expvar"
)
-// ExpvarCollector collects metrics from the expvar interface. It provides a
-// quick way to expose numeric values that are already exported via expvar as
-// Prometheus metrics. Note that the data models of expvar and Prometheus are
-// fundamentally different, and that the ExpvarCollector is inherently
-// slow. Thus, the ExpvarCollector is probably great for experiments and
-// prototying, but you should seriously consider a more direct implementation of
-// Prometheus metrics for monitoring production systems.
-//
-// Use NewExpvarCollector to create new instances.
-type ExpvarCollector struct {
+type expvarCollector struct {
exports map[string]*Desc
}
-// NewExpvarCollector returns a newly allocated ExpvarCollector that still has
-// to be registered with the Prometheus registry.
+// NewExpvarCollector returns a newly allocated expvar Collector that still has
+// to be registered with a Prometheus registry.
+//
+// An expvar Collector collects metrics from the expvar interface. It provides a
+// quick way to expose numeric values that are already exported via expvar as
+// Prometheus metrics. Note that the data models of expvar and Prometheus are
+// fundamentally different, and that the expvar Collector is inherently slower
+// than native Prometheus metrics. Thus, the expvar Collector is probably great
+// for experiments and prototying, but you should seriously consider a more
+// direct implementation of Prometheus metrics for monitoring production
+// systems.
//
// The exports map has the following meaning:
//
@@ -59,21 +59,21 @@ type ExpvarCollector struct {
// sample values.
//
// Anything that does not fit into the scheme above is silently ignored.
-func NewExpvarCollector(exports map[string]*Desc) *ExpvarCollector {
- return &ExpvarCollector{
+func NewExpvarCollector(exports map[string]*Desc) Collector {
+ return &expvarCollector{
exports: exports,
}
}
// Describe implements Collector.
-func (e *ExpvarCollector) Describe(ch chan<- *Desc) {
+func (e *expvarCollector) Describe(ch chan<- *Desc) {
for _, desc := range e.exports {
ch <- desc
}
}
// Collect implements Collector.
-func (e *ExpvarCollector) Collect(ch chan<- Metric) {
+func (e *expvarCollector) Collect(ch chan<- Metric) {
for name, desc := range e.exports {
var m Metric
expVar := expvar.Get(name)
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/fnv.go b/vendor/github.com/prometheus/client_golang/prometheus/fnv.go
new file mode 100644
index 0000000000000000000000000000000000000000..e3b67df8ac0681fd73151e7e44c3ea8bed3bfb63
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/fnv.go
@@ -0,0 +1,29 @@
+package prometheus
+
+// Inline and byte-free variant of hash/fnv's fnv64a.
+
+const (
+ offset64 = 14695981039346656037
+ prime64 = 1099511628211
+)
+
+// hashNew initializies a new fnv64a hash value.
+func hashNew() uint64 {
+ return offset64
+}
+
+// hashAdd adds a string to a fnv64a hash value, returning the updated hash.
+func hashAdd(h uint64, s string) uint64 {
+ for i := 0; i < len(s); i++ {
+ h ^= uint64(s[i])
+ h *= prime64
+ }
+ return h
+}
+
+// hashAddByte adds a byte to a fnv64a hash value, returning the updated hash.
+func hashAddByte(h uint64, b byte) uint64 {
+ h ^= uint64(b)
+ h *= prime64
+ return h
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/gauge.go b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/gauge.go
rename to vendor/github.com/prometheus/client_golang/prometheus/gauge.go
index ba8a402cafc6c65a4040e8ea639d4a1402e6c797..8b70e5141d4099d2c3d768c4cede39aaa29b684a 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/gauge.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
@@ -13,8 +13,6 @@
package prometheus
-import "hash/fnv"
-
// Gauge is a Metric that represents a single numerical value that can
// arbitrarily go up and down.
//
@@ -60,7 +58,7 @@ func NewGauge(opts GaugeOpts) Gauge {
// (e.g. number of operations queued, partitioned by user and operation
// type). Create instances with NewGaugeVec.
type GaugeVec struct {
- MetricVec
+ *MetricVec
}
// NewGaugeVec creates a new GaugeVec based on the provided GaugeOpts and
@@ -74,14 +72,9 @@ func NewGaugeVec(opts GaugeOpts, labelNames []string) *GaugeVec {
opts.ConstLabels,
)
return &GaugeVec{
- MetricVec: MetricVec{
- children: map[uint64]Metric{},
- desc: desc,
- hash: fnv.New64a(),
- newMetric: func(lvs ...string) Metric {
- return newValue(desc, GaugeValue, 0, lvs...)
- },
- },
+ MetricVec: newMetricVec(desc, func(lvs ...string) Metric {
+ return newValue(desc, GaugeValue, 0, lvs...)
+ }),
}
}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go b/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
new file mode 100644
index 0000000000000000000000000000000000000000..abc9d4ec403c42766e3514e3a7f0e506379c744f
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/go_collector.go
@@ -0,0 +1,263 @@
+package prometheus
+
+import (
+ "fmt"
+ "runtime"
+ "runtime/debug"
+ "time"
+)
+
+type goCollector struct {
+ goroutines Gauge
+ gcDesc *Desc
+
+ // metrics to describe and collect
+ metrics memStatsMetrics
+}
+
+// NewGoCollector returns a collector which exports metrics about the current
+// go process.
+func NewGoCollector() Collector {
+ return &goCollector{
+ goroutines: NewGauge(GaugeOpts{
+ Namespace: "go",
+ Name: "goroutines",
+ Help: "Number of goroutines that currently exist.",
+ }),
+ gcDesc: NewDesc(
+ "go_gc_duration_seconds",
+ "A summary of the GC invocation durations.",
+ nil, nil),
+ metrics: memStatsMetrics{
+ {
+ desc: NewDesc(
+ memstatNamespace("alloc_bytes"),
+ "Number of bytes allocated and still in use.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.Alloc) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("alloc_bytes_total"),
+ "Total number of bytes allocated, even if freed.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.TotalAlloc) },
+ valType: CounterValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("sys_bytes"),
+ "Number of bytes obtained by system. Sum of all system allocations.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.Sys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("lookups_total"),
+ "Total number of pointer lookups.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.Lookups) },
+ valType: CounterValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("mallocs_total"),
+ "Total number of mallocs.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.Mallocs) },
+ valType: CounterValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("frees_total"),
+ "Total number of frees.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.Frees) },
+ valType: CounterValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_alloc_bytes"),
+ "Number of heap bytes allocated and still in use.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapAlloc) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_sys_bytes"),
+ "Number of heap bytes obtained from system.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_idle_bytes"),
+ "Number of heap bytes waiting to be used.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapIdle) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_inuse_bytes"),
+ "Number of heap bytes that are in use.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapInuse) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_released_bytes_total"),
+ "Total number of heap bytes released to OS.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapReleased) },
+ valType: CounterValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("heap_objects"),
+ "Number of allocated objects.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.HeapObjects) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("stack_inuse_bytes"),
+ "Number of bytes in use by the stack allocator.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.StackInuse) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("stack_sys_bytes"),
+ "Number of bytes obtained from system for stack allocator.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.StackSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("mspan_inuse_bytes"),
+ "Number of bytes in use by mspan structures.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.MSpanInuse) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("mspan_sys_bytes"),
+ "Number of bytes used for mspan structures obtained from system.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.MSpanSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("mcache_inuse_bytes"),
+ "Number of bytes in use by mcache structures.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.MCacheInuse) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("mcache_sys_bytes"),
+ "Number of bytes used for mcache structures obtained from system.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.MCacheSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("buck_hash_sys_bytes"),
+ "Number of bytes used by the profiling bucket hash table.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.BuckHashSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("gc_sys_bytes"),
+ "Number of bytes used for garbage collection system metadata.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.GCSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("other_sys_bytes"),
+ "Number of bytes used for other system allocations.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.OtherSys) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("next_gc_bytes"),
+ "Number of heap bytes when next garbage collection will take place.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.NextGC) },
+ valType: GaugeValue,
+ }, {
+ desc: NewDesc(
+ memstatNamespace("last_gc_time_seconds"),
+ "Number of seconds since 1970 of last garbage collection.",
+ nil, nil,
+ ),
+ eval: func(ms *runtime.MemStats) float64 { return float64(ms.LastGC) / 1e9 },
+ valType: GaugeValue,
+ },
+ },
+ }
+}
+
+func memstatNamespace(s string) string {
+ return fmt.Sprintf("go_memstats_%s", s)
+}
+
+// Describe returns all descriptions of the collector.
+func (c *goCollector) Describe(ch chan<- *Desc) {
+ ch <- c.goroutines.Desc()
+ ch <- c.gcDesc
+
+ for _, i := range c.metrics {
+ ch <- i.desc
+ }
+}
+
+// Collect returns the current state of all metrics of the collector.
+func (c *goCollector) Collect(ch chan<- Metric) {
+ c.goroutines.Set(float64(runtime.NumGoroutine()))
+ ch <- c.goroutines
+
+ var stats debug.GCStats
+ stats.PauseQuantiles = make([]time.Duration, 5)
+ debug.ReadGCStats(&stats)
+
+ quantiles := make(map[float64]float64)
+ for idx, pq := range stats.PauseQuantiles[1:] {
+ quantiles[float64(idx+1)/float64(len(stats.PauseQuantiles)-1)] = pq.Seconds()
+ }
+ quantiles[0.0] = stats.PauseQuantiles[0].Seconds()
+ ch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), float64(stats.PauseTotal.Seconds()), quantiles)
+
+ ms := &runtime.MemStats{}
+ runtime.ReadMemStats(ms)
+ for _, i := range c.metrics {
+ ch <- MustNewConstMetric(i.desc, i.valType, i.eval(ms))
+ }
+}
+
+// memStatsMetrics provide description, value, and value type for memstat metrics.
+type memStatsMetrics []struct {
+ desc *Desc
+ eval func(*runtime.MemStats) float64
+ valType ValueType
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/histogram.go b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/histogram.go
rename to vendor/github.com/prometheus/client_golang/prometheus/histogram.go
index f98a41bc89d68325ee94615fcc66e44334fbca4a..9719e8fac8ba3ac6cbccc1635830a58bc680afb4 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/histogram.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
@@ -15,7 +15,6 @@ package prometheus
import (
"fmt"
- "hash/fnv"
"math"
"sort"
"sync/atomic"
@@ -52,11 +51,11 @@ type Histogram interface {
// bucket of a histogram ("le" -> "less or equal").
const bucketLabel = "le"
+// DefBuckets are the default Histogram buckets. The default buckets are
+// tailored to broadly measure the response time (in seconds) of a network
+// service. Most likely, however, you will be required to define buckets
+// customized to your use case.
var (
- // DefBuckets are the default Histogram buckets. The default buckets are
- // tailored to broadly measure the response time (in seconds) of a
- // network service. Most likely, however, you will be required to define
- // buckets customized to your use case.
DefBuckets = []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10}
errBucketLabelNotAllowed = fmt.Errorf(
@@ -211,7 +210,7 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr
// Finally we know the final length of h.upperBounds and can make counts.
h.counts = make([]uint64, len(h.upperBounds))
- h.Init(h) // Init self-collection.
+ h.init(h) // Init self-collection.
return h
}
@@ -223,7 +222,7 @@ type histogram struct {
sumBits uint64
count uint64
- SelfCollector
+ selfCollector
// Note that there is no mutex required.
desc *Desc
@@ -288,7 +287,7 @@ func (h *histogram) Write(out *dto.Metric) error {
// (e.g. HTTP request latencies, partitioned by status code and method). Create
// instances with NewHistogramVec.
type HistogramVec struct {
- MetricVec
+ *MetricVec
}
// NewHistogramVec creates a new HistogramVec based on the provided HistogramOpts and
@@ -302,14 +301,9 @@ func NewHistogramVec(opts HistogramOpts, labelNames []string) *HistogramVec {
opts.ConstLabels,
)
return &HistogramVec{
- MetricVec: MetricVec{
- children: map[uint64]Metric{},
- desc: desc,
- hash: fnv.New64a(),
- newMetric: func(lvs ...string) Metric {
- return newHistogram(desc, opts, lvs...)
- },
- },
+ MetricVec: newMetricVec(desc, func(lvs ...string) Metric {
+ return newHistogram(desc, opts, lvs...)
+ }),
}
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/http.go b/vendor/github.com/prometheus/client_golang/prometheus/http.go
similarity index 61%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/http.go
rename to vendor/github.com/prometheus/client_golang/prometheus/http.go
index eabe602468f1138471d41c841cc50f9e5ae413e1..67ee5ac794c277092d0f5a260600638f581d8c6d 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/http.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/http.go
@@ -15,14 +15,114 @@ package prometheus
import (
"bufio"
+ "bytes"
+ "compress/gzip"
+ "fmt"
"io"
"net"
"net/http"
"strconv"
"strings"
+ "sync"
"time"
+
+ "github.com/prometheus/common/expfmt"
)
+// TODO(beorn7): Remove this whole file. It is a partial mirror of
+// promhttp/http.go (to avoid circular import chains) where everything HTTP
+// related should live. The functions here are just for avoiding
+// breakage. Everything is deprecated.
+
+const (
+ contentTypeHeader = "Content-Type"
+ contentLengthHeader = "Content-Length"
+ contentEncodingHeader = "Content-Encoding"
+ acceptEncodingHeader = "Accept-Encoding"
+)
+
+var bufPool sync.Pool
+
+func getBuf() *bytes.Buffer {
+ buf := bufPool.Get()
+ if buf == nil {
+ return &bytes.Buffer{}
+ }
+ return buf.(*bytes.Buffer)
+}
+
+func giveBuf(buf *bytes.Buffer) {
+ buf.Reset()
+ bufPool.Put(buf)
+}
+
+// Handler returns an HTTP handler for the DefaultGatherer. It is
+// already instrumented with InstrumentHandler (using "prometheus" as handler
+// name).
+//
+// Deprecated: Please note the issues described in the doc comment of
+// InstrumentHandler. You might want to consider using promhttp.Handler instead
+// (which is non instrumented).
+func Handler() http.Handler {
+ return InstrumentHandler("prometheus", UninstrumentedHandler())
+}
+
+// UninstrumentedHandler returns an HTTP handler for the DefaultGatherer.
+//
+// Deprecated: Use promhttp.Handler instead. See there for further documentation.
+func UninstrumentedHandler() http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+ mfs, err := DefaultGatherer.Gather()
+ if err != nil {
+ http.Error(w, "An error has occurred during metrics collection:\n\n"+err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ contentType := expfmt.Negotiate(req.Header)
+ buf := getBuf()
+ defer giveBuf(buf)
+ writer, encoding := decorateWriter(req, buf)
+ enc := expfmt.NewEncoder(writer, contentType)
+ var lastErr error
+ for _, mf := range mfs {
+ if err := enc.Encode(mf); err != nil {
+ lastErr = err
+ http.Error(w, "An error has occurred during metrics encoding:\n\n"+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ }
+ if closer, ok := writer.(io.Closer); ok {
+ closer.Close()
+ }
+ if lastErr != nil && buf.Len() == 0 {
+ http.Error(w, "No metrics encoded, last error:\n\n"+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ header := w.Header()
+ header.Set(contentTypeHeader, string(contentType))
+ header.Set(contentLengthHeader, fmt.Sprint(buf.Len()))
+ if encoding != "" {
+ header.Set(contentEncodingHeader, encoding)
+ }
+ w.Write(buf.Bytes())
+ })
+}
+
+// decorateWriter wraps a writer to handle gzip compression if requested. It
+// returns the decorated writer and the appropriate "Content-Encoding" header
+// (which is empty if no compression is enabled).
+func decorateWriter(request *http.Request, writer io.Writer) (io.Writer, string) {
+ header := request.Header.Get(acceptEncodingHeader)
+ parts := strings.Split(header, ",")
+ for _, part := range parts {
+ part := strings.TrimSpace(part)
+ if part == "gzip" || strings.HasPrefix(part, "gzip;") {
+ return gzip.NewWriter(writer), "gzip"
+ }
+ }
+ return writer, ""
+}
+
var instLabels = []string{"method", "code"}
type nower interface {
@@ -57,12 +157,34 @@ func nowSeries(t ...time.Time) nower {
// has a constant label named "handler" with the provided handlerName as
// value. http_requests_total is a metric vector partitioned by HTTP method
// (label name "method") and HTTP status code (label name "code").
+//
+// Deprecated: InstrumentHandler has several issues:
+//
+// - It uses Summaries rather than Histograms. Summaries are not useful if
+// aggregation across multiple instances is required.
+//
+// - It uses microseconds as unit, which is deprecated and should be replaced by
+// seconds.
+//
+// - The size of the request is calculated in a separate goroutine. Since this
+// calculator requires access to the request header, it creates a race with
+// any writes to the header performed during request handling.
+// httputil.ReverseProxy is a prominent example for a handler
+// performing such writes.
+//
+// Upcoming versions of this package will provide ways of instrumenting HTTP
+// handlers that are more flexible and have fewer issues. Please prefer direct
+// instrumentation in the meantime.
func InstrumentHandler(handlerName string, handler http.Handler) http.HandlerFunc {
return InstrumentHandlerFunc(handlerName, handler.ServeHTTP)
}
// InstrumentHandlerFunc wraps the given function for instrumentation. It
-// otherwise works in the same way as InstrumentHandler.
+// otherwise works in the same way as InstrumentHandler (and shares the same
+// issues).
+//
+// Deprecated: InstrumentHandlerFunc is deprecated for the same reasons as
+// InstrumentHandler is.
func InstrumentHandlerFunc(handlerName string, handlerFunc func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
return InstrumentHandlerFuncWithOpts(
SummaryOpts{
@@ -73,13 +195,13 @@ func InstrumentHandlerFunc(handlerName string, handlerFunc func(http.ResponseWri
)
}
-// InstrumentHandlerWithOpts works like InstrumentHandler but provides more
-// flexibility (at the cost of a more complex call syntax). As
-// InstrumentHandler, this function registers four metric collectors, but it
-// uses the provided SummaryOpts to create them. However, the fields "Name" and
-// "Help" in the SummaryOpts are ignored. "Name" is replaced by
-// "requests_total", "request_duration_microseconds", "request_size_bytes", and
-// "response_size_bytes", respectively. "Help" is replaced by an appropriate
+// InstrumentHandlerWithOpts works like InstrumentHandler (and shares the same
+// issues) but provides more flexibility (at the cost of a more complex call
+// syntax). As InstrumentHandler, this function registers four metric
+// collectors, but it uses the provided SummaryOpts to create them. However, the
+// fields "Name" and "Help" in the SummaryOpts are ignored. "Name" is replaced
+// by "requests_total", "request_duration_microseconds", "request_size_bytes",
+// and "response_size_bytes", respectively. "Help" is replaced by an appropriate
// help string. The names of the variable labels of the http_requests_total
// CounterVec are "method" (get, post, etc.), and "code" (HTTP status code).
//
@@ -98,13 +220,20 @@ func InstrumentHandlerFunc(handlerName string, handlerFunc func(http.ResponseWri
// cannot use SummaryOpts. Instead, a CounterOpts struct is created internally,
// and all its fields are set to the equally named fields in the provided
// SummaryOpts.
+//
+// Deprecated: InstrumentHandlerWithOpts is deprecated for the same reasons as
+// InstrumentHandler is.
func InstrumentHandlerWithOpts(opts SummaryOpts, handler http.Handler) http.HandlerFunc {
return InstrumentHandlerFuncWithOpts(opts, handler.ServeHTTP)
}
-// InstrumentHandlerFuncWithOpts works like InstrumentHandlerFunc but provides
-// more flexibility (at the cost of a more complex call syntax). See
-// InstrumentHandlerWithOpts for details how the provided SummaryOpts are used.
+// InstrumentHandlerFuncWithOpts works like InstrumentHandlerFunc (and shares
+// the same issues) but provides more flexibility (at the cost of a more complex
+// call syntax). See InstrumentHandlerWithOpts for details how the provided
+// SummaryOpts are used.
+//
+// Deprecated: InstrumentHandlerFuncWithOpts is deprecated for the same reasons
+// as InstrumentHandler is.
func InstrumentHandlerFuncWithOpts(opts SummaryOpts, handlerFunc func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
reqCnt := NewCounterVec(
CounterOpts{
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/metric.go b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
similarity index 83%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/metric.go
rename to vendor/github.com/prometheus/client_golang/prometheus/metric.go
index 86fd81c108bde27b626457bbfd4a1ff7dec57361..d4063d98f4172b800ca5a45a03b52a5f710e94f4 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/metric.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
@@ -22,10 +22,8 @@ import (
const separatorByte byte = 255
// A Metric models a single sample value with its meta data being exported to
-// Prometheus. Implementers of Metric in this package inclued Gauge, Counter,
-// Untyped, and Summary. Users can implement their own Metric types, but that
-// should be rarely needed. See the example for SelfCollector, which is also an
-// example for a user-implemented Metric.
+// Prometheus. Implementations of Metric in this package are Gauge, Counter,
+// Histogram, Summary, and Untyped.
type Metric interface {
// Desc returns the descriptor for the Metric. This method idempotently
// returns the same descriptor throughout the lifetime of the
@@ -36,21 +34,23 @@ type Metric interface {
// Write encodes the Metric into a "Metric" Protocol Buffer data
// transmission object.
//
- // Implementers of custom Metric types must observe concurrency safety
- // as reads of this metric may occur at any time, and any blocking
- // occurs at the expense of total performance of rendering all
- // registered metrics. Ideally Metric implementations should support
- // concurrent readers.
+ // Metric implementations must observe concurrency safety as reads of
+ // this metric may occur at any time, and any blocking occurs at the
+ // expense of total performance of rendering all registered
+ // metrics. Ideally, Metric implementations should support concurrent
+ // readers.
//
- // The Prometheus client library attempts to minimize memory allocations
- // and will provide a pre-existing reset dto.Metric pointer. Prometheus
- // may recycle the dto.Metric proto message, so Metric implementations
- // should just populate the provided dto.Metric and then should not keep
- // any reference to it.
- //
- // While populating dto.Metric, labels must be sorted lexicographically.
- // (Implementers may find LabelPairSorter useful for that.)
+ // While populating dto.Metric, it is the responsibility of the
+ // implementation to ensure validity of the Metric protobuf (like valid
+ // UTF-8 strings or syntactically valid metric and label names). It is
+ // recommended to sort labels lexicographically. (Implementers may find
+ // LabelPairSorter useful for that.) Callers of Write should still make
+ // sure of sorting if they depend on it.
Write(*dto.Metric) error
+ // TODO(beorn7): The original rationale of passing in a pre-allocated
+ // dto.Metric protobuf to save allocations has disappeared. The
+ // signature of this method should be changed to "Write() (*dto.Metric,
+ // error)".
}
// Opts bundles the options for creating most Metric types. Each metric
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/process_collector.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/process_collector.go
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
index d8cf0eda347c8d27fb523340e497ee8036bf412b..e31e62e78d0d12903facc726498c44bf1d48ff68 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/process_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector.go
@@ -28,7 +28,7 @@ type processCollector struct {
// NewProcessCollector returns a collector which exports the current state of
// process metrics including cpu, memory and file descriptor usage as well as
// the process start time for the given process id under the given namespace.
-func NewProcessCollector(pid int, namespace string) *processCollector {
+func NewProcessCollector(pid int, namespace string) Collector {
return NewProcessCollectorPIDFn(
func() (int, error) { return pid, nil },
namespace,
@@ -43,7 +43,7 @@ func NewProcessCollector(pid int, namespace string) *processCollector {
func NewProcessCollectorPIDFn(
pidFn func() (int, error),
namespace string,
-) *processCollector {
+) Collector {
c := processCollector{
pidFn: pidFn,
collectFn: func(chan<- Metric) {},
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/registry.go b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
new file mode 100644
index 0000000000000000000000000000000000000000..32a3986b06c8b964ccebbccf2ca1e33b23613cef
--- /dev/null
+++ b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
@@ -0,0 +1,806 @@
+// Copyright 2014 The Prometheus 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 prometheus
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "os"
+ "sort"
+ "sync"
+
+ "github.com/golang/protobuf/proto"
+
+ dto "github.com/prometheus/client_model/go"
+)
+
+const (
+ // Capacity for the channel to collect metrics and descriptors.
+ capMetricChan = 1000
+ capDescChan = 10
+)
+
+// DefaultRegisterer and DefaultGatherer are the implementations of the
+// Registerer and Gatherer interface a number of convenience functions in this
+// package act on. Initially, both variables point to the same Registry, which
+// has a process collector (see NewProcessCollector) and a Go collector (see
+// NewGoCollector) already registered. This approach to keep default instances
+// as global state mirrors the approach of other packages in the Go standard
+// library. Note that there are caveats. Change the variables with caution and
+// only if you understand the consequences. Users who want to avoid global state
+// altogether should not use the convenience function and act on custom
+// instances instead.
+var (
+ defaultRegistry = NewRegistry()
+ DefaultRegisterer Registerer = defaultRegistry
+ DefaultGatherer Gatherer = defaultRegistry
+)
+
+func init() {
+ MustRegister(NewProcessCollector(os.Getpid(), ""))
+ MustRegister(NewGoCollector())
+}
+
+// NewRegistry creates a new vanilla Registry without any Collectors
+// pre-registered.
+func NewRegistry() *Registry {
+ return &Registry{
+ collectorsByID: map[uint64]Collector{},
+ descIDs: map[uint64]struct{}{},
+ dimHashesByName: map[string]uint64{},
+ }
+}
+
+// NewPedanticRegistry returns a registry that checks during collection if each
+// collected Metric is consistent with its reported Desc, and if the Desc has
+// actually been registered with the registry.
+//
+// Usually, a Registry will be happy as long as the union of all collected
+// Metrics is consistent and valid even if some metrics are not consistent with
+// their own Desc or a Desc provided by their registered Collector. Well-behaved
+// Collectors and Metrics will only provide consistent Descs. This Registry is
+// useful to test the implementation of Collectors and Metrics.
+func NewPedanticRegistry() *Registry {
+ r := NewRegistry()
+ r.pedanticChecksEnabled = true
+ return r
+}
+
+// Registerer is the interface for the part of a registry in charge of
+// registering and unregistering. Users of custom registries should use
+// Registerer as type for registration purposes (rather then the Registry type
+// directly). In that way, they are free to use custom Registerer implementation
+// (e.g. for testing purposes).
+type Registerer interface {
+ // Register registers a new Collector to be included in metrics
+ // collection. It returns an error if the descriptors provided by the
+ // Collector are invalid or if they — in combination with descriptors of
+ // already registered Collectors — do not fulfill the consistency and
+ // uniqueness criteria described in the documentation of metric.Desc.
+ //
+ // If the provided Collector is equal to a Collector already registered
+ // (which includes the case of re-registering the same Collector), the
+ // returned error is an instance of AlreadyRegisteredError, which
+ // contains the previously registered Collector.
+ //
+ // It is in general not safe to register the same Collector multiple
+ // times concurrently.
+ Register(Collector) error
+ // MustRegister works like Register but registers any number of
+ // Collectors and panics upon the first registration that causes an
+ // error.
+ MustRegister(...Collector)
+ // Unregister unregisters the Collector that equals the Collector passed
+ // in as an argument. (Two Collectors are considered equal if their
+ // Describe method yields the same set of descriptors.) The function
+ // returns whether a Collector was unregistered.
+ //
+ // Note that even after unregistering, it will not be possible to
+ // register a new Collector that is inconsistent with the unregistered
+ // Collector, e.g. a Collector collecting metrics with the same name but
+ // a different help string. The rationale here is that the same registry
+ // instance must only collect consistent metrics throughout its
+ // lifetime.
+ Unregister(Collector) bool
+}
+
+// Gatherer is the interface for the part of a registry in charge of gathering
+// the collected metrics into a number of MetricFamilies. The Gatherer interface
+// comes with the same general implication as described for the Registerer
+// interface.
+type Gatherer interface {
+ // Gather calls the Collect method of the registered Collectors and then
+ // gathers the collected metrics into a lexicographically sorted slice
+ // of MetricFamily protobufs. Even if an error occurs, Gather attempts
+ // to gather as many metrics as possible. Hence, if a non-nil error is
+ // returned, the returned MetricFamily slice could be nil (in case of a
+ // fatal error that prevented any meaningful metric collection) or
+ // contain a number of MetricFamily protobufs, some of which might be
+ // incomplete, and some might be missing altogether. The returned error
+ // (which might be a MultiError) explains the details. In scenarios
+ // where complete collection is critical, the returned MetricFamily
+ // protobufs should be disregarded if the returned error is non-nil.
+ Gather() ([]*dto.MetricFamily, error)
+}
+
+// Register registers the provided Collector with the DefaultRegisterer.
+//
+// Register is a shortcut for DefaultRegisterer.Register(c). See there for more
+// details.
+func Register(c Collector) error {
+ return DefaultRegisterer.Register(c)
+}
+
+// MustRegister registers the provided Collectors with the DefaultRegisterer and
+// panics if any error occurs.
+//
+// MustRegister is a shortcut for DefaultRegisterer.MustRegister(cs...). See
+// there for more details.
+func MustRegister(cs ...Collector) {
+ DefaultRegisterer.MustRegister(cs...)
+}
+
+// RegisterOrGet registers the provided Collector with the DefaultRegisterer and
+// returns the Collector, unless an equal Collector was registered before, in
+// which case that Collector is returned.
+//
+// Deprecated: RegisterOrGet is merely a convenience function for the
+// implementation as described in the documentation for
+// AlreadyRegisteredError. As the use case is relatively rare, this function
+// will be removed in a future version of this package to clean up the
+// namespace.
+func RegisterOrGet(c Collector) (Collector, error) {
+ if err := Register(c); err != nil {
+ if are, ok := err.(AlreadyRegisteredError); ok {
+ return are.ExistingCollector, nil
+ }
+ return nil, err
+ }
+ return c, nil
+}
+
+// MustRegisterOrGet behaves like RegisterOrGet but panics instead of returning
+// an error.
+//
+// Deprecated: This is deprecated for the same reason RegisterOrGet is. See
+// there for details.
+func MustRegisterOrGet(c Collector) Collector {
+ c, err := RegisterOrGet(c)
+ if err != nil {
+ panic(err)
+ }
+ return c
+}
+
+// Unregister removes the registration of the provided Collector from the
+// DefaultRegisterer.
+//
+// Unregister is a shortcut for DefaultRegisterer.Unregister(c). See there for
+// more details.
+func Unregister(c Collector) bool {
+ return DefaultRegisterer.Unregister(c)
+}
+
+// GathererFunc turns a function into a Gatherer.
+type GathererFunc func() ([]*dto.MetricFamily, error)
+
+// Gather implements Gatherer.
+func (gf GathererFunc) Gather() ([]*dto.MetricFamily, error) {
+ return gf()
+}
+
+// SetMetricFamilyInjectionHook replaces the DefaultGatherer with one that
+// gathers from the previous DefaultGatherers but then merges the MetricFamily
+// protobufs returned from the provided hook function with the MetricFamily
+// protobufs returned from the original DefaultGatherer.
+//
+// Deprecated: This function manipulates the DefaultGatherer variable. Consider
+// the implications, i.e. don't do this concurrently with any uses of the
+// DefaultGatherer. In the rare cases where you need to inject MetricFamily
+// protobufs directly, it is recommended to use a custom Registry and combine it
+// with a custom Gatherer using the Gatherers type (see
+// there). SetMetricFamilyInjectionHook only exists for compatibility reasons
+// with previous versions of this package.
+func SetMetricFamilyInjectionHook(hook func() []*dto.MetricFamily) {
+ DefaultGatherer = Gatherers{
+ DefaultGatherer,
+ GathererFunc(func() ([]*dto.MetricFamily, error) { return hook(), nil }),
+ }
+}
+
+// AlreadyRegisteredError is returned by the Register method if the Collector to
+// be registered has already been registered before, or a different Collector
+// that collects the same metrics has been registered before. Registration fails
+// in that case, but you can detect from the kind of error what has
+// happened. The error contains fields for the existing Collector and the
+// (rejected) new Collector that equals the existing one. This can be used to
+// find out if an equal Collector has been registered before and switch over to
+// using the old one, as demonstrated in the example.
+type AlreadyRegisteredError struct {
+ ExistingCollector, NewCollector Collector
+}
+
+func (err AlreadyRegisteredError) Error() string {
+ return "duplicate metrics collector registration attempted"
+}
+
+// MultiError is a slice of errors implementing the error interface. It is used
+// by a Gatherer to report multiple errors during MetricFamily gathering.
+type MultiError []error
+
+func (errs MultiError) Error() string {
+ if len(errs) == 0 {
+ return ""
+ }
+ buf := &bytes.Buffer{}
+ fmt.Fprintf(buf, "%d error(s) occurred:", len(errs))
+ for _, err := range errs {
+ fmt.Fprintf(buf, "\n* %s", err)
+ }
+ return buf.String()
+}
+
+// MaybeUnwrap returns nil if len(errs) is 0. It returns the first and only
+// contained error as error if len(errs is 1). In all other cases, it returns
+// the MultiError directly. This is helpful for returning a MultiError in a way
+// that only uses the MultiError if needed.
+func (errs MultiError) MaybeUnwrap() error {
+ switch len(errs) {
+ case 0:
+ return nil
+ case 1:
+ return errs[0]
+ default:
+ return errs
+ }
+}
+
+// Registry registers Prometheus collectors, collects their metrics, and gathers
+// them into MetricFamilies for exposition. It implements both Registerer and
+// Gatherer. The zero value is not usable. Create instances with NewRegistry or
+// NewPedanticRegistry.
+type Registry struct {
+ mtx sync.RWMutex
+ collectorsByID map[uint64]Collector // ID is a hash of the descIDs.
+ descIDs map[uint64]struct{}
+ dimHashesByName map[string]uint64
+ pedanticChecksEnabled bool
+}
+
+// Register implements Registerer.
+func (r *Registry) Register(c Collector) error {
+ var (
+ descChan = make(chan *Desc, capDescChan)
+ newDescIDs = map[uint64]struct{}{}
+ newDimHashesByName = map[string]uint64{}
+ collectorID uint64 // Just a sum of all desc IDs.
+ duplicateDescErr error
+ )
+ go func() {
+ c.Describe(descChan)
+ close(descChan)
+ }()
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+ // Coduct various tests...
+ for desc := range descChan {
+
+ // Is the descriptor valid at all?
+ if desc.err != nil {
+ return fmt.Errorf("descriptor %s is invalid: %s", desc, desc.err)
+ }
+
+ // Is the descID unique?
+ // (In other words: Is the fqName + constLabel combination unique?)
+ if _, exists := r.descIDs[desc.id]; exists {
+ duplicateDescErr = fmt.Errorf("descriptor %s already exists with the same fully-qualified name and const label values", desc)
+ }
+ // If it is not a duplicate desc in this collector, add it to
+ // the collectorID. (We allow duplicate descs within the same
+ // collector, but their existence must be a no-op.)
+ if _, exists := newDescIDs[desc.id]; !exists {
+ newDescIDs[desc.id] = struct{}{}
+ collectorID += desc.id
+ }
+
+ // Are all the label names and the help string consistent with
+ // previous descriptors of the same name?
+ // First check existing descriptors...
+ if dimHash, exists := r.dimHashesByName[desc.fqName]; exists {
+ if dimHash != desc.dimHash {
+ return fmt.Errorf("a previously registered descriptor with the same fully-qualified name as %s has different label names or a different help string", desc)
+ }
+ } else {
+ // ...then check the new descriptors already seen.
+ if dimHash, exists := newDimHashesByName[desc.fqName]; exists {
+ if dimHash != desc.dimHash {
+ return fmt.Errorf("descriptors reported by collector have inconsistent label names or help strings for the same fully-qualified name, offender is %s", desc)
+ }
+ } else {
+ newDimHashesByName[desc.fqName] = desc.dimHash
+ }
+ }
+ }
+ // Did anything happen at all?
+ if len(newDescIDs) == 0 {
+ return errors.New("collector has no descriptors")
+ }
+ if existing, exists := r.collectorsByID[collectorID]; exists {
+ return AlreadyRegisteredError{
+ ExistingCollector: existing,
+ NewCollector: c,
+ }
+ }
+ // If the collectorID is new, but at least one of the descs existed
+ // before, we are in trouble.
+ if duplicateDescErr != nil {
+ return duplicateDescErr
+ }
+
+ // Only after all tests have passed, actually register.
+ r.collectorsByID[collectorID] = c
+ for hash := range newDescIDs {
+ r.descIDs[hash] = struct{}{}
+ }
+ for name, dimHash := range newDimHashesByName {
+ r.dimHashesByName[name] = dimHash
+ }
+ return nil
+}
+
+// Unregister implements Registerer.
+func (r *Registry) Unregister(c Collector) bool {
+ var (
+ descChan = make(chan *Desc, capDescChan)
+ descIDs = map[uint64]struct{}{}
+ collectorID uint64 // Just a sum of the desc IDs.
+ )
+ go func() {
+ c.Describe(descChan)
+ close(descChan)
+ }()
+ for desc := range descChan {
+ if _, exists := descIDs[desc.id]; !exists {
+ collectorID += desc.id
+ descIDs[desc.id] = struct{}{}
+ }
+ }
+
+ r.mtx.RLock()
+ if _, exists := r.collectorsByID[collectorID]; !exists {
+ r.mtx.RUnlock()
+ return false
+ }
+ r.mtx.RUnlock()
+
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ delete(r.collectorsByID, collectorID)
+ for id := range descIDs {
+ delete(r.descIDs, id)
+ }
+ // dimHashesByName is left untouched as those must be consistent
+ // throughout the lifetime of a program.
+ return true
+}
+
+// MustRegister implements Registerer.
+func (r *Registry) MustRegister(cs ...Collector) {
+ for _, c := range cs {
+ if err := r.Register(c); err != nil {
+ panic(err)
+ }
+ }
+}
+
+// Gather implements Gatherer.
+func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
+ var (
+ metricChan = make(chan Metric, capMetricChan)
+ metricHashes = map[uint64]struct{}{}
+ dimHashes = map[string]uint64{}
+ wg sync.WaitGroup
+ errs MultiError // The collected errors to return in the end.
+ registeredDescIDs map[uint64]struct{} // Only used for pedantic checks
+ )
+
+ r.mtx.RLock()
+ metricFamiliesByName := make(map[string]*dto.MetricFamily, len(r.dimHashesByName))
+
+ // Scatter.
+ // (Collectors could be complex and slow, so we call them all at once.)
+ wg.Add(len(r.collectorsByID))
+ go func() {
+ wg.Wait()
+ close(metricChan)
+ }()
+ for _, collector := range r.collectorsByID {
+ go func(collector Collector) {
+ defer wg.Done()
+ collector.Collect(metricChan)
+ }(collector)
+ }
+
+ // In case pedantic checks are enabled, we have to copy the map before
+ // giving up the RLock.
+ if r.pedanticChecksEnabled {
+ registeredDescIDs = make(map[uint64]struct{}, len(r.descIDs))
+ for id := range r.descIDs {
+ registeredDescIDs[id] = struct{}{}
+ }
+ }
+
+ r.mtx.RUnlock()
+
+ // Drain metricChan in case of premature return.
+ defer func() {
+ for _ = range metricChan {
+ }
+ }()
+
+ // Gather.
+ for metric := range metricChan {
+ // This could be done concurrently, too, but it required locking
+ // of metricFamiliesByName (and of metricHashes if checks are
+ // enabled). Most likely not worth it.
+ desc := metric.Desc()
+ dtoMetric := &dto.Metric{}
+ if err := metric.Write(dtoMetric); err != nil {
+ errs = append(errs, fmt.Errorf(
+ "error collecting metric %v: %s", desc, err,
+ ))
+ continue
+ }
+ metricFamily, ok := metricFamiliesByName[desc.fqName]
+ if ok {
+ if metricFamily.GetHelp() != desc.help {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s has help %q but should have %q",
+ desc.fqName, dtoMetric, desc.help, metricFamily.GetHelp(),
+ ))
+ continue
+ }
+ // TODO(beorn7): Simplify switch once Desc has type.
+ switch metricFamily.GetType() {
+ case dto.MetricType_COUNTER:
+ if dtoMetric.Counter == nil {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s should be a Counter",
+ desc.fqName, dtoMetric,
+ ))
+ continue
+ }
+ case dto.MetricType_GAUGE:
+ if dtoMetric.Gauge == nil {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s should be a Gauge",
+ desc.fqName, dtoMetric,
+ ))
+ continue
+ }
+ case dto.MetricType_SUMMARY:
+ if dtoMetric.Summary == nil {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s should be a Summary",
+ desc.fqName, dtoMetric,
+ ))
+ continue
+ }
+ case dto.MetricType_UNTYPED:
+ if dtoMetric.Untyped == nil {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s should be Untyped",
+ desc.fqName, dtoMetric,
+ ))
+ continue
+ }
+ case dto.MetricType_HISTOGRAM:
+ if dtoMetric.Histogram == nil {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s should be a Histogram",
+ desc.fqName, dtoMetric,
+ ))
+ continue
+ }
+ default:
+ panic("encountered MetricFamily with invalid type")
+ }
+ } else {
+ metricFamily = &dto.MetricFamily{}
+ metricFamily.Name = proto.String(desc.fqName)
+ metricFamily.Help = proto.String(desc.help)
+ // TODO(beorn7): Simplify switch once Desc has type.
+ switch {
+ case dtoMetric.Gauge != nil:
+ metricFamily.Type = dto.MetricType_GAUGE.Enum()
+ case dtoMetric.Counter != nil:
+ metricFamily.Type = dto.MetricType_COUNTER.Enum()
+ case dtoMetric.Summary != nil:
+ metricFamily.Type = dto.MetricType_SUMMARY.Enum()
+ case dtoMetric.Untyped != nil:
+ metricFamily.Type = dto.MetricType_UNTYPED.Enum()
+ case dtoMetric.Histogram != nil:
+ metricFamily.Type = dto.MetricType_HISTOGRAM.Enum()
+ default:
+ errs = append(errs, fmt.Errorf(
+ "empty metric collected: %s", dtoMetric,
+ ))
+ continue
+ }
+ metricFamiliesByName[desc.fqName] = metricFamily
+ }
+ if err := checkMetricConsistency(metricFamily, dtoMetric, metricHashes, dimHashes); err != nil {
+ errs = append(errs, err)
+ continue
+ }
+ if r.pedanticChecksEnabled {
+ // Is the desc registered at all?
+ if _, exist := registeredDescIDs[desc.id]; !exist {
+ errs = append(errs, fmt.Errorf(
+ "collected metric %s %s with unregistered descriptor %s",
+ metricFamily.GetName(), dtoMetric, desc,
+ ))
+ continue
+ }
+ if err := checkDescConsistency(metricFamily, dtoMetric, desc); err != nil {
+ errs = append(errs, err)
+ continue
+ }
+ }
+ metricFamily.Metric = append(metricFamily.Metric, dtoMetric)
+ }
+ return normalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
+}
+
+// Gatherers is a slice of Gatherer instances that implements the Gatherer
+// interface itself. Its Gather method calls Gather on all Gatherers in the
+// slice in order and returns the merged results. Errors returned from the
+// Gather calles are all returned in a flattened MultiError. Duplicate and
+// inconsistent Metrics are skipped (first occurrence in slice order wins) and
+// reported in the returned error.
+//
+// Gatherers can be used to merge the Gather results from multiple
+// Registries. It also provides a way to directly inject existing MetricFamily
+// protobufs into the gathering by creating a custom Gatherer with a Gather
+// method that simply returns the existing MetricFamily protobufs. Note that no
+// registration is involved (in contrast to Collector registration), so
+// obviously registration-time checks cannot happen. Any inconsistencies between
+// the gathered MetricFamilies are reported as errors by the Gather method, and
+// inconsistent Metrics are dropped. Invalid parts of the MetricFamilies
+// (e.g. syntactically invalid metric or label names) will go undetected.
+type Gatherers []Gatherer
+
+// Gather implements Gatherer.
+func (gs Gatherers) Gather() ([]*dto.MetricFamily, error) {
+ var (
+ metricFamiliesByName = map[string]*dto.MetricFamily{}
+ metricHashes = map[uint64]struct{}{}
+ dimHashes = map[string]uint64{}
+ errs MultiError // The collected errors to return in the end.
+ )
+
+ for i, g := range gs {
+ mfs, err := g.Gather()
+ if err != nil {
+ if multiErr, ok := err.(MultiError); ok {
+ for _, err := range multiErr {
+ errs = append(errs, fmt.Errorf("[from Gatherer #%d] %s", i+1, err))
+ }
+ } else {
+ errs = append(errs, fmt.Errorf("[from Gatherer #%d] %s", i+1, err))
+ }
+ }
+ for _, mf := range mfs {
+ existingMF, exists := metricFamiliesByName[mf.GetName()]
+ if exists {
+ if existingMF.GetHelp() != mf.GetHelp() {
+ errs = append(errs, fmt.Errorf(
+ "gathered metric family %s has help %q but should have %q",
+ mf.GetName(), mf.GetHelp(), existingMF.GetHelp(),
+ ))
+ continue
+ }
+ if existingMF.GetType() != mf.GetType() {
+ errs = append(errs, fmt.Errorf(
+ "gathered metric family %s has type %s but should have %s",
+ mf.GetName(), mf.GetType(), existingMF.GetType(),
+ ))
+ continue
+ }
+ } else {
+ existingMF = &dto.MetricFamily{}
+ existingMF.Name = mf.Name
+ existingMF.Help = mf.Help
+ existingMF.Type = mf.Type
+ metricFamiliesByName[mf.GetName()] = existingMF
+ }
+ for _, m := range mf.Metric {
+ if err := checkMetricConsistency(existingMF, m, metricHashes, dimHashes); err != nil {
+ errs = append(errs, err)
+ continue
+ }
+ existingMF.Metric = append(existingMF.Metric, m)
+ }
+ }
+ }
+ return normalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
+}
+
+// metricSorter is a sortable slice of *dto.Metric.
+type metricSorter []*dto.Metric
+
+func (s metricSorter) Len() int {
+ return len(s)
+}
+
+func (s metricSorter) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
+}
+
+func (s metricSorter) Less(i, j int) bool {
+ if len(s[i].Label) != len(s[j].Label) {
+ // This should not happen. The metrics are
+ // inconsistent. However, we have to deal with the fact, as
+ // people might use custom collectors or metric family injection
+ // to create inconsistent metrics. So let's simply compare the
+ // number of labels in this case. That will still yield
+ // reproducible sorting.
+ return len(s[i].Label) < len(s[j].Label)
+ }
+ for n, lp := range s[i].Label {
+ vi := lp.GetValue()
+ vj := s[j].Label[n].GetValue()
+ if vi != vj {
+ return vi < vj
+ }
+ }
+
+ // We should never arrive here. Multiple metrics with the same
+ // label set in the same scrape will lead to undefined ingestion
+ // behavior. However, as above, we have to provide stable sorting
+ // here, even for inconsistent metrics. So sort equal metrics
+ // by their timestamp, with missing timestamps (implying "now")
+ // coming last.
+ if s[i].TimestampMs == nil {
+ return false
+ }
+ if s[j].TimestampMs == nil {
+ return true
+ }
+ return s[i].GetTimestampMs() < s[j].GetTimestampMs()
+}
+
+// normalizeMetricFamilies returns a MetricFamily slice whith empty
+// MetricFamilies pruned and the remaining MetricFamilies sorted by name within
+// the slice, with the contained Metrics sorted within each MetricFamily.
+func normalizeMetricFamilies(metricFamiliesByName map[string]*dto.MetricFamily) []*dto.MetricFamily {
+ for _, mf := range metricFamiliesByName {
+ sort.Sort(metricSorter(mf.Metric))
+ }
+ names := make([]string, 0, len(metricFamiliesByName))
+ for name, mf := range metricFamiliesByName {
+ if len(mf.Metric) > 0 {
+ names = append(names, name)
+ }
+ }
+ sort.Strings(names)
+ result := make([]*dto.MetricFamily, 0, len(names))
+ for _, name := range names {
+ result = append(result, metricFamiliesByName[name])
+ }
+ return result
+}
+
+// checkMetricConsistency checks if the provided Metric is consistent with the
+// provided MetricFamily. It also hashed the Metric labels and the MetricFamily
+// name. If the resulting hash is alread in the provided metricHashes, an error
+// is returned. If not, it is added to metricHashes. The provided dimHashes maps
+// MetricFamily names to their dimHash (hashed sorted label names). If dimHashes
+// doesn't yet contain a hash for the provided MetricFamily, it is
+// added. Otherwise, an error is returned if the existing dimHashes in not equal
+// the calculated dimHash.
+func checkMetricConsistency(
+ metricFamily *dto.MetricFamily,
+ dtoMetric *dto.Metric,
+ metricHashes map[uint64]struct{},
+ dimHashes map[string]uint64,
+) error {
+ // Type consistency with metric family.
+ if metricFamily.GetType() == dto.MetricType_GAUGE && dtoMetric.Gauge == nil ||
+ metricFamily.GetType() == dto.MetricType_COUNTER && dtoMetric.Counter == nil ||
+ metricFamily.GetType() == dto.MetricType_SUMMARY && dtoMetric.Summary == nil ||
+ metricFamily.GetType() == dto.MetricType_HISTOGRAM && dtoMetric.Histogram == nil ||
+ metricFamily.GetType() == dto.MetricType_UNTYPED && dtoMetric.Untyped == nil {
+ return fmt.Errorf(
+ "collected metric %s %s is not a %s",
+ metricFamily.GetName(), dtoMetric, metricFamily.GetType(),
+ )
+ }
+
+ // Is the metric unique (i.e. no other metric with the same name and the same label values)?
+ h := hashNew()
+ h = hashAdd(h, metricFamily.GetName())
+ h = hashAddByte(h, separatorByte)
+ dh := hashNew()
+ // Make sure label pairs are sorted. We depend on it for the consistency
+ // check.
+ sort.Sort(LabelPairSorter(dtoMetric.Label))
+ for _, lp := range dtoMetric.Label {
+ h = hashAdd(h, lp.GetValue())
+ h = hashAddByte(h, separatorByte)
+ dh = hashAdd(dh, lp.GetName())
+ dh = hashAddByte(dh, separatorByte)
+ }
+ if _, exists := metricHashes[h]; exists {
+ return fmt.Errorf(
+ "collected metric %s %s was collected before with the same name and label values",
+ metricFamily.GetName(), dtoMetric,
+ )
+ }
+ if dimHash, ok := dimHashes[metricFamily.GetName()]; ok {
+ if dimHash != dh {
+ return fmt.Errorf(
+ "collected metric %s %s has label dimensions inconsistent with previously collected metrics in the same metric family",
+ metricFamily.GetName(), dtoMetric,
+ )
+ }
+ } else {
+ dimHashes[metricFamily.GetName()] = dh
+ }
+ metricHashes[h] = struct{}{}
+ return nil
+}
+
+func checkDescConsistency(
+ metricFamily *dto.MetricFamily,
+ dtoMetric *dto.Metric,
+ desc *Desc,
+) error {
+ // Desc help consistency with metric family help.
+ if metricFamily.GetHelp() != desc.help {
+ return fmt.Errorf(
+ "collected metric %s %s has help %q but should have %q",
+ metricFamily.GetName(), dtoMetric, metricFamily.GetHelp(), desc.help,
+ )
+ }
+
+ // Is the desc consistent with the content of the metric?
+ lpsFromDesc := make([]*dto.LabelPair, 0, len(dtoMetric.Label))
+ lpsFromDesc = append(lpsFromDesc, desc.constLabelPairs...)
+ for _, l := range desc.variableLabels {
+ lpsFromDesc = append(lpsFromDesc, &dto.LabelPair{
+ Name: proto.String(l),
+ })
+ }
+ if len(lpsFromDesc) != len(dtoMetric.Label) {
+ return fmt.Errorf(
+ "labels in collected metric %s %s are inconsistent with descriptor %s",
+ metricFamily.GetName(), dtoMetric, desc,
+ )
+ }
+ sort.Sort(LabelPairSorter(lpsFromDesc))
+ for i, lpFromDesc := range lpsFromDesc {
+ lpFromMetric := dtoMetric.Label[i]
+ if lpFromDesc.GetName() != lpFromMetric.GetName() ||
+ lpFromDesc.Value != nil && lpFromDesc.GetValue() != lpFromMetric.GetValue() {
+ return fmt.Errorf(
+ "labels in collected metric %s %s are inconsistent with descriptor %s",
+ metricFamily.GetName(), dtoMetric, desc,
+ )
+ }
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/summary.go b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/summary.go
rename to vendor/github.com/prometheus/client_golang/prometheus/summary.go
index fe81e004f670cd181e62fc6a6dcf2b9871323cf3..bce05bf9a027621ecb52680c4b04bbdcd81d2262 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/summary.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
@@ -15,7 +15,6 @@ package prometheus
import (
"fmt"
- "hash/fnv"
"math"
"sort"
"sync"
@@ -54,8 +53,8 @@ type Summary interface {
Observe(float64)
}
+// DefObjectives are the default Summary quantile values.
var (
- // DefObjectives are the default Summary quantile values.
DefObjectives = map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}
errQuantileLabelNotAllowed = fmt.Errorf(
@@ -140,11 +139,11 @@ type SummaryOpts struct {
BufCap uint32
}
-// TODO: Great fuck-up with the sliding-window decay algorithm... The Merge
-// method of perk/quantile is actually not working as advertised - and it might
-// be unfixable, as the underlying algorithm is apparently not capable of
-// merging summaries in the first place. To avoid using Merge, we are currently
-// adding observations to _each_ age bucket, i.e. the effort to add a sample is
+// Great fuck-up with the sliding-window decay algorithm... The Merge method of
+// perk/quantile is actually not working as advertised - and it might be
+// unfixable, as the underlying algorithm is apparently not capable of merging
+// summaries in the first place. To avoid using Merge, we are currently adding
+// observations to _each_ age bucket, i.e. the effort to add a sample is
// essentially multiplied by the number of age buckets. When rotating age
// buckets, we empty the previous head stream. On scrape time, we simply take
// the quantiles from the head stream (no merging required). Result: More effort
@@ -228,12 +227,12 @@ func newSummary(desc *Desc, opts SummaryOpts, labelValues ...string) Summary {
}
sort.Float64s(s.sortedObjectives)
- s.Init(s) // Init self-collection.
+ s.init(s) // Init self-collection.
return s
}
type summary struct {
- SelfCollector
+ selfCollector
bufMtx sync.Mutex // Protects hotBuf and hotBufExpTime.
mtx sync.Mutex // Protects every other moving part.
@@ -391,7 +390,7 @@ func (s quantSort) Less(i, j int) bool {
// (e.g. HTTP request latencies, partitioned by status code and method). Create
// instances with NewSummaryVec.
type SummaryVec struct {
- MetricVec
+ *MetricVec
}
// NewSummaryVec creates a new SummaryVec based on the provided SummaryOpts and
@@ -405,14 +404,9 @@ func NewSummaryVec(opts SummaryOpts, labelNames []string) *SummaryVec {
opts.ConstLabels,
)
return &SummaryVec{
- MetricVec: MetricVec{
- children: map[uint64]Metric{},
- desc: desc,
- hash: fnv.New64a(),
- newMetric: func(lvs ...string) Metric {
- return newSummary(desc, opts, lvs...)
- },
- },
+ MetricVec: newMetricVec(desc, func(lvs ...string) Metric {
+ return newSummary(desc, opts, lvs...)
+ }),
}
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/untyped.go b/vendor/github.com/prometheus/client_golang/prometheus/untyped.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/untyped.go
rename to vendor/github.com/prometheus/client_golang/prometheus/untyped.go
index c65ab1c53126e281c6c4dfb9cf871ea7401dc727..5faf7e6e3eba2960e858bb2640f3b276b0b5b837 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/untyped.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/untyped.go
@@ -13,8 +13,6 @@
package prometheus
-import "hash/fnv"
-
// Untyped is a Metric that represents a single numerical value that can
// arbitrarily go up and down.
//
@@ -58,7 +56,7 @@ func NewUntyped(opts UntypedOpts) Untyped {
// labels. This is used if you want to count the same thing partitioned by
// various dimensions. Create instances with NewUntypedVec.
type UntypedVec struct {
- MetricVec
+ *MetricVec
}
// NewUntypedVec creates a new UntypedVec based on the provided UntypedOpts and
@@ -72,14 +70,9 @@ func NewUntypedVec(opts UntypedOpts, labelNames []string) *UntypedVec {
opts.ConstLabels,
)
return &UntypedVec{
- MetricVec: MetricVec{
- children: map[uint64]Metric{},
- desc: desc,
- hash: fnv.New64a(),
- newMetric: func(lvs ...string) Metric {
- return newValue(desc, UntypedValue, 0, lvs...)
- },
- },
+ MetricVec: newMetricVec(desc, func(lvs ...string) Metric {
+ return newValue(desc, UntypedValue, 0, lvs...)
+ }),
}
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/value.go b/vendor/github.com/prometheus/client_golang/prometheus/value.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/value.go
rename to vendor/github.com/prometheus/client_golang/prometheus/value.go
index b54ac11e888ee86b65c67fed54ed749f3f345e29..a944c37754fefc1b79eced52b667f55e417c73ae 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/value.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/value.go
@@ -48,7 +48,7 @@ type value struct {
// operations. http://golang.org/pkg/sync/atomic/#pkg-note-BUG
valBits uint64
- SelfCollector
+ selfCollector
desc *Desc
valType ValueType
@@ -68,7 +68,7 @@ func newValue(desc *Desc, valueType ValueType, val float64, labelValues ...strin
valBits: math.Float64bits(val),
labelPairs: makeLabelPairs(desc, labelValues),
}
- result.Init(result)
+ result.init(result)
return result
}
@@ -113,7 +113,7 @@ func (v *value) Write(out *dto.Metric) error {
// library to back the implementations of CounterFunc, GaugeFunc, and
// UntypedFunc.
type valueFunc struct {
- SelfCollector
+ selfCollector
desc *Desc
valType ValueType
@@ -134,7 +134,7 @@ func newValueFunc(desc *Desc, valueType ValueType, function func() float64) *val
function: function,
labelPairs: makeLabelPairs(desc, nil),
}
- result.Init(result)
+ result.init(result)
return result
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/vec.go b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
similarity index 54%
rename from Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/vec.go
rename to vendor/github.com/prometheus/client_golang/prometheus/vec.go
index a1f3bdf37d83266a29d43e161bb46181e0e05d4c..7f3eef9a46707813913a49bc466528ccd87a6c2f 100644
--- a/Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/vec.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
@@ -14,10 +14,10 @@
package prometheus
import (
- "bytes"
"fmt"
- "hash"
"sync"
+
+ "github.com/prometheus/common/model"
)
// MetricVec is a Collector to bundle metrics of the same name that
@@ -26,17 +26,32 @@ import (
// type. GaugeVec, CounterVec, SummaryVec, and UntypedVec are examples already
// provided in this package.
type MetricVec struct {
- mtx sync.RWMutex // Protects not only children, but also hash and buf.
- children map[uint64]Metric
+ mtx sync.RWMutex // Protects the children.
+ children map[uint64][]metricWithLabelValues
desc *Desc
- // hash is our own hash instance to avoid repeated allocations.
- hash hash.Hash64
- // buf is used to copy string contents into it for hashing,
- // again to avoid allocations.
- buf bytes.Buffer
+ newMetric func(labelValues ...string) Metric
+ hashAdd func(h uint64, s string) uint64 // replace hash function for testing collision handling
+ hashAddByte func(h uint64, b byte) uint64
+}
+
+// newMetricVec returns an initialized MetricVec. The concrete value is
+// returned for embedding into another struct.
+func newMetricVec(desc *Desc, newMetric func(lvs ...string) Metric) *MetricVec {
+ return &MetricVec{
+ children: map[uint64][]metricWithLabelValues{},
+ desc: desc,
+ newMetric: newMetric,
+ hashAdd: hashAdd,
+ hashAddByte: hashAddByte,
+ }
+}
- newMetric func(labelValues ...string) Metric
+// metricWithLabelValues provides the metric and its label values for
+// disambiguation on hash collision.
+type metricWithLabelValues struct {
+ values []string
+ metric Metric
}
// Describe implements Collector. The length of the returned slice
@@ -50,8 +65,10 @@ func (m *MetricVec) Collect(ch chan<- Metric) {
m.mtx.RLock()
defer m.mtx.RUnlock()
- for _, metric := range m.children {
- ch <- metric
+ for _, metrics := range m.children {
+ for _, metric := range metrics {
+ ch <- metric.metric
+ }
}
}
@@ -80,14 +97,12 @@ func (m *MetricVec) Collect(ch chan<- Metric) {
// with a performance overhead (for creating and processing the Labels map).
// See also the GaugeVec example.
func (m *MetricVec) GetMetricWithLabelValues(lvs ...string) (Metric, error) {
- m.mtx.Lock()
- defer m.mtx.Unlock()
-
h, err := m.hashLabelValues(lvs)
if err != nil {
return nil, err
}
- return m.getOrCreateMetric(h, lvs...), nil
+
+ return m.getOrCreateMetricWithLabelValues(h, lvs), nil
}
// GetMetricWith returns the Metric for the given Labels map (the label names
@@ -103,18 +118,12 @@ func (m *MetricVec) GetMetricWithLabelValues(lvs ...string) (Metric, error) {
// GetMetricWithLabelValues(...string). See there for pros and cons of the two
// methods.
func (m *MetricVec) GetMetricWith(labels Labels) (Metric, error) {
- m.mtx.Lock()
- defer m.mtx.Unlock()
-
h, err := m.hashLabels(labels)
if err != nil {
return nil, err
}
- lvs := make([]string, len(labels))
- for i, label := range m.desc.variableLabels {
- lvs[i] = labels[label]
- }
- return m.getOrCreateMetric(h, lvs...), nil
+
+ return m.getOrCreateMetricWithLabels(h, labels), nil
}
// WithLabelValues works as GetMetricWithLabelValues, but panics if an error
@@ -162,11 +171,7 @@ func (m *MetricVec) DeleteLabelValues(lvs ...string) bool {
if err != nil {
return false
}
- if _, has := m.children[h]; !has {
- return false
- }
- delete(m.children, h)
- return true
+ return m.deleteByHashWithLabelValues(h, lvs)
}
// Delete deletes the metric where the variable labels are the same as those
@@ -187,10 +192,50 @@ func (m *MetricVec) Delete(labels Labels) bool {
if err != nil {
return false
}
- if _, has := m.children[h]; !has {
+
+ return m.deleteByHashWithLabels(h, labels)
+}
+
+// deleteByHashWithLabelValues removes the metric from the hash bucket h. If
+// there are multiple matches in the bucket, use lvs to select a metric and
+// remove only that metric.
+func (m *MetricVec) deleteByHashWithLabelValues(h uint64, lvs []string) bool {
+ metrics, ok := m.children[h]
+ if !ok {
return false
}
- delete(m.children, h)
+
+ i := m.findMetricWithLabelValues(metrics, lvs)
+ if i >= len(metrics) {
+ return false
+ }
+
+ if len(metrics) > 1 {
+ m.children[h] = append(metrics[:i], metrics[i+1:]...)
+ } else {
+ delete(m.children, h)
+ }
+ return true
+}
+
+// deleteByHashWithLabels removes the metric from the hash bucket h. If there
+// are multiple matches in the bucket, use lvs to select a metric and remove
+// only that metric.
+func (m *MetricVec) deleteByHashWithLabels(h uint64, labels Labels) bool {
+ metrics, ok := m.children[h]
+ if !ok {
+ return false
+ }
+ i := m.findMetricWithLabels(metrics, labels)
+ if i >= len(metrics) {
+ return false
+ }
+
+ if len(metrics) > 1 {
+ m.children[h] = append(metrics[:i], metrics[i+1:]...)
+ } else {
+ delete(m.children, h)
+ }
return true
}
@@ -208,40 +253,152 @@ func (m *MetricVec) hashLabelValues(vals []string) (uint64, error) {
if len(vals) != len(m.desc.variableLabels) {
return 0, errInconsistentCardinality
}
- m.hash.Reset()
+ h := hashNew()
for _, val := range vals {
- m.buf.Reset()
- m.buf.WriteString(val)
- m.hash.Write(m.buf.Bytes())
+ h = m.hashAdd(h, val)
+ h = m.hashAddByte(h, model.SeparatorByte)
}
- return m.hash.Sum64(), nil
+ return h, nil
}
func (m *MetricVec) hashLabels(labels Labels) (uint64, error) {
if len(labels) != len(m.desc.variableLabels) {
return 0, errInconsistentCardinality
}
- m.hash.Reset()
+ h := hashNew()
for _, label := range m.desc.variableLabels {
val, ok := labels[label]
if !ok {
return 0, fmt.Errorf("label name %q missing in label map", label)
}
- m.buf.Reset()
- m.buf.WriteString(val)
- m.hash.Write(m.buf.Bytes())
+ h = m.hashAdd(h, val)
+ h = m.hashAddByte(h, model.SeparatorByte)
}
- return m.hash.Sum64(), nil
+ return h, nil
}
-func (m *MetricVec) getOrCreateMetric(hash uint64, labelValues ...string) Metric {
- metric, ok := m.children[hash]
+// getOrCreateMetricWithLabelValues retrieves the metric by hash and label value
+// or creates it and returns the new one.
+//
+// This function holds the mutex.
+func (m *MetricVec) getOrCreateMetricWithLabelValues(hash uint64, lvs []string) Metric {
+ m.mtx.RLock()
+ metric, ok := m.getMetricWithLabelValues(hash, lvs)
+ m.mtx.RUnlock()
+ if ok {
+ return metric
+ }
+
+ m.mtx.Lock()
+ defer m.mtx.Unlock()
+ metric, ok = m.getMetricWithLabelValues(hash, lvs)
if !ok {
- // Copy labelValues. Otherwise, they would be allocated even if we don't go
- // down this code path.
- copiedLabelValues := append(make([]string, 0, len(labelValues)), labelValues...)
- metric = m.newMetric(copiedLabelValues...)
- m.children[hash] = metric
+ // Copy to avoid allocation in case wo don't go down this code path.
+ copiedLVs := make([]string, len(lvs))
+ copy(copiedLVs, lvs)
+ metric = m.newMetric(copiedLVs...)
+ m.children[hash] = append(m.children[hash], metricWithLabelValues{values: copiedLVs, metric: metric})
}
return metric
}
+
+// getOrCreateMetricWithLabelValues retrieves the metric by hash and label value
+// or creates it and returns the new one.
+//
+// This function holds the mutex.
+func (m *MetricVec) getOrCreateMetricWithLabels(hash uint64, labels Labels) Metric {
+ m.mtx.RLock()
+ metric, ok := m.getMetricWithLabels(hash, labels)
+ m.mtx.RUnlock()
+ if ok {
+ return metric
+ }
+
+ m.mtx.Lock()
+ defer m.mtx.Unlock()
+ metric, ok = m.getMetricWithLabels(hash, labels)
+ if !ok {
+ lvs := m.extractLabelValues(labels)
+ metric = m.newMetric(lvs...)
+ m.children[hash] = append(m.children[hash], metricWithLabelValues{values: lvs, metric: metric})
+ }
+ return metric
+}
+
+// getMetricWithLabelValues gets a metric while handling possible collisions in
+// the hash space. Must be called while holding read mutex.
+func (m *MetricVec) getMetricWithLabelValues(h uint64, lvs []string) (Metric, bool) {
+ metrics, ok := m.children[h]
+ if ok {
+ if i := m.findMetricWithLabelValues(metrics, lvs); i < len(metrics) {
+ return metrics[i].metric, true
+ }
+ }
+ return nil, false
+}
+
+// getMetricWithLabels gets a metric while handling possible collisions in
+// the hash space. Must be called while holding read mutex.
+func (m *MetricVec) getMetricWithLabels(h uint64, labels Labels) (Metric, bool) {
+ metrics, ok := m.children[h]
+ if ok {
+ if i := m.findMetricWithLabels(metrics, labels); i < len(metrics) {
+ return metrics[i].metric, true
+ }
+ }
+ return nil, false
+}
+
+// findMetricWithLabelValues returns the index of the matching metric or
+// len(metrics) if not found.
+func (m *MetricVec) findMetricWithLabelValues(metrics []metricWithLabelValues, lvs []string) int {
+ for i, metric := range metrics {
+ if m.matchLabelValues(metric.values, lvs) {
+ return i
+ }
+ }
+ return len(metrics)
+}
+
+// findMetricWithLabels returns the index of the matching metric or len(metrics)
+// if not found.
+func (m *MetricVec) findMetricWithLabels(metrics []metricWithLabelValues, labels Labels) int {
+ for i, metric := range metrics {
+ if m.matchLabels(metric.values, labels) {
+ return i
+ }
+ }
+ return len(metrics)
+}
+
+func (m *MetricVec) matchLabelValues(values []string, lvs []string) bool {
+ if len(values) != len(lvs) {
+ return false
+ }
+ for i, v := range values {
+ if v != lvs[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func (m *MetricVec) matchLabels(values []string, labels Labels) bool {
+ if len(labels) != len(values) {
+ return false
+ }
+ for i, k := range m.desc.variableLabels {
+ if values[i] != labels[k] {
+ return false
+ }
+ }
+ return true
+}
+
+func (m *MetricVec) extractLabelValues(labels Labels) []string {
+ labelValues := make([]string, len(labels))
+ for i, k := range m.desc.variableLabels {
+ labelValues[i] = labels[k]
+ }
+ return labelValues
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_model/LICENSE b/vendor/github.com/prometheus/client_model/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/client_model/LICENSE
rename to vendor/github.com/prometheus/client_model/LICENSE
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_model/NOTICE b/vendor/github.com/prometheus/client_model/NOTICE
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/client_model/NOTICE
rename to vendor/github.com/prometheus/client_model/NOTICE
diff --git a/Godeps/_workspace/src/github.com/prometheus/client_model/go/metrics.pb.go b/vendor/github.com/prometheus/client_model/go/metrics.pb.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/client_model/go/metrics.pb.go
rename to vendor/github.com/prometheus/client_model/go/metrics.pb.go
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/LICENSE b/vendor/github.com/prometheus/common/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/LICENSE
rename to vendor/github.com/prometheus/common/LICENSE
diff --git a/vendor/github.com/prometheus/common/NOTICE b/vendor/github.com/prometheus/common/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..636a2c1a5e88f09e6549b8a6d013cd7d7eb19c7e
--- /dev/null
+++ b/vendor/github.com/prometheus/common/NOTICE
@@ -0,0 +1,5 @@
+Common libraries shared by Prometheus Go components.
+Copyright 2015 The Prometheus Authors
+
+This product includes software developed at
+SoundCloud Ltd. (http://soundcloud.com/).
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/decode.go b/vendor/github.com/prometheus/common/expfmt/decode.go
similarity index 86%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/decode.go
rename to vendor/github.com/prometheus/common/expfmt/decode.go
index d36f0ecebcbb3b6dad23fb0f2ab1771eedc92661..487fdc6cca9e6c8cac075d060e0e9bbfa4d4498a 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/decode.go
+++ b/vendor/github.com/prometheus/common/expfmt/decode.go
@@ -37,66 +37,45 @@ type DecodeOptions struct {
}
// ResponseFormat extracts the correct format from a HTTP response header.
-func ResponseFormat(h http.Header) (Format, error) {
+// If no matching format can be found FormatUnknown is returned.
+func ResponseFormat(h http.Header) Format {
ct := h.Get(hdrContentType)
mediatype, params, err := mime.ParseMediaType(ct)
if err != nil {
- return "", fmt.Errorf("invalid Content-Type header %q: %s", ct, err)
+ return FmtUnknown
}
- const (
- textType = "text/plain"
- jsonType = "application/json"
- )
+ const textType = "text/plain"
switch mediatype {
case ProtoType:
- if p := params["proto"]; p != ProtoProtocol {
- return "", fmt.Errorf("unrecognized protocol message %s", p)
+ if p, ok := params["proto"]; ok && p != ProtoProtocol {
+ return FmtUnknown
}
- if e := params["encoding"]; e != "delimited" {
- return "", fmt.Errorf("unsupported encoding %s", e)
+ if e, ok := params["encoding"]; ok && e != "delimited" {
+ return FmtUnknown
}
- return FmtProtoDelim, nil
+ return FmtProtoDelim
case textType:
if v, ok := params["version"]; ok && v != TextVersion {
- return "", fmt.Errorf("unrecognized protocol version %s", v)
- }
- return FmtText, nil
-
- case jsonType:
- var prometheusAPIVersion string
-
- if params["schema"] == "prometheus/telemetry" && params["version"] != "" {
- prometheusAPIVersion = params["version"]
- } else {
- prometheusAPIVersion = h.Get("X-Prometheus-API-Version")
- }
-
- switch prometheusAPIVersion {
- case "0.0.2":
- return FmtJSON2, nil
- default:
- return "", fmt.Errorf("unrecognized API version %s", prometheusAPIVersion)
+ return FmtUnknown
}
+ return FmtText
}
- return "", fmt.Errorf("unsupported media type %q, expected %q or %q", mediatype, ProtoType, textType)
+ return FmtUnknown
}
-// NewDecoder returns a new decoder based on the HTTP header.
-func NewDecoder(r io.Reader, format Format) (Decoder, error) {
+// NewDecoder returns a new decoder based on the given input format.
+// If the input format does not imply otherwise, a text format decoder is returned.
+func NewDecoder(r io.Reader, format Format) Decoder {
switch format {
case FmtProtoDelim:
- return &protoDecoder{r: r}, nil
- case FmtText:
- return &textDecoder{r: r}, nil
- case FmtJSON2:
- return newJSON2Decoder(r), nil
+ return &protoDecoder{r: r}
}
- return nil, fmt.Errorf("unsupported decoding format %q", format)
+ return &textDecoder{r: r}
}
// protoDecoder implements the Decoder interface for protocol buffers.
@@ -107,10 +86,32 @@ type protoDecoder struct {
// Decode implements the Decoder interface.
func (d *protoDecoder) Decode(v *dto.MetricFamily) error {
_, err := pbutil.ReadDelimited(d.r, v)
- return err
+ if err != nil {
+ return err
+ }
+ if !model.IsValidMetricName(model.LabelValue(v.GetName())) {
+ return fmt.Errorf("invalid metric name %q", v.GetName())
+ }
+ for _, m := range v.GetMetric() {
+ if m == nil {
+ continue
+ }
+ for _, l := range m.GetLabel() {
+ if l == nil {
+ continue
+ }
+ if !model.LabelValue(l.GetValue()).IsValid() {
+ return fmt.Errorf("invalid label value %q", l.GetValue())
+ }
+ if !model.LabelName(l.GetName()).IsValid() {
+ return fmt.Errorf("invalid label name %q", l.GetName())
+ }
+ }
+ }
+ return nil
}
-// textDecoder implements the Decoder interface for the text protcol.
+// textDecoder implements the Decoder interface for the text protocol.
type textDecoder struct {
r io.Reader
p TextParser
@@ -129,13 +130,14 @@ func (d *textDecoder) Decode(v *dto.MetricFamily) error {
if len(fams) == 0 {
return io.EOF
}
+ d.fams = make([]*dto.MetricFamily, 0, len(fams))
for _, f := range fams {
d.fams = append(d.fams, f)
}
}
- *v = *d.fams[len(d.fams)-1]
- d.fams = d.fams[:len(d.fams)-1]
+ *v = *d.fams[0]
+ d.fams = d.fams[1:]
return nil
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/encode.go b/vendor/github.com/prometheus/common/expfmt/encode.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/encode.go
rename to vendor/github.com/prometheus/common/expfmt/encode.go
index 392ca90ee2572222559151ae3ba564a92c424c92..11839ed65ce379ae46aa8e6c1d513cf334d95b0c 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/encode.go
+++ b/vendor/github.com/prometheus/common/expfmt/encode.go
@@ -18,9 +18,9 @@ import (
"io"
"net/http"
- "bitbucket.org/ww/goautoneg"
"github.com/golang/protobuf/proto"
"github.com/matttproud/golang_protobuf_extensions/pbutil"
+ "github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg"
dto "github.com/prometheus/client_model/go"
)
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/expfmt.go b/vendor/github.com/prometheus/common/expfmt/expfmt.go
similarity index 90%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/expfmt.go
rename to vendor/github.com/prometheus/common/expfmt/expfmt.go
index 3637dd7661d712b62047a4f8f36a344a8ff85d2b..366fbde98a154461cdf958950e35153c3cf6d27d 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/expfmt.go
+++ b/vendor/github.com/prometheus/common/expfmt/expfmt.go
@@ -24,11 +24,14 @@ const (
ProtoFmt = ProtoType + "; proto=" + ProtoProtocol + ";"
// The Content-Type values for the different wire protocols.
+ FmtUnknown Format = `<unknown>`
FmtText Format = `text/plain; version=` + TextVersion
FmtProtoDelim Format = ProtoFmt + ` encoding=delimited`
FmtProtoText Format = ProtoFmt + ` encoding=text`
FmtProtoCompact Format = ProtoFmt + ` encoding=compact-text`
- FmtJSON2 Format = `application/json; version=0.0.2`
+
+ // fmtJSON2 is hidden as it is deprecated.
+ fmtJSON2 Format = `application/json; version=0.0.2`
)
const (
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/fuzz.go b/vendor/github.com/prometheus/common/expfmt/fuzz.go
similarity index 89%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/fuzz.go
rename to vendor/github.com/prometheus/common/expfmt/fuzz.go
index 14f920146921a8113ae210c5fe927281342a8605..dc2eedeefcac4ce1e383ec529c1043e6f0c6bad2 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/fuzz.go
+++ b/vendor/github.com/prometheus/common/expfmt/fuzz.go
@@ -20,8 +20,8 @@ import "bytes"
// Fuzz text metric parser with with github.com/dvyukov/go-fuzz:
//
-// go-fuzz-build github.com/prometheus/client_golang/text
-// go-fuzz -bin text-fuzz.zip -workdir fuzz
+// go-fuzz-build github.com/prometheus/common/expfmt
+// go-fuzz -bin expfmt-fuzz.zip -workdir fuzz
//
// Further input samples should go in the folder fuzz/corpus.
func Fuzz(in []byte) int {
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_create.go b/vendor/github.com/prometheus/common/expfmt/text_create.go
similarity index 95%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_create.go
rename to vendor/github.com/prometheus/common/expfmt/text_create.go
index 0bb9c14cc2b672b88f7f53de7c0653f8f68091f6..1e060879e1d3008fbd84fab5450f186cd96b0c30 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_create.go
+++ b/vendor/github.com/prometheus/common/expfmt/text_create.go
@@ -14,7 +14,6 @@
package expfmt
import (
- "bytes"
"fmt"
"io"
"math"
@@ -285,21 +284,17 @@ func labelPairsToText(
return written, nil
}
+var (
+ escape = strings.NewReplacer("\\", `\\`, "\n", `\n`)
+ escapeWithDoubleQuote = strings.NewReplacer("\\", `\\`, "\n", `\n`, "\"", `\"`)
+)
+
// escapeString replaces '\' by '\\', new line character by '\n', and - if
// includeDoubleQuote is true - '"' by '\"'.
func escapeString(v string, includeDoubleQuote bool) string {
- result := bytes.NewBuffer(make([]byte, 0, len(v)))
- for _, c := range v {
- switch {
- case c == '\\':
- result.WriteString(`\\`)
- case includeDoubleQuote && c == '"':
- result.WriteString(`\"`)
- case c == '\n':
- result.WriteString(`\n`)
- default:
- result.WriteRune(c)
- }
+ if includeDoubleQuote {
+ return escapeWithDoubleQuote.Replace(v)
}
- return result.String()
+
+ return escape.Replace(v)
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_parse.go b/vendor/github.com/prometheus/common/expfmt/text_parse.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_parse.go
rename to vendor/github.com/prometheus/common/expfmt/text_parse.go
index 84433bc4f6efd9ce71adc7ac0809c93f21dcb1f5..bd170b1675f897770af7aa622df29f94f90c8634 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_parse.go
+++ b/vendor/github.com/prometheus/common/expfmt/text_parse.go
@@ -108,6 +108,13 @@ func (p *TextParser) TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricF
delete(p.metricFamiliesByName, k)
}
}
+ // If p.err is io.EOF now, we have run into a premature end of the input
+ // stream. Turn this error into something nicer and more
+ // meaningful. (io.EOF is often used as a signal for the legitimate end
+ // of an input stream.)
+ if p.err == io.EOF {
+ p.parseError("unexpected end of input stream")
+ }
return p.metricFamiliesByName, p.err
}
diff --git a/Godeps/_workspace/src/bitbucket.org/ww/goautoneg/README.txt b/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/README.txt
similarity index 100%
rename from Godeps/_workspace/src/bitbucket.org/ww/goautoneg/README.txt
rename to vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/README.txt
diff --git a/Godeps/_workspace/src/bitbucket.org/ww/goautoneg/autoneg.go b/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go
similarity index 100%
rename from Godeps/_workspace/src/bitbucket.org/ww/goautoneg/autoneg.go
rename to vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go
diff --git a/vendor/github.com/prometheus/common/model/alert.go b/vendor/github.com/prometheus/common/model/alert.go
new file mode 100644
index 0000000000000000000000000000000000000000..35e739c7ad21533593a4e1338ac5621aa5c3cec7
--- /dev/null
+++ b/vendor/github.com/prometheus/common/model/alert.go
@@ -0,0 +1,136 @@
+// Copyright 2013 The Prometheus 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 model
+
+import (
+ "fmt"
+ "time"
+)
+
+type AlertStatus string
+
+const (
+ AlertFiring AlertStatus = "firing"
+ AlertResolved AlertStatus = "resolved"
+)
+
+// Alert is a generic representation of an alert in the Prometheus eco-system.
+type Alert struct {
+ // Label value pairs for purpose of aggregation, matching, and disposition
+ // dispatching. This must minimally include an "alertname" label.
+ Labels LabelSet `json:"labels"`
+
+ // Extra key/value information which does not define alert identity.
+ Annotations LabelSet `json:"annotations"`
+
+ // The known time range for this alert. Both ends are optional.
+ StartsAt time.Time `json:"startsAt,omitempty"`
+ EndsAt time.Time `json:"endsAt,omitempty"`
+ GeneratorURL string `json:"generatorURL"`
+}
+
+// Name returns the name of the alert. It is equivalent to the "alertname" label.
+func (a *Alert) Name() string {
+ return string(a.Labels[AlertNameLabel])
+}
+
+// Fingerprint returns a unique hash for the alert. It is equivalent to
+// the fingerprint of the alert's label set.
+func (a *Alert) Fingerprint() Fingerprint {
+ return a.Labels.Fingerprint()
+}
+
+func (a *Alert) String() string {
+ s := fmt.Sprintf("%s[%s]", a.Name(), a.Fingerprint().String()[:7])
+ if a.Resolved() {
+ return s + "[resolved]"
+ }
+ return s + "[active]"
+}
+
+// Resolved returns true iff the activity interval ended in the past.
+func (a *Alert) Resolved() bool {
+ return a.ResolvedAt(time.Now())
+}
+
+// ResolvedAt returns true off the activity interval ended before
+// the given timestamp.
+func (a *Alert) ResolvedAt(ts time.Time) bool {
+ if a.EndsAt.IsZero() {
+ return false
+ }
+ return !a.EndsAt.After(ts)
+}
+
+// Status returns the status of the alert.
+func (a *Alert) Status() AlertStatus {
+ if a.Resolved() {
+ return AlertResolved
+ }
+ return AlertFiring
+}
+
+// Validate checks whether the alert data is inconsistent.
+func (a *Alert) Validate() error {
+ if a.StartsAt.IsZero() {
+ return fmt.Errorf("start time missing")
+ }
+ if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {
+ return fmt.Errorf("start time must be before end time")
+ }
+ if err := a.Labels.Validate(); err != nil {
+ return fmt.Errorf("invalid label set: %s", err)
+ }
+ if len(a.Labels) == 0 {
+ return fmt.Errorf("at least one label pair required")
+ }
+ if err := a.Annotations.Validate(); err != nil {
+ return fmt.Errorf("invalid annotations: %s", err)
+ }
+ return nil
+}
+
+// Alert is a list of alerts that can be sorted in chronological order.
+type Alerts []*Alert
+
+func (as Alerts) Len() int { return len(as) }
+func (as Alerts) Swap(i, j int) { as[i], as[j] = as[j], as[i] }
+
+func (as Alerts) Less(i, j int) bool {
+ if as[i].StartsAt.Before(as[j].StartsAt) {
+ return true
+ }
+ if as[i].EndsAt.Before(as[j].EndsAt) {
+ return true
+ }
+ return as[i].Fingerprint() < as[j].Fingerprint()
+}
+
+// HasFiring returns true iff one of the alerts is not resolved.
+func (as Alerts) HasFiring() bool {
+ for _, a := range as {
+ if !a.Resolved() {
+ return true
+ }
+ }
+ return false
+}
+
+// Status returns StatusFiring iff at least one of the alerts is firing.
+func (as Alerts) Status() AlertStatus {
+ if as.HasFiring() {
+ return AlertFiring
+ }
+ return AlertResolved
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/fingerprinting.go b/vendor/github.com/prometheus/common/model/fingerprinting.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/fingerprinting.go
rename to vendor/github.com/prometheus/common/model/fingerprinting.go
diff --git a/vendor/github.com/prometheus/common/model/fnv.go b/vendor/github.com/prometheus/common/model/fnv.go
new file mode 100644
index 0000000000000000000000000000000000000000..038fc1c9003caa6b5412202fac52e8e5e5ec8809
--- /dev/null
+++ b/vendor/github.com/prometheus/common/model/fnv.go
@@ -0,0 +1,42 @@
+// Copyright 2015 The Prometheus 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 model
+
+// Inline and byte-free variant of hash/fnv's fnv64a.
+
+const (
+ offset64 = 14695981039346656037
+ prime64 = 1099511628211
+)
+
+// hashNew initializies a new fnv64a hash value.
+func hashNew() uint64 {
+ return offset64
+}
+
+// hashAdd adds a string to a fnv64a hash value, returning the updated hash.
+func hashAdd(h uint64, s string) uint64 {
+ for i := 0; i < len(s); i++ {
+ h ^= uint64(s[i])
+ h *= prime64
+ }
+ return h
+}
+
+// hashAddByte adds a byte to a fnv64a hash value, returning the updated hash.
+func hashAddByte(h uint64, b byte) uint64 {
+ h ^= uint64(b)
+ h *= prime64
+ return h
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/labels.go b/vendor/github.com/prometheus/common/model/labels.go
similarity index 90%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/labels.go
rename to vendor/github.com/prometheus/common/model/labels.go
index 6459c8f791b55064591c240a605e43777012a207..3b72e7ff8f6cf751e84beec863e4f47dd86d9c91 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/labels.go
+++ b/vendor/github.com/prometheus/common/model/labels.go
@@ -17,8 +17,8 @@ import (
"encoding/json"
"fmt"
"regexp"
- "sort"
"strings"
+ "unicode/utf8"
)
const (
@@ -87,6 +87,19 @@ var LabelNameRE = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
// therewith.
type LabelName string
+// IsValid is true iff the label name matches the pattern of LabelNameRE.
+func (ln LabelName) IsValid() bool {
+ if len(ln) == 0 {
+ return false
+ }
+ for i, b := range ln {
+ if !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || (b >= '0' && b <= '9' && i > 0)) {
+ return false
+ }
+ }
+ return true
+}
+
// UnmarshalYAML implements the yaml.Unmarshaler interface.
func (ln *LabelName) UnmarshalYAML(unmarshal func(interface{}) error) error {
var s string
@@ -139,6 +152,11 @@ func (l LabelNames) String() string {
// A LabelValue is an associated value for a LabelName.
type LabelValue string
+// IsValid returns true iff the string is a valid UTF8.
+func (lv LabelValue) IsValid() bool {
+ return utf8.ValidString(string(lv))
+}
+
// LabelValues is a sortable LabelValue slice. It implements sort.Interface.
type LabelValues []LabelValue
@@ -147,7 +165,7 @@ func (l LabelValues) Len() int {
}
func (l LabelValues) Less(i, j int) bool {
- return sort.StringsAreSorted([]string{string(l[i]), string(l[j])})
+ return string(l[i]) < string(l[j])
}
func (l LabelValues) Swap(i, j int) {
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/labelset.go b/vendor/github.com/prometheus/common/model/labelset.go
similarity index 90%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/labelset.go
rename to vendor/github.com/prometheus/common/model/labelset.go
index 142b9d1e2d3ad63312198ee05c10ccc436fab22b..5f931cdb9b3ab63415a7b7ed60bb7765f48d46ac 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/labelset.go
+++ b/vendor/github.com/prometheus/common/model/labelset.go
@@ -27,6 +27,21 @@ import (
// match.
type LabelSet map[LabelName]LabelValue
+// Validate checks whether all names and values in the label set
+// are valid.
+func (ls LabelSet) Validate() error {
+ for ln, lv := range ls {
+ if !ln.IsValid() {
+ return fmt.Errorf("invalid name %q", ln)
+ }
+ if !lv.IsValid() {
+ return fmt.Errorf("invalid value %q", lv)
+ }
+ }
+ return nil
+}
+
+// Equal returns true iff both label sets have exactly the same key/value pairs.
func (ls LabelSet) Equal(o LabelSet) bool {
if len(ls) != len(o) {
return false
@@ -90,6 +105,7 @@ func (ls LabelSet) Before(o LabelSet) bool {
return false
}
+// Clone returns a copy of the label set.
func (ls LabelSet) Clone() LabelSet {
lsn := make(LabelSet, len(ls))
for ln, lv := range ls {
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/metric.go b/vendor/github.com/prometheus/common/model/metric.go
similarity index 82%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/metric.go
rename to vendor/github.com/prometheus/common/model/metric.go
index 25fc3c942585afe51421769b7762fdd0dee44632..a5da59a5055e519d3c588edebe4e3b502af5aab2 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/metric.go
+++ b/vendor/github.com/prometheus/common/model/metric.go
@@ -15,11 +15,15 @@ package model
import (
"fmt"
+ "regexp"
"sort"
"strings"
)
-var separator = []byte{0}
+var (
+ separator = []byte{0}
+ MetricNameRE = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_:]*$`)
+)
// A Metric is similar to a LabelSet, but the key difference is that a Metric is
// a singleton and refers to one and only one stream of samples.
@@ -79,3 +83,16 @@ func (m Metric) Fingerprint() Fingerprint {
func (m Metric) FastFingerprint() Fingerprint {
return LabelSet(m).FastFingerprint()
}
+
+// IsValidMetricName returns true iff name matches the pattern of MetricNameRE.
+func IsValidMetricName(n LabelValue) bool {
+ if len(n) == 0 {
+ return false
+ }
+ for i, b := range n {
+ if !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || b == ':' || (b >= '0' && b <= '9' && i > 0)) {
+ return false
+ }
+ }
+ return true
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/model.go b/vendor/github.com/prometheus/common/model/model.go
similarity index 94%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/model.go
rename to vendor/github.com/prometheus/common/model/model.go
index 88f013a47a41b6a3abb23a894d3670630a778116..a7b9691707e83b9302f16aa56dbbb6ff3c5f7a25 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/model.go
+++ b/vendor/github.com/prometheus/common/model/model.go
@@ -12,5 +12,5 @@
// limitations under the License.
// Package model contains common data structures that are shared across
-// Prometheus componenets and libraries.
+// Prometheus components and libraries.
package model
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/signature.go b/vendor/github.com/prometheus/common/model/signature.go
similarity index 67%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/signature.go
rename to vendor/github.com/prometheus/common/model/signature.go
index 28f370065a9e58d06908b46434ac760125c6b79a..8762b13c63d1ac239db221d6437170ff77c11877 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/signature.go
+++ b/vendor/github.com/prometheus/common/model/signature.go
@@ -14,11 +14,7 @@
package model
import (
- "bytes"
- "hash"
- "hash/fnv"
"sort"
- "sync"
)
// SeparatorByte is a byte that cannot occur in valid UTF-8 sequences and is
@@ -28,30 +24,9 @@ const SeparatorByte byte = 255
var (
// cache the signature of an empty label set.
- emptyLabelSignature = fnv.New64a().Sum64()
-
- hashAndBufPool sync.Pool
+ emptyLabelSignature = hashNew()
)
-type hashAndBuf struct {
- h hash.Hash64
- b bytes.Buffer
-}
-
-func getHashAndBuf() *hashAndBuf {
- hb := hashAndBufPool.Get()
- if hb == nil {
- return &hashAndBuf{h: fnv.New64a()}
- }
- return hb.(*hashAndBuf)
-}
-
-func putHashAndBuf(hb *hashAndBuf) {
- hb.h.Reset()
- hb.b.Reset()
- hashAndBufPool.Put(hb)
-}
-
// LabelsToSignature returns a quasi-unique signature (i.e., fingerprint) for a
// given label set. (Collisions are possible but unlikely if the number of label
// sets the function is applied to is small.)
@@ -66,18 +41,14 @@ func LabelsToSignature(labels map[string]string) uint64 {
}
sort.Strings(labelNames)
- hb := getHashAndBuf()
- defer putHashAndBuf(hb)
-
+ sum := hashNew()
for _, labelName := range labelNames {
- hb.b.WriteString(labelName)
- hb.b.WriteByte(SeparatorByte)
- hb.b.WriteString(labels[labelName])
- hb.b.WriteByte(SeparatorByte)
- hb.h.Write(hb.b.Bytes())
- hb.b.Reset()
+ sum = hashAdd(sum, labelName)
+ sum = hashAddByte(sum, SeparatorByte)
+ sum = hashAdd(sum, labels[labelName])
+ sum = hashAddByte(sum, SeparatorByte)
}
- return hb.h.Sum64()
+ return sum
}
// labelSetToFingerprint works exactly as LabelsToSignature but takes a LabelSet as
@@ -93,18 +64,14 @@ func labelSetToFingerprint(ls LabelSet) Fingerprint {
}
sort.Sort(labelNames)
- hb := getHashAndBuf()
- defer putHashAndBuf(hb)
-
+ sum := hashNew()
for _, labelName := range labelNames {
- hb.b.WriteString(string(labelName))
- hb.b.WriteByte(SeparatorByte)
- hb.b.WriteString(string(ls[labelName]))
- hb.b.WriteByte(SeparatorByte)
- hb.h.Write(hb.b.Bytes())
- hb.b.Reset()
+ sum = hashAdd(sum, string(labelName))
+ sum = hashAddByte(sum, SeparatorByte)
+ sum = hashAdd(sum, string(ls[labelName]))
+ sum = hashAddByte(sum, SeparatorByte)
}
- return Fingerprint(hb.h.Sum64())
+ return Fingerprint(sum)
}
// labelSetToFastFingerprint works similar to labelSetToFingerprint but uses a
@@ -116,17 +83,12 @@ func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
}
var result uint64
- hb := getHashAndBuf()
- defer putHashAndBuf(hb)
-
for labelName, labelValue := range ls {
- hb.b.WriteString(string(labelName))
- hb.b.WriteByte(SeparatorByte)
- hb.b.WriteString(string(labelValue))
- hb.h.Write(hb.b.Bytes())
- result ^= hb.h.Sum64()
- hb.h.Reset()
- hb.b.Reset()
+ sum := hashNew()
+ sum = hashAdd(sum, string(labelName))
+ sum = hashAddByte(sum, SeparatorByte)
+ sum = hashAdd(sum, string(labelValue))
+ result ^= sum
}
return Fingerprint(result)
}
@@ -136,24 +98,20 @@ func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
// specified LabelNames into the signature calculation. The labels passed in
// will be sorted by this function.
func SignatureForLabels(m Metric, labels ...LabelName) uint64 {
- if len(m) == 0 || len(labels) == 0 {
+ if len(labels) == 0 {
return emptyLabelSignature
}
sort.Sort(LabelNames(labels))
- hb := getHashAndBuf()
- defer putHashAndBuf(hb)
-
+ sum := hashNew()
for _, label := range labels {
- hb.b.WriteString(string(label))
- hb.b.WriteByte(SeparatorByte)
- hb.b.WriteString(string(m[label]))
- hb.b.WriteByte(SeparatorByte)
- hb.h.Write(hb.b.Bytes())
- hb.b.Reset()
+ sum = hashAdd(sum, string(label))
+ sum = hashAddByte(sum, SeparatorByte)
+ sum = hashAdd(sum, string(m[label]))
+ sum = hashAddByte(sum, SeparatorByte)
}
- return hb.h.Sum64()
+ return sum
}
// SignatureWithoutLabels works like LabelsToSignature but takes a Metric as
@@ -175,16 +133,12 @@ func SignatureWithoutLabels(m Metric, labels map[LabelName]struct{}) uint64 {
}
sort.Sort(labelNames)
- hb := getHashAndBuf()
- defer putHashAndBuf(hb)
-
+ sum := hashNew()
for _, labelName := range labelNames {
- hb.b.WriteString(string(labelName))
- hb.b.WriteByte(SeparatorByte)
- hb.b.WriteString(string(m[labelName]))
- hb.b.WriteByte(SeparatorByte)
- hb.h.Write(hb.b.Bytes())
- hb.b.Reset()
+ sum = hashAdd(sum, string(labelName))
+ sum = hashAddByte(sum, SeparatorByte)
+ sum = hashAdd(sum, string(m[labelName]))
+ sum = hashAddByte(sum, SeparatorByte)
}
- return hb.h.Sum64()
+ return sum
}
diff --git a/vendor/github.com/prometheus/common/model/silence.go b/vendor/github.com/prometheus/common/model/silence.go
new file mode 100644
index 0000000000000000000000000000000000000000..7538e2997741e67242e32090c634a5732a7cadcc
--- /dev/null
+++ b/vendor/github.com/prometheus/common/model/silence.go
@@ -0,0 +1,106 @@
+// Copyright 2015 The Prometheus 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 model
+
+import (
+ "encoding/json"
+ "fmt"
+ "regexp"
+ "time"
+)
+
+// Matcher describes a matches the value of a given label.
+type Matcher struct {
+ Name LabelName `json:"name"`
+ Value string `json:"value"`
+ IsRegex bool `json:"isRegex"`
+}
+
+func (m *Matcher) UnmarshalJSON(b []byte) error {
+ type plain Matcher
+ if err := json.Unmarshal(b, (*plain)(m)); err != nil {
+ return err
+ }
+
+ if len(m.Name) == 0 {
+ return fmt.Errorf("label name in matcher must not be empty")
+ }
+ if m.IsRegex {
+ if _, err := regexp.Compile(m.Value); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Validate returns true iff all fields of the matcher have valid values.
+func (m *Matcher) Validate() error {
+ if !m.Name.IsValid() {
+ return fmt.Errorf("invalid name %q", m.Name)
+ }
+ if m.IsRegex {
+ if _, err := regexp.Compile(m.Value); err != nil {
+ return fmt.Errorf("invalid regular expression %q", m.Value)
+ }
+ } else if !LabelValue(m.Value).IsValid() || len(m.Value) == 0 {
+ return fmt.Errorf("invalid value %q", m.Value)
+ }
+ return nil
+}
+
+// Silence defines the representation of a silence definiton
+// in the Prometheus eco-system.
+type Silence struct {
+ ID uint64 `json:"id,omitempty"`
+
+ Matchers []*Matcher `json:"matchers"`
+
+ StartsAt time.Time `json:"startsAt"`
+ EndsAt time.Time `json:"endsAt"`
+
+ CreatedAt time.Time `json:"createdAt,omitempty"`
+ CreatedBy string `json:"createdBy"`
+ Comment string `json:"comment,omitempty"`
+}
+
+// Validate returns true iff all fields of the silence have valid values.
+func (s *Silence) Validate() error {
+ if len(s.Matchers) == 0 {
+ return fmt.Errorf("at least one matcher required")
+ }
+ for _, m := range s.Matchers {
+ if err := m.Validate(); err != nil {
+ return fmt.Errorf("invalid matcher: %s", err)
+ }
+ }
+ if s.StartsAt.IsZero() {
+ return fmt.Errorf("start time missing")
+ }
+ if s.EndsAt.IsZero() {
+ return fmt.Errorf("end time missing")
+ }
+ if s.EndsAt.Before(s.StartsAt) {
+ return fmt.Errorf("start time must be before end time")
+ }
+ if s.CreatedBy == "" {
+ return fmt.Errorf("creator information missing")
+ }
+ if s.Comment == "" {
+ return fmt.Errorf("comment missing")
+ }
+ if s.CreatedAt.IsZero() {
+ return fmt.Errorf("creation timestamp missing")
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/time.go b/vendor/github.com/prometheus/common/model/time.go
similarity index 84%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/time.go
rename to vendor/github.com/prometheus/common/model/time.go
index ebc8bf6cc841d0c07db758b5d74eb5431214140e..548968aebe6d48ad1a523da64ce776399121d829 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/time.go
+++ b/vendor/github.com/prometheus/common/model/time.go
@@ -163,51 +163,70 @@ func (t *Time) UnmarshalJSON(b []byte) error {
// This type should not propagate beyond the scope of input/output processing.
type Duration time.Duration
+var durationRE = regexp.MustCompile("^([0-9]+)(y|w|d|h|m|s|ms)$")
+
// StringToDuration parses a string into a time.Duration, assuming that a year
-// a day always has 24h.
+// always has 365d, a week always has 7d, and a day always has 24h.
func ParseDuration(durationStr string) (Duration, error) {
matches := durationRE.FindStringSubmatch(durationStr)
if len(matches) != 3 {
return 0, fmt.Errorf("not a valid duration string: %q", durationStr)
}
- durSeconds, _ := strconv.Atoi(matches[1])
- dur := time.Duration(durSeconds) * time.Second
- unit := matches[2]
- switch unit {
+ var (
+ n, _ = strconv.Atoi(matches[1])
+ dur = time.Duration(n) * time.Millisecond
+ )
+ switch unit := matches[2]; unit {
+ case "y":
+ dur *= 1000 * 60 * 60 * 24 * 365
+ case "w":
+ dur *= 1000 * 60 * 60 * 24 * 7
case "d":
- dur *= 60 * 60 * 24
+ dur *= 1000 * 60 * 60 * 24
case "h":
- dur *= 60 * 60
+ dur *= 1000 * 60 * 60
case "m":
- dur *= 60
+ dur *= 1000 * 60
case "s":
- dur *= 1
+ dur *= 1000
+ case "ms":
+ // Value already correct
default:
return 0, fmt.Errorf("invalid time unit in duration string: %q", unit)
}
return Duration(dur), nil
}
-var durationRE = regexp.MustCompile("^([0-9]+)([ywdhms]+)$")
-
func (d Duration) String() string {
- seconds := int64(time.Duration(d) / time.Second)
+ var (
+ ms = int64(time.Duration(d) / time.Millisecond)
+ unit = "ms"
+ )
factors := map[string]int64{
- "d": 60 * 60 * 24,
- "h": 60 * 60,
- "m": 60,
- "s": 1,
+ "y": 1000 * 60 * 60 * 24 * 365,
+ "w": 1000 * 60 * 60 * 24 * 7,
+ "d": 1000 * 60 * 60 * 24,
+ "h": 1000 * 60 * 60,
+ "m": 1000 * 60,
+ "s": 1000,
+ "ms": 1,
}
- unit := "s"
+
switch int64(0) {
- case seconds % factors["d"]:
+ case ms % factors["y"]:
+ unit = "y"
+ case ms % factors["w"]:
+ unit = "w"
+ case ms % factors["d"]:
unit = "d"
- case seconds % factors["h"]:
+ case ms % factors["h"]:
unit = "h"
- case seconds % factors["m"]:
+ case ms % factors["m"]:
unit = "m"
+ case ms % factors["s"]:
+ unit = "s"
}
- return fmt.Sprintf("%v%v", seconds/factors[unit], unit)
+ return fmt.Sprintf("%v%v", ms/factors[unit], unit)
}
// MarshalYAML implements the yaml.Marshaler interface.
diff --git a/Godeps/_workspace/src/github.com/prometheus/common/model/value.go b/vendor/github.com/prometheus/common/model/value.go
similarity index 94%
rename from Godeps/_workspace/src/github.com/prometheus/common/model/value.go
rename to vendor/github.com/prometheus/common/model/value.go
index 10ffb0bd61147b56a79403973245fb3cf1d686b9..dbf5d10e4317dc7ad073e26070d9ca6d8bf8bfe1 100644
--- a/Godeps/_workspace/src/github.com/prometheus/common/model/value.go
+++ b/vendor/github.com/prometheus/common/model/value.go
@@ -16,6 +16,7 @@ package model
import (
"encoding/json"
"fmt"
+ "math"
"sort"
"strconv"
"strings"
@@ -43,8 +44,14 @@ func (v *SampleValue) UnmarshalJSON(b []byte) error {
return nil
}
+// Equal returns true if the value of v and o is equal or if both are NaN. Note
+// that v==o is false if both are NaN. If you want the conventional float
+// behavior, use == to compare two SampleValues.
func (v SampleValue) Equal(o SampleValue) bool {
- return v == o
+ if v == o {
+ return true
+ }
+ return math.IsNaN(float64(v)) && math.IsNaN(float64(o))
}
func (v SampleValue) String() string {
@@ -77,9 +84,9 @@ func (s *SamplePair) UnmarshalJSON(b []byte) error {
}
// Equal returns true if this SamplePair and o have equal Values and equal
-// Timestamps.
+// Timestamps. The sematics of Value equality is defined by SampleValue.Equal.
func (s *SamplePair) Equal(o *SamplePair) bool {
- return s == o || (s.Value == o.Value && s.Timestamp.Equal(o.Timestamp))
+ return s == o || (s.Value.Equal(o.Value) && s.Timestamp.Equal(o.Timestamp))
}
func (s SamplePair) String() string {
@@ -93,7 +100,8 @@ type Sample struct {
Timestamp Time `json:"timestamp"`
}
-// Equal compares first the metrics, then the timestamp, then the value.
+// Equal compares first the metrics, then the timestamp, then the value. The
+// sematics of value equality is defined by SampleValue.Equal.
func (s *Sample) Equal(o *Sample) bool {
if s == o {
return true
@@ -105,7 +113,7 @@ func (s *Sample) Equal(o *Sample) bool {
if !s.Timestamp.Equal(o.Timestamp) {
return false
}
- if s.Value != o.Value {
+ if s.Value.Equal(o.Value) {
return false
}
diff --git a/vendor/github.com/prometheus/procfs/.travis.yml b/vendor/github.com/prometheus/procfs/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..2b4554da58ecbb899f327cd3982f0e3c87b5c9e9
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/.travis.yml
@@ -0,0 +1,5 @@
+sudo: false
+language: go
+go:
+ - 1.5
+ - 1.6
diff --git a/vendor/github.com/prometheus/procfs/AUTHORS.md b/vendor/github.com/prometheus/procfs/AUTHORS.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c802dd8755e7fe2cb0e17a336efeb07dbf3c742
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/AUTHORS.md
@@ -0,0 +1,20 @@
+The Prometheus project was started by Matt T. Proud (emeritus) and
+Julius Volz in 2012.
+
+Maintainers of this repository:
+
+* Tobias Schmidt <ts@soundcloud.com>
+
+The following individuals have contributed code to this repository
+(listed in alphabetical order):
+
+* Armen Baghumian <abaghumian@noggin.com.au>
+* Bjoern Rabenstein <beorn@soundcloud.com>
+* David Cournapeau <cournape@gmail.com>
+* Ji-Hoon, Seol <jihoon.seol@gmail.com>
+* Jonas Große Sundrup <cherti@letopolis.de>
+* Julius Volz <julius.volz@gmail.com>
+* Matthias Rampke <mr@soundcloud.com>
+* Nicky Gerritsen <nicky@streamone.nl>
+* Rémi Audebert <contact@halfr.net>
+* Tobias Schmidt <tobidt@gmail.com>
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/CONTRIBUTING.md b/vendor/github.com/prometheus/procfs/CONTRIBUTING.md
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/CONTRIBUTING.md
rename to vendor/github.com/prometheus/procfs/CONTRIBUTING.md
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/LICENSE b/vendor/github.com/prometheus/procfs/LICENSE
similarity index 99%
rename from Godeps/_workspace/src/github.com/google/gofuzz/LICENSE
rename to vendor/github.com/prometheus/procfs/LICENSE
index d645695673349e3947e8e5ae42332d0ac3164cd7..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 100644
--- a/Godeps/_workspace/src/github.com/google/gofuzz/LICENSE
+++ b/vendor/github.com/prometheus/procfs/LICENSE
@@ -1,4 +1,3 @@
-
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
diff --git a/vendor/github.com/prometheus/procfs/Makefile b/vendor/github.com/prometheus/procfs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c264a49d179705a261d1ca45370fcf27cedb1c95
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/Makefile
@@ -0,0 +1,6 @@
+ci:
+ ! gofmt -l *.go | read nothing
+ go vet
+ go test -v ./...
+ go get github.com/golang/lint/golint
+ golint *.go
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/NOTICE b/vendor/github.com/prometheus/procfs/NOTICE
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/NOTICE
rename to vendor/github.com/prometheus/procfs/NOTICE
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/README.md b/vendor/github.com/prometheus/procfs/README.md
similarity index 71%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/README.md
rename to vendor/github.com/prometheus/procfs/README.md
index 761d31cd4dc77d27fc802ec4bd801987d33b6f51..6e7ee6b8b758b38762ff2bad9da63faea155e7f8 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/README.md
+++ b/vendor/github.com/prometheus/procfs/README.md
@@ -3,5 +3,8 @@
This procfs package provides functions to retrieve system, kernel and process
metrics from the pseudo-filesystem proc.
+*WARNING*: This package is a work in progress. Its API may still break in
+backwards-incompatible ways without warnings. Use it at your own risk.
+
[](https://godoc.org/github.com/prometheus/procfs)
[](https://travis-ci.org/prometheus/procfs)
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/doc.go b/vendor/github.com/prometheus/procfs/doc.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/doc.go
rename to vendor/github.com/prometheus/procfs/doc.go
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/fs.go b/vendor/github.com/prometheus/procfs/fs.go
similarity index 78%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/fs.go
rename to vendor/github.com/prometheus/procfs/fs.go
index 838474aba40c2dee0701675671b16ec0b7d1e118..49aaab0505d14f445b77c7bffe258e5d4c913c9d 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/fs.go
+++ b/vendor/github.com/prometheus/procfs/fs.go
@@ -27,10 +27,7 @@ func NewFS(mountPoint string) (FS, error) {
return FS(mountPoint), nil
}
-func (fs FS) stat(p string) (os.FileInfo, error) {
- return os.Stat(path.Join(string(fs), p))
-}
-
-func (fs FS) open(p string) (*os.File, error) {
- return os.Open(path.Join(string(fs), p))
+// Path returns the path of the given subsystem relative to the procfs root.
+func (fs FS) Path(p ...string) string {
+ return path.Join(append([]string{string(fs)}, p...)...)
}
diff --git a/vendor/github.com/prometheus/procfs/ipvs.go b/vendor/github.com/prometheus/procfs/ipvs.go
new file mode 100644
index 0000000000000000000000000000000000000000..e7012f7323ebd8b7f0fdddc9815a24d22e57b237
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/ipvs.go
@@ -0,0 +1,224 @@
+package procfs
+
+import (
+ "bufio"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net"
+ "os"
+ "strconv"
+ "strings"
+)
+
+// IPVSStats holds IPVS statistics, as exposed by the kernel in `/proc/net/ip_vs_stats`.
+type IPVSStats struct {
+ // Total count of connections.
+ Connections uint64
+ // Total incoming packages processed.
+ IncomingPackets uint64
+ // Total outgoing packages processed.
+ OutgoingPackets uint64
+ // Total incoming traffic.
+ IncomingBytes uint64
+ // Total outgoing traffic.
+ OutgoingBytes uint64
+}
+
+// IPVSBackendStatus holds current metrics of one virtual / real address pair.
+type IPVSBackendStatus struct {
+ // The local (virtual) IP address.
+ LocalAddress net.IP
+ // The local (virtual) port.
+ LocalPort uint16
+ // The transport protocol (TCP, UDP).
+ Proto string
+ // The remote (real) IP address.
+ RemoteAddress net.IP
+ // The remote (real) port.
+ RemotePort uint16
+ // The current number of active connections for this virtual/real address pair.
+ ActiveConn uint64
+ // The current number of inactive connections for this virtual/real address pair.
+ InactConn uint64
+ // The current weight of this virtual/real address pair.
+ Weight uint64
+}
+
+// NewIPVSStats reads the IPVS statistics.
+func NewIPVSStats() (IPVSStats, error) {
+ fs, err := NewFS(DefaultMountPoint)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+
+ return fs.NewIPVSStats()
+}
+
+// NewIPVSStats reads the IPVS statistics from the specified `proc` filesystem.
+func (fs FS) NewIPVSStats() (IPVSStats, error) {
+ file, err := os.Open(fs.Path("net/ip_vs_stats"))
+ if err != nil {
+ return IPVSStats{}, err
+ }
+ defer file.Close()
+
+ return parseIPVSStats(file)
+}
+
+// parseIPVSStats performs the actual parsing of `ip_vs_stats`.
+func parseIPVSStats(file io.Reader) (IPVSStats, error) {
+ var (
+ statContent []byte
+ statLines []string
+ statFields []string
+ stats IPVSStats
+ )
+
+ statContent, err := ioutil.ReadAll(file)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+
+ statLines = strings.SplitN(string(statContent), "\n", 4)
+ if len(statLines) != 4 {
+ return IPVSStats{}, errors.New("ip_vs_stats corrupt: too short")
+ }
+
+ statFields = strings.Fields(statLines[2])
+ if len(statFields) != 5 {
+ return IPVSStats{}, errors.New("ip_vs_stats corrupt: unexpected number of fields")
+ }
+
+ stats.Connections, err = strconv.ParseUint(statFields[0], 16, 64)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+ stats.IncomingPackets, err = strconv.ParseUint(statFields[1], 16, 64)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+ stats.OutgoingPackets, err = strconv.ParseUint(statFields[2], 16, 64)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+ stats.IncomingBytes, err = strconv.ParseUint(statFields[3], 16, 64)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+ stats.OutgoingBytes, err = strconv.ParseUint(statFields[4], 16, 64)
+ if err != nil {
+ return IPVSStats{}, err
+ }
+
+ return stats, nil
+}
+
+// NewIPVSBackendStatus reads and returns the status of all (virtual,real) server pairs.
+func NewIPVSBackendStatus() ([]IPVSBackendStatus, error) {
+ fs, err := NewFS(DefaultMountPoint)
+ if err != nil {
+ return []IPVSBackendStatus{}, err
+ }
+
+ return fs.NewIPVSBackendStatus()
+}
+
+// NewIPVSBackendStatus reads and returns the status of all (virtual,real) server pairs from the specified `proc` filesystem.
+func (fs FS) NewIPVSBackendStatus() ([]IPVSBackendStatus, error) {
+ file, err := os.Open(fs.Path("net/ip_vs"))
+ if err != nil {
+ return nil, err
+ }
+ defer file.Close()
+
+ return parseIPVSBackendStatus(file)
+}
+
+func parseIPVSBackendStatus(file io.Reader) ([]IPVSBackendStatus, error) {
+ var (
+ status []IPVSBackendStatus
+ scanner = bufio.NewScanner(file)
+ proto string
+ localAddress net.IP
+ localPort uint16
+ err error
+ )
+
+ for scanner.Scan() {
+ fields := strings.Fields(string(scanner.Text()))
+ if len(fields) == 0 {
+ continue
+ }
+ switch {
+ case fields[0] == "IP" || fields[0] == "Prot" || fields[1] == "RemoteAddress:Port":
+ continue
+ case fields[0] == "TCP" || fields[0] == "UDP":
+ if len(fields) < 2 {
+ continue
+ }
+ proto = fields[0]
+ localAddress, localPort, err = parseIPPort(fields[1])
+ if err != nil {
+ return nil, err
+ }
+ case fields[0] == "->":
+ if len(fields) < 6 {
+ continue
+ }
+ remoteAddress, remotePort, err := parseIPPort(fields[1])
+ if err != nil {
+ return nil, err
+ }
+ weight, err := strconv.ParseUint(fields[3], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+ activeConn, err := strconv.ParseUint(fields[4], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+ inactConn, err := strconv.ParseUint(fields[5], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+ status = append(status, IPVSBackendStatus{
+ LocalAddress: localAddress,
+ LocalPort: localPort,
+ RemoteAddress: remoteAddress,
+ RemotePort: remotePort,
+ Proto: proto,
+ Weight: weight,
+ ActiveConn: activeConn,
+ InactConn: inactConn,
+ })
+ }
+ }
+ return status, nil
+}
+
+func parseIPPort(s string) (net.IP, uint16, error) {
+ tmp := strings.SplitN(s, ":", 2)
+
+ if len(tmp) != 2 {
+ return nil, 0, fmt.Errorf("invalid IP:Port: %s", s)
+ }
+
+ if len(tmp[0]) != 8 && len(tmp[0]) != 32 {
+ return nil, 0, fmt.Errorf("invalid IP: %s", tmp[0])
+ }
+
+ ip, err := hex.DecodeString(tmp[0])
+ if err != nil {
+ return nil, 0, err
+ }
+
+ port, err := strconv.ParseUint(tmp[1], 16, 16)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ return ip, uint16(port), nil
+}
diff --git a/vendor/github.com/prometheus/procfs/mdstat.go b/vendor/github.com/prometheus/procfs/mdstat.go
new file mode 100644
index 0000000000000000000000000000000000000000..d7a248c0dfc4b823c2ef7456bf1dae0839e6aaf6
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/mdstat.go
@@ -0,0 +1,138 @@
+package procfs
+
+import (
+ "fmt"
+ "io/ioutil"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+var (
+ statuslineRE = regexp.MustCompile(`(\d+) blocks .*\[(\d+)/(\d+)\] \[[U_]+\]`)
+ buildlineRE = regexp.MustCompile(`\((\d+)/\d+\)`)
+)
+
+// MDStat holds info parsed from /proc/mdstat.
+type MDStat struct {
+ // Name of the device.
+ Name string
+ // activity-state of the device.
+ ActivityState string
+ // Number of active disks.
+ DisksActive int64
+ // Total number of disks the device consists of.
+ DisksTotal int64
+ // Number of blocks the device holds.
+ BlocksTotal int64
+ // Number of blocks on the device that are in sync.
+ BlocksSynced int64
+}
+
+// ParseMDStat parses an mdstat-file and returns a struct with the relevant infos.
+func (fs FS) ParseMDStat() (mdstates []MDStat, err error) {
+ mdStatusFilePath := fs.Path("mdstat")
+ content, err := ioutil.ReadFile(mdStatusFilePath)
+ if err != nil {
+ return []MDStat{}, fmt.Errorf("error parsing %s: %s", mdStatusFilePath, err)
+ }
+
+ mdStates := []MDStat{}
+ lines := strings.Split(string(content), "\n")
+ for i, l := range lines {
+ if l == "" {
+ continue
+ }
+ if l[0] == ' ' {
+ continue
+ }
+ if strings.HasPrefix(l, "Personalities") || strings.HasPrefix(l, "unused") {
+ continue
+ }
+
+ mainLine := strings.Split(l, " ")
+ if len(mainLine) < 3 {
+ return mdStates, fmt.Errorf("error parsing mdline: %s", l)
+ }
+ mdName := mainLine[0]
+ activityState := mainLine[2]
+
+ if len(lines) <= i+3 {
+ return mdStates, fmt.Errorf(
+ "error parsing %s: too few lines for md device %s",
+ mdStatusFilePath,
+ mdName,
+ )
+ }
+
+ active, total, size, err := evalStatusline(lines[i+1])
+ if err != nil {
+ return mdStates, fmt.Errorf("error parsing %s: %s", mdStatusFilePath, err)
+ }
+
+ // j is the line number of the syncing-line.
+ j := i + 2
+ if strings.Contains(lines[i+2], "bitmap") { // skip bitmap line
+ j = i + 3
+ }
+
+ // If device is syncing at the moment, get the number of currently
+ // synced bytes, otherwise that number equals the size of the device.
+ syncedBlocks := size
+ if strings.Contains(lines[j], "recovery") || strings.Contains(lines[j], "resync") {
+ syncedBlocks, err = evalBuildline(lines[j])
+ if err != nil {
+ return mdStates, fmt.Errorf("error parsing %s: %s", mdStatusFilePath, err)
+ }
+ }
+
+ mdStates = append(mdStates, MDStat{
+ Name: mdName,
+ ActivityState: activityState,
+ DisksActive: active,
+ DisksTotal: total,
+ BlocksTotal: size,
+ BlocksSynced: syncedBlocks,
+ })
+ }
+
+ return mdStates, nil
+}
+
+func evalStatusline(statusline string) (active, total, size int64, err error) {
+ matches := statuslineRE.FindStringSubmatch(statusline)
+ if len(matches) != 4 {
+ return 0, 0, 0, fmt.Errorf("unexpected statusline: %s", statusline)
+ }
+
+ size, err = strconv.ParseInt(matches[1], 10, 64)
+ if err != nil {
+ return 0, 0, 0, fmt.Errorf("unexpected statusline %s: %s", statusline, err)
+ }
+
+ total, err = strconv.ParseInt(matches[2], 10, 64)
+ if err != nil {
+ return 0, 0, 0, fmt.Errorf("unexpected statusline %s: %s", statusline, err)
+ }
+
+ active, err = strconv.ParseInt(matches[3], 10, 64)
+ if err != nil {
+ return 0, 0, 0, fmt.Errorf("unexpected statusline %s: %s", statusline, err)
+ }
+
+ return active, total, size, nil
+}
+
+func evalBuildline(buildline string) (syncedBlocks int64, err error) {
+ matches := buildlineRE.FindStringSubmatch(buildline)
+ if len(matches) != 2 {
+ return 0, fmt.Errorf("unexpected buildline: %s", buildline)
+ }
+
+ syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)
+ if err != nil {
+ return 0, fmt.Errorf("%s in buildline: %s", err, buildline)
+ }
+
+ return syncedBlocks, nil
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/proc.go b/vendor/github.com/prometheus/procfs/proc.go
similarity index 58%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/proc.go
rename to vendor/github.com/prometheus/procfs/proc.go
index 21445cf1761665f8045cebf490d396b4796d3b72..0d0a6a90f0becd4e02a45b34c7f1a1a438d38120 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/proc.go
+++ b/vendor/github.com/prometheus/procfs/proc.go
@@ -4,7 +4,6 @@ import (
"fmt"
"io/ioutil"
"os"
- "path"
"strconv"
"strings"
)
@@ -24,9 +23,13 @@ func (p Procs) Len() int { return len(p) }
func (p Procs) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p Procs) Less(i, j int) bool { return p[i].PID < p[j].PID }
-// Self returns a process for the current process.
+// Self returns a process for the current process read via /proc/self.
func Self() (Proc, error) {
- return NewProc(os.Getpid())
+ fs, err := NewFS(DefaultMountPoint)
+ if err != nil {
+ return Proc{}, err
+ }
+ return fs.Self()
}
// NewProc returns a process for the given pid under /proc.
@@ -35,32 +38,42 @@ func NewProc(pid int) (Proc, error) {
if err != nil {
return Proc{}, err
}
-
return fs.NewProc(pid)
}
-// AllProcs returns a list of all currently avaible processes under /proc.
+// AllProcs returns a list of all currently available processes under /proc.
func AllProcs() (Procs, error) {
fs, err := NewFS(DefaultMountPoint)
if err != nil {
return Procs{}, err
}
-
return fs.AllProcs()
}
+// Self returns a process for the current process.
+func (fs FS) Self() (Proc, error) {
+ p, err := os.Readlink(fs.Path("self"))
+ if err != nil {
+ return Proc{}, err
+ }
+ pid, err := strconv.Atoi(strings.Replace(p, string(fs), "", -1))
+ if err != nil {
+ return Proc{}, err
+ }
+ return fs.NewProc(pid)
+}
+
// NewProc returns a process for the given pid.
func (fs FS) NewProc(pid int) (Proc, error) {
- if _, err := fs.stat(strconv.Itoa(pid)); err != nil {
+ if _, err := os.Stat(fs.Path(strconv.Itoa(pid))); err != nil {
return Proc{}, err
}
-
return Proc{PID: pid, fs: fs}, nil
}
-// AllProcs returns a list of all currently avaible processes.
+// AllProcs returns a list of all currently available processes.
func (fs FS) AllProcs() (Procs, error) {
- d, err := fs.open("")
+ d, err := os.Open(fs.Path())
if err != nil {
return Procs{}, err
}
@@ -85,7 +98,7 @@ func (fs FS) AllProcs() (Procs, error) {
// CmdLine returns the command line of a process.
func (p Proc) CmdLine() ([]string, error) {
- f, err := p.open("cmdline")
+ f, err := os.Open(p.path("cmdline"))
if err != nil {
return nil, err
}
@@ -96,9 +109,39 @@ func (p Proc) CmdLine() ([]string, error) {
return nil, err
}
+ if len(data) < 1 {
+ return []string{}, nil
+ }
+
return strings.Split(string(data[:len(data)-1]), string(byte(0))), nil
}
+// Comm returns the command name of a process.
+func (p Proc) Comm() (string, error) {
+ f, err := os.Open(p.path("comm"))
+ if err != nil {
+ return "", err
+ }
+ defer f.Close()
+
+ data, err := ioutil.ReadAll(f)
+ if err != nil {
+ return "", err
+ }
+
+ return strings.TrimSpace(string(data)), nil
+}
+
+// Executable returns the absolute path of the executable command of a process.
+func (p Proc) Executable() (string, error) {
+ exe, err := os.Readlink(p.path("exe"))
+ if os.IsNotExist(err) {
+ return "", nil
+ }
+
+ return exe, err
+}
+
// FileDescriptors returns the currently open file descriptors of a process.
func (p Proc) FileDescriptors() ([]uintptr, error) {
names, err := p.fileDescriptors()
@@ -118,6 +161,26 @@ func (p Proc) FileDescriptors() ([]uintptr, error) {
return fds, nil
}
+// FileDescriptorTargets returns the targets of all file descriptors of a process.
+// If a file descriptor is not a symlink to a file (like a socket), that value will be the empty string.
+func (p Proc) FileDescriptorTargets() ([]string, error) {
+ names, err := p.fileDescriptors()
+ if err != nil {
+ return nil, err
+ }
+
+ targets := make([]string, len(names))
+
+ for i, name := range names {
+ target, err := os.Readlink(p.path("fd", name))
+ if err == nil {
+ targets[i] = target
+ }
+ }
+
+ return targets, nil
+}
+
// FileDescriptorsLen returns the number of currently open file descriptors of
// a process.
func (p Proc) FileDescriptorsLen() (int, error) {
@@ -130,7 +193,7 @@ func (p Proc) FileDescriptorsLen() (int, error) {
}
func (p Proc) fileDescriptors() ([]string, error) {
- d, err := p.open("fd")
+ d, err := os.Open(p.path("fd"))
if err != nil {
return nil, err
}
@@ -144,6 +207,6 @@ func (p Proc) fileDescriptors() ([]string, error) {
return names, nil
}
-func (p Proc) open(pa string) (*os.File, error) {
- return p.fs.open(path.Join(strconv.Itoa(p.PID), pa))
+func (p Proc) path(pa ...string) string {
+ return p.fs.Path(append([]string{strconv.Itoa(p.PID)}, pa...)...)
}
diff --git a/vendor/github.com/prometheus/procfs/proc_io.go b/vendor/github.com/prometheus/procfs/proc_io.go
new file mode 100644
index 0000000000000000000000000000000000000000..b4e31d7ba39e96c63479ecbc291c0f4a60b866fa
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/proc_io.go
@@ -0,0 +1,55 @@
+package procfs
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+)
+
+// ProcIO models the content of /proc/<pid>/io.
+type ProcIO struct {
+ // Chars read.
+ RChar uint64
+ // Chars written.
+ WChar uint64
+ // Read syscalls.
+ SyscR uint64
+ // Write syscalls.
+ SyscW uint64
+ // Bytes read.
+ ReadBytes uint64
+ // Bytes written.
+ WriteBytes uint64
+ // Bytes written, but taking into account truncation. See
+ // Documentation/filesystems/proc.txt in the kernel sources for
+ // detailed explanation.
+ CancelledWriteBytes int64
+}
+
+// NewIO creates a new ProcIO instance from a given Proc instance.
+func (p Proc) NewIO() (ProcIO, error) {
+ pio := ProcIO{}
+
+ f, err := os.Open(p.path("io"))
+ if err != nil {
+ return pio, err
+ }
+ defer f.Close()
+
+ data, err := ioutil.ReadAll(f)
+ if err != nil {
+ return pio, err
+ }
+
+ ioFormat := "rchar: %d\nwchar: %d\nsyscr: %d\nsyscw: %d\n" +
+ "read_bytes: %d\nwrite_bytes: %d\n" +
+ "cancelled_write_bytes: %d\n"
+
+ _, err = fmt.Sscanf(string(data), ioFormat, &pio.RChar, &pio.WChar, &pio.SyscR,
+ &pio.SyscW, &pio.ReadBytes, &pio.WriteBytes, &pio.CancelledWriteBytes)
+ if err != nil {
+ return pio, err
+ }
+
+ return pio, nil
+}
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/proc_limits.go b/vendor/github.com/prometheus/procfs/proc_limits.go
similarity index 55%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/proc_limits.go
rename to vendor/github.com/prometheus/procfs/proc_limits.go
index 9f080b9f62be9b424be742888bd9f515e6d57749..2df997ce11fe090b7ce035572432feefb9d0c877 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/proc_limits.go
+++ b/vendor/github.com/prometheus/procfs/proc_limits.go
@@ -3,29 +3,56 @@ package procfs
import (
"bufio"
"fmt"
+ "os"
"regexp"
"strconv"
)
// ProcLimits represents the soft limits for each of the process's resource
-// limits.
+// limits. For more information see getrlimit(2):
+// http://man7.org/linux/man-pages/man2/getrlimit.2.html.
type ProcLimits struct {
- CPUTime int
- FileSize int
- DataSize int
- StackSize int
- CoreFileSize int
- ResidentSet int
- Processes int
- OpenFiles int
- LockedMemory int
- AddressSpace int
- FileLocks int
- PendingSignals int
- MsqqueueSize int
- NicePriority int
+ // CPU time limit in seconds.
+ CPUTime int
+ // Maximum size of files that the process may create.
+ FileSize int
+ // Maximum size of the process's data segment (initialized data,
+ // uninitialized data, and heap).
+ DataSize int
+ // Maximum size of the process stack in bytes.
+ StackSize int
+ // Maximum size of a core file.
+ CoreFileSize int
+ // Limit of the process's resident set in pages.
+ ResidentSet int
+ // Maximum number of processes that can be created for the real user ID of
+ // the calling process.
+ Processes int
+ // Value one greater than the maximum file descriptor number that can be
+ // opened by this process.
+ OpenFiles int
+ // Maximum number of bytes of memory that may be locked into RAM.
+ LockedMemory int
+ // Maximum size of the process's virtual memory address space in bytes.
+ AddressSpace int
+ // Limit on the combined number of flock(2) locks and fcntl(2) leases that
+ // this process may establish.
+ FileLocks int
+ // Limit of signals that may be queued for the real user ID of the calling
+ // process.
+ PendingSignals int
+ // Limit on the number of bytes that can be allocated for POSIX message
+ // queues for the real user ID of the calling process.
+ MsqqueueSize int
+ // Limit of the nice priority set using setpriority(2) or nice(2).
+ NicePriority int
+ // Limit of the real-time priority set using sched_setscheduler(2) or
+ // sched_setparam(2).
RealtimePriority int
- RealtimeTimeout int
+ // Limit (in microseconds) on the amount of CPU time that a process
+ // scheduled under a real-time scheduling policy may consume without making
+ // a blocking system call.
+ RealtimeTimeout int
}
const (
@@ -39,7 +66,7 @@ var (
// NewLimits returns the current soft limits of the process.
func (p Proc) NewLimits() (ProcLimits, error) {
- f, err := p.open("limits")
+ f, err := os.Open(p.path("limits"))
if err != nil {
return ProcLimits{}, err
}
@@ -60,7 +87,7 @@ func (p Proc) NewLimits() (ProcLimits, error) {
case "Max cpu time":
l.CPUTime, err = parseInt(fields[1])
case "Max file size":
- l.FileLocks, err = parseInt(fields[1])
+ l.FileSize, err = parseInt(fields[1])
case "Max data size":
l.DataSize, err = parseInt(fields[1])
case "Max stack size":
@@ -90,7 +117,6 @@ func (p Proc) NewLimits() (ProcLimits, error) {
case "Max realtime timeout":
l.RealtimeTimeout, err = parseInt(fields[1])
}
-
if err != nil {
return ProcLimits{}, err
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/proc_stat.go b/vendor/github.com/prometheus/procfs/proc_stat.go
similarity index 88%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/proc_stat.go
rename to vendor/github.com/prometheus/procfs/proc_stat.go
index 30a403b6c7ecae068f7339557b9dc41ba481b345..724e271b9ed8a7714e2f9bb41c91e7ef4794898b 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/proc_stat.go
+++ b/vendor/github.com/prometheus/procfs/proc_stat.go
@@ -7,15 +7,15 @@ import (
"os"
)
-// Originally, this USER_HZ value was dynamically retrieved via a sysconf call which
-// required cgo. However, that caused a lot of problems regarding
+// Originally, this USER_HZ value was dynamically retrieved via a sysconf call
+// which required cgo. However, that caused a lot of problems regarding
// cross-compilation. Alternatives such as running a binary to determine the
-// value, or trying to derive it in some other way were all problematic.
-// After much research it was determined that USER_HZ is actually hardcoded to
-// 100 on all Go-supported platforms as of the time of this writing. This is
-// why we decided to hardcode it here as well. It is not impossible that there
-// could be systems with exceptions, but they should be very exotic edge cases,
-// and in that case, the worst outcome will be two misreported metrics.
+// value, or trying to derive it in some other way were all problematic. After
+// much research it was determined that USER_HZ is actually hardcoded to 100 on
+// all Go-supported platforms as of the time of this writing. This is why we
+// decided to hardcode it here as well. It is not impossible that there could
+// be systems with exceptions, but they should be very exotic edge cases, and
+// in that case, the worst outcome will be two misreported metrics.
//
// See also the following discussions:
//
@@ -91,7 +91,7 @@ type ProcStat struct {
// NewStat returns the current status information of the process.
func (p Proc) NewStat() (ProcStat, error) {
- f, err := p.open("stat")
+ f, err := os.Open(p.path("stat"))
if err != nil {
return ProcStat{}, err
}
diff --git a/Godeps/_workspace/src/github.com/prometheus/procfs/stat.go b/vendor/github.com/prometheus/procfs/stat.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/prometheus/procfs/stat.go
rename to vendor/github.com/prometheus/procfs/stat.go
index 26fefb0fa020c92a9552ea44b7e5839a12d18daf..1ca217e8c72e762aef10a40625a8547b104e67d9 100644
--- a/Godeps/_workspace/src/github.com/prometheus/procfs/stat.go
+++ b/vendor/github.com/prometheus/procfs/stat.go
@@ -3,6 +3,7 @@ package procfs
import (
"bufio"
"fmt"
+ "os"
"strconv"
"strings"
)
@@ -25,7 +26,7 @@ func NewStat() (Stat, error) {
// NewStat returns an information about current kernel/system statistics.
func (fs FS) NewStat() (Stat, error) {
- f, err := fs.open("stat")
+ f, err := os.Open(fs.Path("stat"))
if err != nil {
return Stat{}, err
}
diff --git a/vendor/github.com/spf13/cobra/.gitignore b/vendor/github.com/spf13/cobra/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..1b8c7c2611674d0b2774f2b6c318850c7f5fa08c
--- /dev/null
+++ b/vendor/github.com/spf13/cobra/.gitignore
@@ -0,0 +1,36 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+# Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore
+# swap
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+# session
+Session.vim
+# temporary
+.netrwhist
+*~
+# auto-generated tag files
+tags
+
+*.exe
+
+cobra.test
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/.mailmap b/vendor/github.com/spf13/cobra/.mailmap
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/cobra/.mailmap
rename to vendor/github.com/spf13/cobra/.mailmap
diff --git a/vendor/github.com/spf13/cobra/.travis.yml b/vendor/github.com/spf13/cobra/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6e84be54d16dbfd483ebbade5ed5a10014ec7266
--- /dev/null
+++ b/vendor/github.com/spf13/cobra/.travis.yml
@@ -0,0 +1,18 @@
+language: go
+go:
+ - 1.4.3
+ - 1.5.4
+ - 1.6.3
+ - tip
+
+matrix:
+ allow_failures:
+ - go: tip
+
+before_install:
+ - mkdir -p bin
+ - curl -Lso bin/shellcheck https://github.com/caarlos0/shellcheck-docker/releases/download/v0.4.3/shellcheck
+ - chmod +x bin/shellcheck
+script:
+ - PATH=$PATH:$PWD/bin go test -v ./...
+ - go build
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt b/vendor/github.com/spf13/cobra/LICENSE.txt
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
rename to vendor/github.com/spf13/cobra/LICENSE.txt
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/README.md b/vendor/github.com/spf13/cobra/README.md
similarity index 94%
rename from Godeps/_workspace/src/github.com/spf13/cobra/README.md
rename to vendor/github.com/spf13/cobra/README.md
index caeebb9dc644889ab931e25a4ef634f822d78c78..b338a0e4424a2633bba0fe169146d68b827c6829 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/README.md
+++ b/vendor/github.com/spf13/cobra/README.md
@@ -7,6 +7,7 @@ Many of the most widely used Go projects are built using Cobra including:
* [Kubernetes](http://kubernetes.io/)
* [Hugo](http://gohugo.io)
* [rkt](https://github.com/coreos/rkt)
+* [etcd](https://github.com/coreos/etcd)
* [Docker (distribution)](https://github.com/docker/distribution)
* [OpenShift](https://www.openshift.com/)
* [Delve](https://github.com/derekparker/delve)
@@ -15,10 +16,13 @@ Many of the most widely used Go projects are built using Cobra including:
* [Bleve](http://www.blevesearch.com/)
* [ProjectAtomic (enterprise)](http://www.projectatomic.io/)
* [Parse (CLI)](https://parse.com/)
+* [GiantSwarm's swarm](https://github.com/giantswarm/cli)
+* [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack)
-[](https://travis-ci.org/spf13/cobra)
+[](https://travis-ci.org/spf13/cobra)
[](https://circleci.com/gh/spf13/cobra)
+[](https://godoc.org/github.com/spf13/cobra)
@@ -65,7 +69,7 @@ Cobra is built on a structure of commands, arguments & flags.
The best applications will read like sentences when used. Users will know how
to use the application because they will natively understand how to use it.
-The pattern to follow is
+The pattern to follow is
`APPNAME VERB NOUN --ADJECTIVE.`
or
`APPNAME COMMAND ARG --FLAG`
@@ -74,7 +78,7 @@ A few good real world examples may better illustrate this point.
In the following example, 'server' is a command, and 'port' is a flag:
- > hugo serve --port=1313
+ > hugo server --port=1313
In this command we are telling Git to clone the url bare.
@@ -168,6 +172,12 @@ func main() {
Cobra provides its own program that will create your application and add any
commands you want. It's the easiest way to incorporate Cobra into your application.
+In order to use the cobra command, compile it using the following command:
+
+ > go install github.com/spf13/cobra/cobra
+
+This will create the cobra executable under your go path bin directory!
+
### cobra init
The `cobra init [yourApp]` command will create your initial application code
@@ -199,7 +209,7 @@ cobra add config
cobra add create -p 'configCmd'
```
-Once you have run these four commands you would have an app structure that would look like:
+Once you have run these three commands you would have an app structure that would look like:
```
▾ app/
@@ -223,13 +233,27 @@ The cobra generator will be easier to use if you provide a simple configuration
file which will help you eliminate providing a bunch of repeated information in
flags over and over.
-an example ~/.cobra.yaml file:
+An example ~/.cobra.yaml file:
```yaml
author: Steve Francia <spf@spf13.com>
license: MIT
```
+You can specify no license by setting `license` to `none` or you can specify
+a custom license:
+
+```yaml
+license:
+ header: This file is part of {{ .appName }}.
+ text: |
+ {{ .copyright }}
+
+ This is my license. There are many like it, but this one is mine.
+ My license is my best friend. It is my life. I must master it as I must
+ master my life.
+```
+
## Manually implementing Cobra
To manually implement cobra you need to create a bare main.go file and a RootCmd file.
@@ -329,7 +353,7 @@ var versionCmd = &cobra.Command{
}
```
-### Attach command to its parent
+### Attach command to its parent
If you notice in the above example we attach the command to its parent. In
@@ -473,18 +497,18 @@ The following output is automatically generated by Cobra. Nothing beyond the
command and flag definitions are needed.
> hugo help
-
+
hugo is the main command, used to build your Hugo site.
-
+
Hugo is a Fast and Flexible Static Site Generator
built with love by spf13 and friends in Go.
-
+
Complete documentation is available at http://gohugo.io/.
-
+
Usage:
hugo [flags]
hugo [command]
-
+
Available Commands:
server Hugo runs its own webserver to render the files
version Print the version number of Hugo
@@ -499,7 +523,7 @@ command and flag definitions are needed.
gendoc Generate Markdown documentation for the Hugo CLI.
genman Generate man page for Hugo
import Import your site from others.
-
+
Flags:
-b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
-D, --buildDrafts[=false]: include content marked as draft
@@ -524,7 +548,7 @@ command and flag definitions are needed.
-v, --verbose[=false]: verbose output
--verboseLog[=false]: verbose logging
-w, --watch[=false]: watch filesystem for changes and recreate as needed
-
+
Use "hugo [command] --help" for more information about a command.
@@ -533,7 +557,7 @@ around it. In fact, you can provide your own if you want.
### Defining your own help
-You can provide your own Help command or you own template for the default command to use.
+You can provide your own Help command or your own template for the default command to use.
The default help command is
@@ -576,7 +600,7 @@ embeds the usage as part of its output.
Usage:
hugo [flags]
hugo [command]
-
+
Available Commands:
server Hugo runs its own webserver to render the files
version Print the version number of Hugo
@@ -591,7 +615,7 @@ embeds the usage as part of its output.
gendoc Generate Markdown documentation for the Hugo CLI.
genman Generate man page for Hugo
import Import your site from others.
-
+
Flags:
-b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
-D, --buildDrafts[=false]: include content marked as draft
@@ -710,7 +734,8 @@ func main() {
## Alternative Error Handling
-Cobra also has functions where the return signature is an error. This allows for errors to bubble up to the top, providing a way to handle the errors in one location. The current list of functions that return an error is:
+Cobra also has functions where the return signature is an error. This allows for errors to bubble up to the top,
+providing a way to handle the errors in one location. The current list of functions that return an error is:
* PersistentPreRunE
* PreRunE
@@ -718,6 +743,10 @@ Cobra also has functions where the return signature is an error. This allows for
* PostRunE
* PersistentPostRunE
+If you would like to silence the default `error` and `usage` output in favor of your own, you can set `SilenceUsage`
+and `SilenceErrors` to `false` on the command. A child command respects these flags if they are set on the parent
+command.
+
**Example Usage using RunE:**
```go
@@ -791,11 +820,11 @@ Run 'kubectl help' for usage.
## Generating Markdown-formatted documentation for your command
-Cobra can generate a Markdown-formatted document based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Markdown Docs](md_docs.md).
+Cobra can generate a Markdown-formatted document based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Markdown Docs](doc/md_docs.md).
## Generating man pages for your command
-Cobra can generate a man page based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Man Docs](man_docs.md).
+Cobra can generate a man page based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Man Docs](doc/man_docs.md).
## Generating bash completions for your command
@@ -857,8 +886,8 @@ Libraries for extending Cobra:
Names in no particular order:
-* [spf13](https://github.com/spf13),
-[eparis](https://github.com/eparis),
+* [spf13](https://github.com/spf13),
+[eparis](https://github.com/eparis),
[bep](https://github.com/bep), and many more!
## License
diff --git a/vendor/github.com/spf13/cobra/bash_completions.go b/vendor/github.com/spf13/cobra/bash_completions.go
new file mode 100644
index 0000000000000000000000000000000000000000..5b3e855be12d54db5dff598c42bcf843bc295744
--- /dev/null
+++ b/vendor/github.com/spf13/cobra/bash_completions.go
@@ -0,0 +1,643 @@
+package cobra
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "sort"
+ "strings"
+
+ "github.com/spf13/pflag"
+)
+
+const (
+ BashCompFilenameExt = "cobra_annotation_bash_completion_filename_extentions"
+ BashCompCustom = "cobra_annotation_bash_completion_custom"
+ BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag"
+ BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir"
+)
+
+func preamble(out io.Writer, name string) error {
+ _, err := fmt.Fprintf(out, "# bash completion for %-36s -*- shell-script -*-\n", name)
+ if err != nil {
+ return err
+ }
+ _, err = fmt.Fprint(out, `
+__debug()
+{
+ if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
+ echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
+ fi
+}
+
+# Homebrew on Macs have version 1.3 of bash-completion which doesn't include
+# _init_completion. This is a very minimal version of that function.
+__my_init_completion()
+{
+ COMPREPLY=()
+ _get_comp_words_by_ref "$@" cur prev words cword
+}
+
+__index_of_word()
+{
+ local w word=$1
+ shift
+ index=0
+ for w in "$@"; do
+ [[ $w = "$word" ]] && return
+ index=$((index+1))
+ done
+ index=-1
+}
+
+__contains_word()
+{
+ local w word=$1; shift
+ for w in "$@"; do
+ [[ $w = "$word" ]] && return
+ done
+ return 1
+}
+
+__handle_reply()
+{
+ __debug "${FUNCNAME[0]}"
+ case $cur in
+ -*)
+ if [[ $(type -t compopt) = "builtin" ]]; then
+ compopt -o nospace
+ fi
+ local allflags
+ if [ ${#must_have_one_flag[@]} -ne 0 ]; then
+ allflags=("${must_have_one_flag[@]}")
+ else
+ allflags=("${flags[*]} ${two_word_flags[*]}")
+ fi
+ COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") )
+ if [[ $(type -t compopt) = "builtin" ]]; then
+ [[ "${COMPREPLY[0]}" == *= ]] || compopt +o nospace
+ fi
+
+ # complete after --flag=abc
+ if [[ $cur == *=* ]]; then
+ if [[ $(type -t compopt) = "builtin" ]]; then
+ compopt +o nospace
+ fi
+
+ local index flag
+ flag="${cur%%=*}"
+ __index_of_word "${flag}" "${flags_with_completion[@]}"
+ if [[ ${index} -ge 0 ]]; then
+ COMPREPLY=()
+ PREFIX=""
+ cur="${cur#*=}"
+ ${flags_completion[${index}]}
+ if [ -n "${ZSH_VERSION}" ]; then
+ # zfs completion needs --flag= prefix
+ eval "COMPREPLY=( \"\${COMPREPLY[@]/#/${flag}=}\" )"
+ fi
+ fi
+ fi
+ return 0;
+ ;;
+ esac
+
+ # check if we are handling a flag with special work handling
+ local index
+ __index_of_word "${prev}" "${flags_with_completion[@]}"
+ if [[ ${index} -ge 0 ]]; then
+ ${flags_completion[${index}]}
+ return
+ fi
+
+ # we are parsing a flag and don't have a special handler, no completion
+ if [[ ${cur} != "${words[cword]}" ]]; then
+ return
+ fi
+
+ local completions
+ completions=("${commands[@]}")
+ if [[ ${#must_have_one_noun[@]} -ne 0 ]]; then
+ completions=("${must_have_one_noun[@]}")
+ fi
+ if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then
+ completions+=("${must_have_one_flag[@]}")
+ fi
+ COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") )
+
+ if [[ ${#COMPREPLY[@]} -eq 0 && ${#noun_aliases[@]} -gt 0 && ${#must_have_one_noun[@]} -ne 0 ]]; then
+ COMPREPLY=( $(compgen -W "${noun_aliases[*]}" -- "$cur") )
+ fi
+
+ if [[ ${#COMPREPLY[@]} -eq 0 ]]; then
+ declare -F __custom_func >/dev/null && __custom_func
+ fi
+
+ __ltrim_colon_completions "$cur"
+}
+
+# The arguments should be in the form "ext1|ext2|extn"
+__handle_filename_extension_flag()
+{
+ local ext="$1"
+ _filedir "@(${ext})"
+}
+
+__handle_subdirs_in_dir_flag()
+{
+ local dir="$1"
+ pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1
+}
+
+__handle_flag()
+{
+ __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
+
+ # if a command required a flag, and we found it, unset must_have_one_flag()
+ local flagname=${words[c]}
+ local flagvalue
+ # if the word contained an =
+ if [[ ${words[c]} == *"="* ]]; then
+ flagvalue=${flagname#*=} # take in as flagvalue after the =
+ flagname=${flagname%%=*} # strip everything after the =
+ flagname="${flagname}=" # but put the = back
+ fi
+ __debug "${FUNCNAME[0]}: looking for ${flagname}"
+ if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then
+ must_have_one_flag=()
+ fi
+
+ # if you set a flag which only applies to this command, don't show subcommands
+ if __contains_word "${flagname}" "${local_nonpersistent_flags[@]}"; then
+ commands=()
+ fi
+
+ # keep flag value with flagname as flaghash
+ if [ -n "${flagvalue}" ] ; then
+ flaghash[${flagname}]=${flagvalue}
+ elif [ -n "${words[ $((c+1)) ]}" ] ; then
+ flaghash[${flagname}]=${words[ $((c+1)) ]}
+ else
+ flaghash[${flagname}]="true" # pad "true" for bool flag
+ fi
+
+ # skip the argument to a two word flag
+ if __contains_word "${words[c]}" "${two_word_flags[@]}"; then
+ c=$((c+1))
+ # if we are looking for a flags value, don't show commands
+ if [[ $c -eq $cword ]]; then
+ commands=()
+ fi
+ fi
+
+ c=$((c+1))
+
+}
+
+__handle_noun()
+{
+ __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
+
+ if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then
+ must_have_one_noun=()
+ elif __contains_word "${words[c]}" "${noun_aliases[@]}"; then
+ must_have_one_noun=()
+ fi
+
+ nouns+=("${words[c]}")
+ c=$((c+1))
+}
+
+__handle_command()
+{
+ __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
+
+ local next_command
+ if [[ -n ${last_command} ]]; then
+ next_command="_${last_command}_${words[c]//:/__}"
+ else
+ if [[ $c -eq 0 ]]; then
+ next_command="_$(basename "${words[c]//:/__}")"
+ else
+ next_command="_${words[c]//:/__}"
+ fi
+ fi
+ c=$((c+1))
+ __debug "${FUNCNAME[0]}: looking for ${next_command}"
+ declare -F $next_command >/dev/null && $next_command
+}
+
+__handle_word()
+{
+ if [[ $c -ge $cword ]]; then
+ __handle_reply
+ return
+ fi
+ __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
+ if [[ "${words[c]}" == -* ]]; then
+ __handle_flag
+ elif __contains_word "${words[c]}" "${commands[@]}"; then
+ __handle_command
+ elif [[ $c -eq 0 ]] && __contains_word "$(basename "${words[c]}")" "${commands[@]}"; then
+ __handle_command
+ else
+ __handle_noun
+ fi
+ __handle_word
+}
+
+`)
+ return err
+}
+
+func postscript(w io.Writer, name string) error {
+ name = strings.Replace(name, ":", "__", -1)
+ _, err := fmt.Fprintf(w, "__start_%s()\n", name)
+ if err != nil {
+ return err
+ }
+ _, err = fmt.Fprintf(w, `{
+ local cur prev words cword
+ declare -A flaghash 2>/dev/null || :
+ if declare -F _init_completion >/dev/null 2>&1; then
+ _init_completion -s || return
+ else
+ __my_init_completion -n "=" || return
+ fi
+
+ local c=0
+ local flags=()
+ local two_word_flags=()
+ local local_nonpersistent_flags=()
+ local flags_with_completion=()
+ local flags_completion=()
+ local commands=("%s")
+ local must_have_one_flag=()
+ local must_have_one_noun=()
+ local last_command
+ local nouns=()
+
+ __handle_word
+}
+
+`, name)
+ if err != nil {
+ return err
+ }
+ _, err = fmt.Fprintf(w, `if [[ $(type -t compopt) = "builtin" ]]; then
+ complete -o default -F __start_%s %s
+else
+ complete -o default -o nospace -F __start_%s %s
+fi
+
+`, name, name, name, name)
+ if err != nil {
+ return err
+ }
+ _, err = fmt.Fprintf(w, "# ex: ts=4 sw=4 et filetype=sh\n")
+ return err
+}
+
+func writeCommands(cmd *Command, w io.Writer) error {
+ if _, err := fmt.Fprintf(w, " commands=()\n"); err != nil {
+ return err
+ }
+ for _, c := range cmd.Commands() {
+ if !c.IsAvailableCommand() || c == cmd.helpCommand {
+ continue
+ }
+ if _, err := fmt.Fprintf(w, " commands+=(%q)\n", c.Name()); err != nil {
+ return err
+ }
+ }
+ _, err := fmt.Fprintf(w, "\n")
+ return err
+}
+
+func writeFlagHandler(name string, annotations map[string][]string, w io.Writer) error {
+ for key, value := range annotations {
+ switch key {
+ case BashCompFilenameExt:
+ _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name)
+ if err != nil {
+ return err
+ }
+
+ if len(value) > 0 {
+ ext := "__handle_filename_extension_flag " + strings.Join(value, "|")
+ _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext)
+ } else {
+ ext := "_filedir"
+ _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext)
+ }
+ if err != nil {
+ return err
+ }
+ case BashCompCustom:
+ _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name)
+ if err != nil {
+ return err
+ }
+ if len(value) > 0 {
+ handlers := strings.Join(value, "; ")
+ _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", handlers)
+ } else {
+ _, err = fmt.Fprintf(w, " flags_completion+=(:)\n")
+ }
+ if err != nil {
+ return err
+ }
+ case BashCompSubdirsInDir:
+ _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name)
+
+ if len(value) == 1 {
+ ext := "__handle_subdirs_in_dir_flag " + value[0]
+ _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext)
+ } else {
+ ext := "_filedir -d"
+ _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext)
+ }
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+func writeShortFlag(flag *pflag.Flag, w io.Writer) error {
+ b := (len(flag.NoOptDefVal) > 0)
+ name := flag.Shorthand
+ format := " "
+ if !b {
+ format += "two_word_"
+ }
+ format += "flags+=(\"-%s\")\n"
+ if _, err := fmt.Fprintf(w, format, name); err != nil {
+ return err
+ }
+ return writeFlagHandler("-"+name, flag.Annotations, w)
+}
+
+func writeFlag(flag *pflag.Flag, w io.Writer) error {
+ b := (len(flag.NoOptDefVal) > 0)
+ name := flag.Name
+ format := " flags+=(\"--%s"
+ if !b {
+ format += "="
+ }
+ format += "\")\n"
+ if _, err := fmt.Fprintf(w, format, name); err != nil {
+ return err
+ }
+ return writeFlagHandler("--"+name, flag.Annotations, w)
+}
+
+func writeLocalNonPersistentFlag(flag *pflag.Flag, w io.Writer) error {
+ b := (len(flag.NoOptDefVal) > 0)
+ name := flag.Name
+ format := " local_nonpersistent_flags+=(\"--%s"
+ if !b {
+ format += "="
+ }
+ format += "\")\n"
+ if _, err := fmt.Fprintf(w, format, name); err != nil {
+ return err
+ }
+ return nil
+}
+
+func writeFlags(cmd *Command, w io.Writer) error {
+ _, err := fmt.Fprintf(w, ` flags=()
+ two_word_flags=()
+ local_nonpersistent_flags=()
+ flags_with_completion=()
+ flags_completion=()
+
+`)
+ if err != nil {
+ return err
+ }
+ localNonPersistentFlags := cmd.LocalNonPersistentFlags()
+ var visitErr error
+ cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) {
+ if nonCompletableFlag(flag) {
+ return
+ }
+ if err := writeFlag(flag, w); err != nil {
+ visitErr = err
+ return
+ }
+ if len(flag.Shorthand) > 0 {
+ if err := writeShortFlag(flag, w); err != nil {
+ visitErr = err
+ return
+ }
+ }
+ if localNonPersistentFlags.Lookup(flag.Name) != nil {
+ if err := writeLocalNonPersistentFlag(flag, w); err != nil {
+ visitErr = err
+ return
+ }
+ }
+ })
+ if visitErr != nil {
+ return visitErr
+ }
+ cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) {
+ if nonCompletableFlag(flag) {
+ return
+ }
+ if err := writeFlag(flag, w); err != nil {
+ visitErr = err
+ return
+ }
+ if len(flag.Shorthand) > 0 {
+ if err := writeShortFlag(flag, w); err != nil {
+ visitErr = err
+ return
+ }
+ }
+ })
+ if visitErr != nil {
+ return visitErr
+ }
+
+ _, err = fmt.Fprintf(w, "\n")
+ return err
+}
+
+func writeRequiredFlag(cmd *Command, w io.Writer) error {
+ if _, err := fmt.Fprintf(w, " must_have_one_flag=()\n"); err != nil {
+ return err
+ }
+ flags := cmd.NonInheritedFlags()
+ var visitErr error
+ flags.VisitAll(func(flag *pflag.Flag) {
+ if nonCompletableFlag(flag) {
+ return
+ }
+ for key := range flag.Annotations {
+ switch key {
+ case BashCompOneRequiredFlag:
+ format := " must_have_one_flag+=(\"--%s"
+ b := (flag.Value.Type() == "bool")
+ if !b {
+ format += "="
+ }
+ format += "\")\n"
+ if _, err := fmt.Fprintf(w, format, flag.Name); err != nil {
+ visitErr = err
+ return
+ }
+
+ if len(flag.Shorthand) > 0 {
+ if _, err := fmt.Fprintf(w, " must_have_one_flag+=(\"-%s\")\n", flag.Shorthand); err != nil {
+ visitErr = err
+ return
+ }
+ }
+ }
+ }
+ })
+ return visitErr
+}
+
+func writeRequiredNouns(cmd *Command, w io.Writer) error {
+ if _, err := fmt.Fprintf(w, " must_have_one_noun=()\n"); err != nil {
+ return err
+ }
+ sort.Sort(sort.StringSlice(cmd.ValidArgs))
+ for _, value := range cmd.ValidArgs {
+ if _, err := fmt.Fprintf(w, " must_have_one_noun+=(%q)\n", value); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func writeArgAliases(cmd *Command, w io.Writer) error {
+ if _, err := fmt.Fprintf(w, " noun_aliases=()\n"); err != nil {
+ return err
+ }
+ sort.Sort(sort.StringSlice(cmd.ArgAliases))
+ for _, value := range cmd.ArgAliases {
+ if _, err := fmt.Fprintf(w, " noun_aliases+=(%q)\n", value); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func gen(cmd *Command, w io.Writer) error {
+ for _, c := range cmd.Commands() {
+ if !c.IsAvailableCommand() || c == cmd.helpCommand {
+ continue
+ }
+ if err := gen(c, w); err != nil {
+ return err
+ }
+ }
+ commandName := cmd.CommandPath()
+ commandName = strings.Replace(commandName, " ", "_", -1)
+ commandName = strings.Replace(commandName, ":", "__", -1)
+ if _, err := fmt.Fprintf(w, "_%s()\n{\n", commandName); err != nil {
+ return err
+ }
+ if _, err := fmt.Fprintf(w, " last_command=%q\n", commandName); err != nil {
+ return err
+ }
+ if err := writeCommands(cmd, w); err != nil {
+ return err
+ }
+ if err := writeFlags(cmd, w); err != nil {
+ return err
+ }
+ if err := writeRequiredFlag(cmd, w); err != nil {
+ return err
+ }
+ if err := writeRequiredNouns(cmd, w); err != nil {
+ return err
+ }
+ if err := writeArgAliases(cmd, w); err != nil {
+ return err
+ }
+ if _, err := fmt.Fprintf(w, "}\n\n"); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (cmd *Command) GenBashCompletion(w io.Writer) error {
+ if err := preamble(w, cmd.Name()); err != nil {
+ return err
+ }
+ if len(cmd.BashCompletionFunction) > 0 {
+ if _, err := fmt.Fprintf(w, "%s\n", cmd.BashCompletionFunction); err != nil {
+ return err
+ }
+ }
+ if err := gen(cmd, w); err != nil {
+ return err
+ }
+ return postscript(w, cmd.Name())
+}
+
+func nonCompletableFlag(flag *pflag.Flag) bool {
+ return flag.Hidden || len(flag.Deprecated) > 0
+}
+
+func (cmd *Command) GenBashCompletionFile(filename string) error {
+ outFile, err := os.Create(filename)
+ if err != nil {
+ return err
+ }
+ defer outFile.Close()
+
+ return cmd.GenBashCompletion(outFile)
+}
+
+// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists.
+func (cmd *Command) MarkFlagRequired(name string) error {
+ return MarkFlagRequired(cmd.Flags(), name)
+}
+
+// MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag, if it exists.
+func (cmd *Command) MarkPersistentFlagRequired(name string) error {
+ return MarkFlagRequired(cmd.PersistentFlags(), name)
+}
+
+// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists.
+func MarkFlagRequired(flags *pflag.FlagSet, name string) error {
+ return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"})
+}
+
+// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists.
+// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
+func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error {
+ return MarkFlagFilename(cmd.Flags(), name, extensions...)
+}
+
+// MarkFlagCustom adds the BashCompCustom annotation to the named flag, if it exists.
+// Generated bash autocompletion will call the bash function f for the flag.
+func (cmd *Command) MarkFlagCustom(name string, f string) error {
+ return MarkFlagCustom(cmd.Flags(), name, f)
+}
+
+// MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists.
+// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
+func (cmd *Command) MarkPersistentFlagFilename(name string, extensions ...string) error {
+ return MarkFlagFilename(cmd.PersistentFlags(), name, extensions...)
+}
+
+// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists.
+// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
+func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error {
+ return flags.SetAnnotation(name, BashCompFilenameExt, extensions)
+}
+
+// MarkFlagCustom adds the BashCompCustom annotation to the named flag in the flag set, if it exists.
+// Generated bash autocompletion will call the bash function f for the flag.
+func MarkFlagCustom(flags *pflag.FlagSet, name string, f string) error {
+ return flags.SetAnnotation(name, BashCompCustom, []string{f})
+}
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md b/vendor/github.com/spf13/cobra/bash_completions.md
similarity index 73%
rename from Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
rename to vendor/github.com/spf13/cobra/bash_completions.md
index 204704efc14ccc870d88abfdaaabdc942add6257..6e3b71f13d518cbae4bcbbe49701808ef30d7bd3 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
+++ b/vendor/github.com/spf13/cobra/bash_completions.md
@@ -80,7 +80,7 @@ The `BashCompletionFunction` option is really only valid/useful on the root comm
In the above example "pod" was assumed to already be typed. But if you want `kubectl get [tab][tab]` to show a list of valid "nouns" you have to set them. Simplified code from `kubectl get` looks like:
```go
-validArgs []string = { "pods", "nodes", "services", "replicationControllers" }
+validArgs []string = { "pod", "node", "service", "replicationcontroller" }
cmd := &cobra.Command{
Use: "get [(-o|--output=)json|yaml|template|...] (RESOURCE [NAME] | RESOURCE/NAME ...)",
@@ -99,9 +99,34 @@ Notice we put the "ValidArgs" on the "get" subcommand. Doing so will give result
```bash
# kubectl get [tab][tab]
-nodes pods replicationControllers services
+node pod replicationcontroller service
```
+## Plural form and shortcuts for nouns
+
+If your nouns have a number of aliases, you can define them alongside `ValidArgs` using `ArgAliases`:
+
+```go`
+argAliases []string = { "pods", "nodes", "services", "svc", "replicationcontrollers", "rc" }
+
+cmd := &cobra.Command{
+ ...
+ ValidArgs: validArgs,
+ ArgAliases: argAliases
+}
+```
+
+The aliases are not shown to the user on tab completion, but they are accepted as valid nouns by
+the completion algorithm if entered manually, e.g. in:
+
+```bash
+# kubectl get rc [tab][tab]
+backend frontend database
+```
+
+Note that without declaring `rc` as an alias, the completion algorithm would show the list of nouns
+in this example again instead of the replication controllers.
+
## Mark flags as required
Most of the time completions will only show subcommands. But if a flag is required to make a subcommand work, you probably want it to show up when the user types [tab][tab]. Marking a flag as 'Required' is incredibly easy.
@@ -147,3 +172,35 @@ hello.yml test.json
```
So while there are many other files in the CWD it only shows me subdirs and those with valid extensions.
+
+# Specifiy custom flag completion
+
+Similar to the filename completion and filtering using cobra.BashCompFilenameExt, you can specifiy
+a custom flag completion function with cobra.BashCompCustom:
+
+```go
+ annotation := make(map[string][]string)
+ annotation[cobra.BashCompFilenameExt] = []string{"__kubectl_get_namespaces"}
+
+ flag := &pflag.Flag{
+ Name: "namespace",
+ Usage: usage,
+ Annotations: annotation,
+ }
+ cmd.Flags().AddFlag(flag)
+```
+
+In addition add the `__handle_namespace_flag` implementation in the `BashCompletionFunction`
+value, e.g.:
+
+```bash
+__kubectl_get_namespaces()
+{
+ local template
+ template="{{ range .items }}{{ .metadata.name }} {{ end }}"
+ local kubectl_out
+ if kubectl_out=$(kubectl get -o template --template="${template}" namespace 2>/dev/null); then
+ COMPREPLY=( $( compgen -W "${kubectl_out}[*]" -- "$cur" ) )
+ fi
+}
+```
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go b/vendor/github.com/spf13/cobra/cobra.go
similarity index 85%
rename from Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
rename to vendor/github.com/spf13/cobra/cobra.go
index 20957cdd1faaa59ffbd166a2279bc1cb91addb52..93a2c0f3a77d73a491fbf5a56fb07e36c80e36b6 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
+++ b/vendor/github.com/spf13/cobra/cobra.go
@@ -26,27 +26,24 @@ import (
"unicode"
)
-var templateFuncs template.FuncMap = template.FuncMap{
- "trim": strings.TrimSpace,
- "trimRightSpace": trimRightSpace,
- "rpad": rpad,
- "gt": Gt,
- "eq": Eq,
+var templateFuncs = template.FuncMap{
+ "trim": strings.TrimSpace,
+ "trimRightSpace": trimRightSpace,
+ "appendIfNotPresent": appendIfNotPresent,
+ "rpad": rpad,
+ "gt": Gt,
+ "eq": Eq,
}
var initializers []func()
// automatic prefix matching can be a dangerous thing to automatically enable in CLI tools.
// Set this to true to enable it
-var EnablePrefixMatching bool = false
+var EnablePrefixMatching = false
-// enables an information splash screen on Windows if the CLI is started from explorer.exe.
-var EnableWindowsMouseTrap bool = true
-
-var MousetrapHelpText string = `This is a command line tool
-
-You need to open cmd.exe and run it from there.
-`
+//EnableCommandSorting controls sorting of the slice of commands, which is turned on by default.
+//To disable sorting, set it to false.
+var EnableCommandSorting = true
//AddTemplateFunc adds a template function that's available to Usage and Help
//template generation.
@@ -119,6 +116,14 @@ func trimRightSpace(s string) string {
return strings.TrimRightFunc(s, unicode.IsSpace)
}
+// appendIfNotPresent will append stringToAppend to the end of s, but only if it's not yet present in s
+func appendIfNotPresent(s, stringToAppend string) string {
+ if strings.Contains(s, stringToAppend) {
+ return s
+ }
+ return s + " " + stringToAppend
+}
+
//rpad adds padding to the right of a string
func rpad(s string, padding int) string {
template := fmt.Sprintf("%%-%ds", padding)
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/command.go b/vendor/github.com/spf13/cobra/command.go
similarity index 86%
rename from Godeps/_workspace/src/github.com/spf13/cobra/command.go
rename to vendor/github.com/spf13/cobra/command.go
index f5fa34e2af39cf9e596595f8bc03516f4919aa72..083e4ea7f47b52bef8b34e6c5aa53d30436ee926 100644
--- a/Godeps/_workspace/src/github.com/spf13/cobra/command.go
+++ b/vendor/github.com/spf13/cobra/command.go
@@ -21,11 +21,9 @@ import (
"io"
"os"
"path/filepath"
- "runtime"
+ "sort"
"strings"
- "time"
- "github.com/inconshreveable/mousetrap"
flag "github.com/spf13/pflag"
)
@@ -48,8 +46,11 @@ type Command struct {
Long string
// Examples of how to use the command
Example string
- // List of all valid non-flag arguments, used for bash completions *TODO* actually validate these
+ // List of all valid non-flag arguments that are accepted in bash completions
ValidArgs []string
+ // List of aliases for ValidArgs. These are not suggested to the user in the bash
+ // completion, but accepted if entered manually.
+ ArgAliases []string
// Custom functions used by the bash autocompletion generator
BashCompletionFunction string
// Is this command deprecated and should print this string when used?
@@ -103,11 +104,13 @@ type Command struct {
commandsMaxUseLen int
commandsMaxCommandPathLen int
commandsMaxNameLen int
+ // is commands slice are sorted or not
+ commandsAreSorted bool
flagErrorBuf *bytes.Buffer
args []string // actual args parsed from flags
- output *io.Writer // nil means stderr; use Out() method instead
+ output *io.Writer // out writer if set in SetOutput(w)
usageFunc func(*Command) error // Usage can be defined by application
usageTemplate string // Can be defined by Application
helpTemplate string // Can be defined by Application
@@ -120,6 +123,9 @@ type Command struct {
DisableSuggestions bool
// If displaying suggestions, allows to set the minimum levenshtein distance to display, must be > 0
SuggestionsMinimumDistance int
+
+ // Disable the flag parsing. If this is true all flags will be passed to the command as arguments.
+ DisableFlagParsing bool
}
// os.Args[1:] by default, if desired, can be overridden
@@ -128,26 +134,6 @@ func (c *Command) SetArgs(a []string) {
c.args = a
}
-func (c *Command) getOut(def io.Writer) io.Writer {
- if c.output != nil {
- return *c.output
- }
-
- if c.HasParent() {
- return c.parent.Out()
- } else {
- return def
- }
-}
-
-func (c *Command) Out() io.Writer {
- return c.getOut(os.Stderr)
-}
-
-func (c *Command) getOutOrStdout() io.Writer {
- return c.getOut(os.Stdout)
-}
-
// SetOutput sets the destination for usage and error messages.
// If output is nil, os.Stderr is used.
func (c *Command) SetOutput(output io.Writer) {
@@ -190,6 +176,26 @@ func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string
}
}
+func (c *Command) OutOrStdout() io.Writer {
+ return c.getOut(os.Stdout)
+}
+
+func (c *Command) OutOrStderr() io.Writer {
+ return c.getOut(os.Stderr)
+}
+
+func (c *Command) getOut(def io.Writer) io.Writer {
+ if c.output != nil {
+ return *c.output
+ }
+ if c.HasParent() {
+ return c.parent.getOut(def)
+ }
+ return def
+}
+
+// UsageFunc returns either the function set by SetUsageFunc for this command
+// or a parent, or it returns a default usage function
func (c *Command) UsageFunc() (f func(*Command) error) {
if c.usageFunc != nil {
return c.usageFunc
@@ -197,19 +203,26 @@ func (c *Command) UsageFunc() (f func(*Command) error) {
if c.HasParent() {
return c.parent.UsageFunc()
- } else {
- return func(c *Command) error {
- err := tmpl(c.Out(), c.UsageTemplate(), c)
- if err != nil {
- fmt.Print(err)
- }
- return err
+ }
+ return func(c *Command) error {
+ c.mergePersistentFlags()
+ err := tmpl(c.OutOrStderr(), c.UsageTemplate(), c)
+ if err != nil {
+ c.Println(err)
}
+ return err
}
}
+// Output the usage for the command
+// Used when a user provides invalid input
+// Can be defined by user by overriding UsageFunc
+func (c *Command) Usage() error {
+ return c.UsageFunc()(c)
+}
+
// HelpFunc returns either the function set by SetHelpFunc for this command
-// or a parent, or it returns a function which calls c.Help()
+// or a parent, or it returns a function with default help behavior
func (c *Command) HelpFunc() func(*Command, []string) {
cmd := c
for cmd != nil {
@@ -219,42 +232,57 @@ func (c *Command) HelpFunc() func(*Command, []string) {
cmd = cmd.parent
}
return func(*Command, []string) {
- err := c.Help()
+ c.mergePersistentFlags()
+ err := tmpl(c.OutOrStdout(), c.HelpTemplate(), c)
if err != nil {
c.Println(err)
}
}
}
-var minUsagePadding int = 25
+// Output the help for the command
+// Used when a user calls help [command]
+// Can be defined by user by overriding HelpFunc
+func (c *Command) Help() error {
+ c.HelpFunc()(c, []string{})
+ return nil
+}
+
+func (c *Command) UsageString() string {
+ tmpOutput := c.output
+ bb := new(bytes.Buffer)
+ c.SetOutput(bb)
+ c.Usage()
+ c.output = tmpOutput
+ return bb.String()
+}
+
+var minUsagePadding = 25
func (c *Command) UsagePadding() int {
if c.parent == nil || minUsagePadding > c.parent.commandsMaxUseLen {
return minUsagePadding
- } else {
- return c.parent.commandsMaxUseLen
}
+ return c.parent.commandsMaxUseLen
}
-var minCommandPathPadding int = 11
+var minCommandPathPadding = 11
//
func (c *Command) CommandPathPadding() int {
if c.parent == nil || minCommandPathPadding > c.parent.commandsMaxCommandPathLen {
return minCommandPathPadding
- } else {
- return c.parent.commandsMaxCommandPathLen
}
+ return c.parent.commandsMaxCommandPathLen
}
-var minNamePadding int = 11
+var minNamePadding = 11
func (c *Command) NamePadding() int {
if c.parent == nil || minNamePadding > c.parent.commandsMaxNameLen {
return minNamePadding
- } else {
- return c.parent.commandsMaxNameLen
}
+ return c.parent.commandsMaxNameLen
}
func (c *Command) UsageTemplate() string {
@@ -264,9 +292,9 @@ func (c *Command) UsageTemplate() string {
if c.HasParent() {
return c.parent.UsageTemplate()
- } else {
- return `Usage:{{if .Runnable}}
- {{.UseLine}}{{if .HasFlags}} [flags]{{end}}{{end}}{{if .HasSubCommands}}
+ }
+ return `Usage:{{if .Runnable}}
+ {{if .HasAvailableFlags}}{{appendIfNotPresent .UseLine "[flags]"}}{{else}}{{.UseLine}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
{{ .CommandPath}} [command]{{end}}{{if gt .Aliases 0}}
Aliases:
@@ -277,20 +305,19 @@ Examples:
{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}}
Available Commands:{{range .Commands}}{{if .IsAvailableCommand}}
- {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasLocalFlags}}
+ {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableLocalFlags}}
Flags:
-{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasInheritedFlags}}
+{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasAvailableInheritedFlags}}
Global Flags:
{{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}}
Additional help topics:{{range .Commands}}{{if .IsHelpCommand}}
- {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasSubCommands }}
+ {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableSubCommands }}
Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
`
- }
}
func (c *Command) HelpTemplate() string {
@@ -300,11 +327,10 @@ func (c *Command) HelpTemplate() string {
if c.HasParent() {
return c.parent.HelpTemplate()
- } else {
- return `{{with or .Long .Short }}{{. | trim}}
+ }
+ return `{{with or .Long .Short }}{{. | trim}}
{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}`
- }
}
// Really only used when casting a command to a commander
@@ -538,12 +564,17 @@ func (c *Command) execute(a []string) (err error) {
c.Println("\"help\" flag declared as non-bool. Please correct your code")
return err
}
+
if helpVal || !c.Runnable() {
return flag.ErrHelp
}
c.preRun()
+
argWoFlags := c.Flags().Args()
+ if c.DisableFlagParsing {
+ argWoFlags = a
+ }
for p := c; p != nil; p = p.Parent() {
if p.PersistentPreRunE != nil {
@@ -606,9 +637,8 @@ func (c *Command) errorMsgFromParse() string {
if len(x) > 0 {
return x[0]
- } else {
- return ""
}
+ return ""
}
// Call execute to use the args (os.Args[1:] by default)
@@ -626,12 +656,9 @@ func (c *Command) ExecuteC() (cmd *Command, err error) {
return c.Root().ExecuteC()
}
- if EnableWindowsMouseTrap && runtime.GOOS == "windows" {
- if mousetrap.StartedByExplorer() {
- c.Print(MousetrapHelpText)
- time.Sleep(5 * time.Second)
- os.Exit(1)
- }
+ // windows hook
+ if preExecHookFn != nil {
+ preExecHookFn(c)
}
// initialize help as the last point possible to allow for user
@@ -641,7 +668,7 @@ func (c *Command) ExecuteC() (cmd *Command, err error) {
var args []string
// Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155
- if len(c.args) == 0 && filepath.Base(os.Args[0]) != "cobra.test" {
+ if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" {
args = os.Args[1:]
} else {
args = c.args
@@ -661,13 +688,16 @@ func (c *Command) ExecuteC() (cmd *Command, err error) {
}
err = cmd.execute(flags)
if err != nil {
+ // Always show help if requested, even if SilenceErrors is in
+ // effect
+ if err == flag.ErrHelp {
+ cmd.HelpFunc()(cmd, args)
+ return cmd, nil
+ }
+
// If root command has SilentErrors flagged,
// all subcommands should respect it
if !cmd.SilenceErrors && !c.SilenceErrors {
- if err == flag.ErrHelp {
- cmd.HelpFunc()(cmd, args)
- return cmd, nil
- }
c.Println("Error:", err.Error())
}
@@ -707,8 +737,7 @@ func (c *Command) initHelpCmd() {
c.Printf("Unknown help topic %#q.", args)
c.Root().Usage()
} else {
- helpFunc := cmd.HelpFunc()
- helpFunc(cmd, args)
+ cmd.Help()
}
},
}
@@ -722,8 +751,20 @@ func (c *Command) ResetCommands() {
c.helpCommand = nil
}
-//Commands returns a slice of child commands.
+// Sorts commands by their names
+type commandSorterByName []*Command
+
+func (c commandSorterByName) Len() int { return len(c) }
+func (c commandSorterByName) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
+func (c commandSorterByName) Less(i, j int) bool { return c[i].Name() < c[j].Name() }
+
+// Commands returns a sorted slice of child commands.
func (c *Command) Commands() []*Command {
+ // do not sort commands if it already sorted or sorting was disabled
+ if EnableCommandSorting && !c.commandsAreSorted {
+ sort.Sort(commandSorterByName(c.commands))
+ c.commandsAreSorted = true
+ }
return c.commands
}
@@ -747,15 +788,16 @@ func (c *Command) AddCommand(cmds ...*Command) {
if nameLen > c.commandsMaxNameLen {
c.commandsMaxNameLen = nameLen
}
- // If glabal normalization function exists, update all children
+ // If global normalization function exists, update all children
if c.globNormFunc != nil {
x.SetGlobalNormalizationFunc(c.globNormFunc)
}
c.commands = append(c.commands, x)
+ c.commandsAreSorted = false
}
}
-// AddCommand removes one or more commands from a parent command.
+// RemoveCommand removes one or more commands from a parent command.
func (c *Command) RemoveCommand(cmds ...*Command) {
commands := []*Command{}
main:
@@ -789,50 +831,23 @@ main:
}
}
-// Convenience method to Print to the defined output
+// Print is a convenience method to Print to the defined output, fallback to Stderr if not set
func (c *Command) Print(i ...interface{}) {
- fmt.Fprint(c.Out(), i...)
+ fmt.Fprint(c.OutOrStderr(), i...)
}
-// Convenience method to Println to the defined output
+// Println is a convenience method to Println to the defined output, fallback to Stderr if not set
func (c *Command) Println(i ...interface{}) {
str := fmt.Sprintln(i...)
c.Print(str)
}
-// Convenience method to Printf to the defined output
+// Printf is a convenience method to Printf to the defined output, fallback to Stderr if not set
func (c *Command) Printf(format string, i ...interface{}) {
str := fmt.Sprintf(format, i...)
c.Print(str)
}
-// Output the usage for the command
-// Used when a user provides invalid input
-// Can be defined by user by overriding UsageFunc
-func (c *Command) Usage() error {
- c.mergePersistentFlags()
- err := c.UsageFunc()(c)
- return err
-}
-
-// Output the help for the command
-// Used when a user calls help [command]
-// by the default HelpFunc in the commander
-func (c *Command) Help() error {
- c.mergePersistentFlags()
- err := tmpl(c.getOutOrStdout(), c.HelpTemplate(), c)
- return err
-}
-
-func (c *Command) UsageString() string {
- tmpOutput := c.output
- bb := new(bytes.Buffer)
- c.SetOutput(bb)
- c.Usage()
- c.output = tmpOutput
- return bb.String()
-}
-
// CommandPath returns the full path to this command.
func (c *Command) CommandPath() string {
str := c.Name()
@@ -911,7 +926,7 @@ func (c *Command) Name() string {
return name
}
-// Determine if a given string is an alias of the command.
+// HasAlias determines if a given string is an alias of the command.
func (c *Command) HasAlias(s string) bool {
for _, a := range c.Aliases {
if a == s {
@@ -929,12 +944,12 @@ func (c *Command) HasExample() bool {
return len(c.Example) > 0
}
-// Determine if the command is itself runnable
+// Runnable determines if the command is itself runnable
func (c *Command) Runnable() bool {
return c.Run != nil || c.RunE != nil
}
-// Determine if the command has children commands
+// HasSubCommands determines if the command has children commands
func (c *Command) HasSubCommands() bool {
return len(c.commands) > 0
}
@@ -1033,6 +1048,19 @@ func (c *Command) Flags() *flag.FlagSet {
return c.flags
}
+// LocalNonPersistentFlags are flags specific to this command which will NOT persist to subcommands
+func (c *Command) LocalNonPersistentFlags() *flag.FlagSet {
+ persistentFlags := c.PersistentFlags()
+
+ out := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ c.LocalFlags().VisitAll(func(f *flag.Flag) {
+ if persistentFlags.Lookup(f.Name) == nil {
+ out.AddFlag(f)
+ }
+ })
+ return out
+}
+
// Get the local FlagSet specifically set in the current command
func (c *Command) LocalFlags() *flag.FlagSet {
c.mergePersistentFlags()
@@ -1122,11 +1150,35 @@ func (c *Command) HasLocalFlags() bool {
return c.LocalFlags().HasFlags()
}
+// Does the command have flags inherited from its parent command
func (c *Command) HasInheritedFlags() bool {
return c.InheritedFlags().HasFlags()
}
-// Climbs up the command tree looking for matching flag
+// Does the command contain any flags (local plus persistent from the entire
+// structure) which are not hidden or deprecated
+func (c *Command) HasAvailableFlags() bool {
+ return c.Flags().HasAvailableFlags()
+}
+
+// Does the command contain persistent flags which are not hidden or deprecated
+func (c *Command) HasAvailablePersistentFlags() bool {
+ return c.PersistentFlags().HasAvailableFlags()
+}
+
+// Does the command has flags specifically declared locally which are not hidden
+// or deprecated
+func (c *Command) HasAvailableLocalFlags() bool {
+ return c.LocalFlags().HasAvailableFlags()
+}
+
+// Does the command have flags inherited from its parent command which are
+// not hidden or deprecated
+func (c *Command) HasAvailableInheritedFlags() bool {
+ return c.InheritedFlags().HasAvailableFlags()
+}
+
+// Flag climbs up the command tree looking for matching flag
func (c *Command) Flag(name string) (flag *flag.Flag) {
flag = c.Flags().Lookup(name)
@@ -1149,13 +1201,17 @@ func (c *Command) persistentFlag(name string) (flag *flag.Flag) {
return
}
-// Parses persistent flag tree & local flags
+// ParseFlags parses persistent flag tree & local flags
func (c *Command) ParseFlags(args []string) (err error) {
+ if c.DisableFlagParsing {
+ return nil
+ }
c.mergePersistentFlags()
err = c.Flags().Parse(args)
return
}
+// Parent returns a commands parent command
func (c *Command) Parent() *Command {
return c.parent
}
diff --git a/vendor/github.com/spf13/cobra/command_notwin.go b/vendor/github.com/spf13/cobra/command_notwin.go
new file mode 100644
index 0000000000000000000000000000000000000000..6159c1cc19d453a33a229cf81abac093c4f36796
--- /dev/null
+++ b/vendor/github.com/spf13/cobra/command_notwin.go
@@ -0,0 +1,5 @@
+// +build !windows
+
+package cobra
+
+var preExecHookFn func(*Command)
diff --git a/vendor/github.com/spf13/cobra/command_win.go b/vendor/github.com/spf13/cobra/command_win.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b0eaa1b6bc7e0f388763d32a62f915197db19ec
--- /dev/null
+++ b/vendor/github.com/spf13/cobra/command_win.go
@@ -0,0 +1,26 @@
+// +build windows
+
+package cobra
+
+import (
+ "os"
+ "time"
+
+ "github.com/inconshreveable/mousetrap"
+)
+
+var preExecHookFn = preExecHook
+
+// enables an information splash screen on Windows if the CLI is started from explorer.exe.
+var MousetrapHelpText string = `This is a command line tool
+
+You need to open cmd.exe and run it from there.
+`
+
+func preExecHook(c *Command) {
+ if mousetrap.StartedByExplorer() {
+ c.Print(MousetrapHelpText)
+ time.Sleep(5 * time.Second)
+ os.Exit(1)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/.travis.yml b/vendor/github.com/spf13/pflag/.travis.yml
similarity index 60%
rename from Godeps/_workspace/src/github.com/spf13/pflag/.travis.yml
rename to vendor/github.com/spf13/pflag/.travis.yml
index df435a03fd989fc03161149787e84f4e77eb5e73..0a7c136222914a940f4139f76dff16a805c54b5d 100644
--- a/Godeps/_workspace/src/github.com/spf13/pflag/.travis.yml
+++ b/vendor/github.com/spf13/pflag/.travis.yml
@@ -3,16 +3,19 @@ sudo: false
language: go
go:
- - 1.3
- - 1.4
- - 1.5
+ - 1.5.4
+ - 1.6.3
+ - 1.7
- tip
+matrix:
+ allow_failures:
+ - go: tip
install:
- go get github.com/golang/lint/golint
- export PATH=$GOPATH/bin:$PATH
- go install ./...
script:
- - verify/all.sh
+ - verify/all.sh -v
- go test ./...
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/LICENSE b/vendor/github.com/spf13/pflag/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/LICENSE
rename to vendor/github.com/spf13/pflag/LICENSE
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/README.md b/vendor/github.com/spf13/pflag/README.md
similarity index 93%
rename from Godeps/_workspace/src/github.com/spf13/pflag/README.md
rename to vendor/github.com/spf13/pflag/README.md
index e74dd50b41c67d121f7fac20fcf280810756d23d..08ad9456588688778ed462640a75278d426147f8 100644
--- a/Godeps/_workspace/src/github.com/spf13/pflag/README.md
+++ b/vendor/github.com/spf13/pflag/README.md
@@ -85,7 +85,7 @@ fmt.Println("flagvar has value ", flagvar)
```
There are helpers function to get values later if you have the FlagSet but
-it was difficult to keep up with all of the the flag pointers in your code.
+it was difficult to keep up with all of the flag pointers in your code.
If you have a pflag.FlagSet with a flag called 'flagname' of type int you
can use GetInt() to get the int value. But notice that 'flagname' must exist
and it must be an int. GetString("flagname") will fail.
@@ -244,6 +244,25 @@ It is possible to mark a flag as hidden, meaning it will still function as norma
flags.MarkHidden("secretFlag")
```
+## Supporting Go flags when using pflag
+In order to support flags defined using Go's `flag` package, they must be added to the `pflag` flagset. This is usually necessary
+to support flags defined by third-party dependencies (e.g. `golang/glog`).
+
+**Example**: You want to add the Go flags to the `CommandLine` flagset
+```go
+import (
+ goflag "flag"
+ flag "github.com/spf13/pflag"
+)
+
+var ip *int = flag.Int("flagname", 1234, "help message for flagname")
+
+func main() {
+ flag.CommandLine.AddGoFlagSet(goflag.CommandLine)
+ flag.Parse()
+}
+```
+
## More info
You can see the full reference documentation of the pflag package
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/bool.go b/vendor/github.com/spf13/pflag/bool.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/bool.go
rename to vendor/github.com/spf13/pflag/bool.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/count.go b/vendor/github.com/spf13/pflag/count.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/count.go
rename to vendor/github.com/spf13/pflag/count.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/duration.go b/vendor/github.com/spf13/pflag/duration.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/duration.go
rename to vendor/github.com/spf13/pflag/duration.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/flag.go b/vendor/github.com/spf13/pflag/flag.go
similarity index 88%
rename from Godeps/_workspace/src/github.com/spf13/pflag/flag.go
rename to vendor/github.com/spf13/pflag/flag.go
index fd914403418d5042376a0117bc4fad71dd49d02c..eb143d79ac16f86d7f738858f4df277226a1e2e7 100644
--- a/Godeps/_workspace/src/github.com/spf13/pflag/flag.go
+++ b/vendor/github.com/spf13/pflag/flag.go
@@ -242,6 +242,17 @@ func (f *FlagSet) HasFlags() bool {
return len(f.formal) > 0
}
+// HasAvailableFlags returns a bool to indicate if the FlagSet has any flags
+// definied that are not hidden or deprecated.
+func (f *FlagSet) HasAvailableFlags() bool {
+ for _, flag := range f.formal {
+ if !flag.Hidden && len(flag.Deprecated) == 0 {
+ return true
+ }
+ }
+ return false
+}
+
// VisitAll visits the command-line flags in lexicographical order, calling
// fn for each. It visits all flags, even those not set.
func VisitAll(fn func(*Flag)) {
@@ -408,41 +419,126 @@ func (f *FlagSet) PrintDefaults() {
fmt.Fprintf(f.out(), "%s", usages)
}
+// defaultIsZeroValue returns true if the default value for this flag represents
+// a zero value.
+func (f *Flag) defaultIsZeroValue() bool {
+ switch f.Value.(type) {
+ case boolFlag:
+ return f.DefValue == "false"
+ case *durationValue:
+ // Beginning in Go 1.7, duration zero values are "0s"
+ return f.DefValue == "0" || f.DefValue == "0s"
+ case *intValue, *int8Value, *int32Value, *int64Value, *uintValue, *uint8Value, *uint16Value, *uint32Value, *uint64Value, *countValue, *float32Value, *float64Value:
+ return f.DefValue == "0"
+ case *stringValue:
+ return f.DefValue == ""
+ case *ipValue, *ipMaskValue, *ipNetValue:
+ return f.DefValue == "<nil>"
+ case *intSliceValue, *stringSliceValue:
+ return f.DefValue == "[]"
+ default:
+ return true
+ }
+}
+
+// UnquoteUsage extracts a back-quoted name from the usage
+// string for a flag and returns it and the un-quoted usage.
+// Given "a `name` to show" it returns ("name", "a name to show").
+// If there are no back quotes, the name is an educated guess of the
+// type of the flag's value, or the empty string if the flag is boolean.
+func UnquoteUsage(flag *Flag) (name string, usage string) {
+ // Look for a back-quoted name, but avoid the strings package.
+ usage = flag.Usage
+ for i := 0; i < len(usage); i++ {
+ if usage[i] == '`' {
+ for j := i + 1; j < len(usage); j++ {
+ if usage[j] == '`' {
+ name = usage[i+1 : j]
+ usage = usage[:i] + name + usage[j+1:]
+ return name, usage
+ }
+ }
+ break // Only one back quote; use type name.
+ }
+ }
+
+ name = flag.Value.Type()
+ switch name {
+ case "bool":
+ name = ""
+ case "float64":
+ name = "float"
+ case "int64":
+ name = "int"
+ case "uint64":
+ name = "uint"
+ }
+
+ return
+}
+
// FlagUsages Returns a string containing the usage information for all flags in
// the FlagSet
func (f *FlagSet) FlagUsages() string {
x := new(bytes.Buffer)
+ lines := make([]string, 0, len(f.formal))
+
+ maxlen := 0
f.VisitAll(func(flag *Flag) {
if len(flag.Deprecated) > 0 || flag.Hidden {
return
}
- format := ""
+
+ line := ""
if len(flag.Shorthand) > 0 && len(flag.ShorthandDeprecated) == 0 {
- format = " -%s, --%s"
+ line = fmt.Sprintf(" -%s, --%s", flag.Shorthand, flag.Name)
} else {
- format = " %s --%s"
+ line = fmt.Sprintf(" --%s", flag.Name)
}
- if len(flag.NoOptDefVal) > 0 {
- format = format + "["
- }
- if flag.Value.Type() == "string" {
- // put quotes on the value
- format = format + "=%q"
- } else {
- format = format + "=%s"
+
+ varname, usage := UnquoteUsage(flag)
+ if len(varname) > 0 {
+ line += " " + varname
}
if len(flag.NoOptDefVal) > 0 {
- format = format + "]"
+ switch flag.Value.Type() {
+ case "string":
+ line += fmt.Sprintf("[=%q]", flag.NoOptDefVal)
+ case "bool":
+ if flag.NoOptDefVal != "true" {
+ line += fmt.Sprintf("[=%s]", flag.NoOptDefVal)
+ }
+ default:
+ line += fmt.Sprintf("[=%s]", flag.NoOptDefVal)
+ }
+ }
+
+ // This special character will be replaced with spacing once the
+ // correct alignment is calculated
+ line += "\x00"
+ if len(line) > maxlen {
+ maxlen = len(line)
}
- format = format + ": %s\n"
- shorthand := flag.Shorthand
- if len(flag.ShorthandDeprecated) > 0 {
- shorthand = ""
+
+ line += usage
+ if !flag.defaultIsZeroValue() {
+ if flag.Value.Type() == "string" {
+ line += fmt.Sprintf(" (default %q)", flag.DefValue)
+ } else {
+ line += fmt.Sprintf(" (default %s)", flag.DefValue)
+ }
}
- fmt.Fprintf(x, format, shorthand, flag.Name, flag.DefValue, flag.Usage)
+
+ lines = append(lines, line)
})
+ for _, line := range lines {
+ sidx := strings.Index(line, "\x00")
+ spacing := strings.Repeat(" ", maxlen-sidx)
+ fmt.Fprintln(x, line[:sidx], spacing, line[sidx+1:])
+ }
+
return x.String()
}
@@ -463,6 +559,8 @@ func defaultUsage(f *FlagSet) {
// Usage prints to standard error a usage message documenting all defined command-line flags.
// The function is a variable that may be changed to point to a custom function.
+// By default it prints a simple header and calls PrintDefaults; for details about the
+// format of the output and how to control it, see the documentation for PrintDefaults.
var Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
PrintDefaults()
@@ -683,6 +781,9 @@ func (f *FlagSet) parseLongArg(s string, args []string) (a []string, err error)
}
func (f *FlagSet) parseSingleShortArg(shorthands string, args []string) (outShorts string, outArgs []string, err error) {
+ if strings.HasPrefix(shorthands, "test.") {
+ return
+ }
outArgs = args
outShorts = shorthands[1:]
c := shorthands[0]
@@ -806,7 +907,7 @@ func Parsed() bool {
return CommandLine.Parsed()
}
-// The default set of command-line flags, parsed from os.Args.
+// CommandLine is the default set of command-line flags, parsed from os.Args.
var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
// NewFlagSet returns a new, empty flag set with the specified name and
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/float32.go b/vendor/github.com/spf13/pflag/float32.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/float32.go
rename to vendor/github.com/spf13/pflag/float32.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/float64.go b/vendor/github.com/spf13/pflag/float64.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/float64.go
rename to vendor/github.com/spf13/pflag/float64.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/golangflag.go b/vendor/github.com/spf13/pflag/golangflag.go
similarity index 86%
rename from Godeps/_workspace/src/github.com/spf13/pflag/golangflag.go
rename to vendor/github.com/spf13/pflag/golangflag.go
index a8c24efb644f147c0bae0123f9f16cbf00731446..b056147fd876666b18c50b9c24db5325e6b7ffa3 100644
--- a/Godeps/_workspace/src/github.com/spf13/pflag/golangflag.go
+++ b/vendor/github.com/spf13/pflag/golangflag.go
@@ -61,6 +61,9 @@ func (v *flagValueWrapper) Type() string {
}
// PFlagFromGoFlag will return a *pflag.Flag given a *flag.Flag
+// If the *flag.Flag.Name was a single character (ex: `v`) it will be accessiblei
+// with both `-v` and `--v` in flags. If the golang flag was more than a single
+// character (ex: `verbose`) it will only be accessible via `--verbose`
func PFlagFromGoFlag(goflag *goflag.Flag) *Flag {
// Remember the default value as a string; it won't change.
flag := &Flag{
@@ -71,6 +74,10 @@ func PFlagFromGoFlag(goflag *goflag.Flag) *Flag {
//DefValue: goflag.DefValue,
DefValue: goflag.Value.String(),
}
+ // Ex: if the golang flag was -v, allow both -v and --v to work
+ if len(flag.Name) == 1 {
+ flag.Shorthand = flag.Name
+ }
if fv, ok := goflag.Value.(goBoolFlag); ok && fv.IsBoolFlag() {
flag.NoOptDefVal = "true"
}
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/int.go b/vendor/github.com/spf13/pflag/int.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/int.go
rename to vendor/github.com/spf13/pflag/int.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/int32.go b/vendor/github.com/spf13/pflag/int32.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/int32.go
rename to vendor/github.com/spf13/pflag/int32.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/int64.go b/vendor/github.com/spf13/pflag/int64.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/int64.go
rename to vendor/github.com/spf13/pflag/int64.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/int8.go b/vendor/github.com/spf13/pflag/int8.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/int8.go
rename to vendor/github.com/spf13/pflag/int8.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/int_slice.go b/vendor/github.com/spf13/pflag/int_slice.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/int_slice.go
rename to vendor/github.com/spf13/pflag/int_slice.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/ip.go b/vendor/github.com/spf13/pflag/ip.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/ip.go
rename to vendor/github.com/spf13/pflag/ip.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/ipmask.go b/vendor/github.com/spf13/pflag/ipmask.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/ipmask.go
rename to vendor/github.com/spf13/pflag/ipmask.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/ipnet.go b/vendor/github.com/spf13/pflag/ipnet.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/ipnet.go
rename to vendor/github.com/spf13/pflag/ipnet.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/string.go b/vendor/github.com/spf13/pflag/string.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/string.go
rename to vendor/github.com/spf13/pflag/string.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/string_slice.go b/vendor/github.com/spf13/pflag/string_slice.go
similarity index 96%
rename from Godeps/_workspace/src/github.com/spf13/pflag/string_slice.go
rename to vendor/github.com/spf13/pflag/string_slice.go
index b53648b2e52370633011371f49453899b89937db..f2a49d97b995341b173c47d36273e44c2bda732b 100644
--- a/Godeps/_workspace/src/github.com/spf13/pflag/string_slice.go
+++ b/vendor/github.com/spf13/pflag/string_slice.go
@@ -21,10 +21,17 @@ func newStringSliceValue(val []string, p *[]string) *stringSliceValue {
return ssv
}
-func (s *stringSliceValue) Set(val string) error {
+func readAsCSV(val string) ([]string, error) {
+ if val == "" {
+ return []string{}, nil
+ }
stringReader := strings.NewReader(val)
csvReader := csv.NewReader(stringReader)
- v, err := csvReader.Read()
+ return csvReader.Read()
+}
+
+func (s *stringSliceValue) Set(val string) error {
+ v, err := readAsCSV(val)
if err != nil {
return err
}
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/uint.go b/vendor/github.com/spf13/pflag/uint.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/uint.go
rename to vendor/github.com/spf13/pflag/uint.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/uint16.go b/vendor/github.com/spf13/pflag/uint16.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/uint16.go
rename to vendor/github.com/spf13/pflag/uint16.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/uint32.go b/vendor/github.com/spf13/pflag/uint32.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/uint32.go
rename to vendor/github.com/spf13/pflag/uint32.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/uint64.go b/vendor/github.com/spf13/pflag/uint64.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/uint64.go
rename to vendor/github.com/spf13/pflag/uint64.go
diff --git a/Godeps/_workspace/src/github.com/spf13/pflag/uint8.go b/vendor/github.com/spf13/pflag/uint8.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/spf13/pflag/uint8.go
rename to vendor/github.com/spf13/pflag/uint8.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/LICENSE b/vendor/github.com/ugorji/go/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/LICENSE
rename to vendor/github.com/ugorji/go/LICENSE
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go b/vendor/github.com/ugorji/go/codec/0doc.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go
rename to vendor/github.com/ugorji/go/codec/0doc.go
index bd7361c8796e374669c6672c715a05182466a671..209f9ebad5bbeb171623310d9a028d480105a09f 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go
+++ b/vendor/github.com/ugorji/go/codec/0doc.go
@@ -68,7 +68,7 @@ Rich Feature Set includes:
- Encode/Decode from/to chan types (for iterative streaming support)
- Drop-in replacement for encoding/json. `json:` key in struct tag supported.
- Provides a RPC Server and Client Codec for net/rpc communication protocol.
- - Handle unique idiosynchracies of codecs e.g.
+ - Handle unique idiosyncrasies of codecs e.g.
- For messagepack, configure how ambiguities in handling raw bytes are resolved
- For messagepack, provide rpc server/client codec to support
msgpack-rpc protocol defined at:
@@ -181,7 +181,7 @@ package codec
// - Decoding using a chan is good, but incurs concurrency costs.
// This is because there's no fast way to use a channel without it
// having to switch goroutines constantly.
-// Callback pattern is still the best. Maybe cnsider supporting something like:
+// Callback pattern is still the best. Maybe consider supporting something like:
// type X struct {
// Name string
// Ys []Y
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/README.md
rename to vendor/github.com/ugorji/go/codec/README.md
index a790a52bb9817e71f0989decd219bd2946b6bc8f..91cb3a27bd5149670311996d6ffc94b721fa6c96 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/README.md
+++ b/vendor/github.com/ugorji/go/codec/README.md
@@ -68,7 +68,7 @@ Rich Feature Set includes:
- Encode/Decode from/to chan types (for iterative streaming support)
- Drop-in replacement for encoding/json. `json:` key in struct tag supported.
- Provides a RPC Server and Client Codec for net/rpc communication protocol.
- - Handle unique idiosynchracies of codecs e.g.
+ - Handle unique idiosyncrasies of codecs e.g.
- For messagepack, configure how ambiguities in handling raw bytes are resolved
- For messagepack, provide rpc server/client codec to support
msgpack-rpc protocol defined at:
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go
rename to vendor/github.com/ugorji/go/codec/binc.go
index 766d26cf6d73ecd39b8ddf2b40d2112b4faf3843..f392eb536f362d8f1d181ffc966045d025074c4c 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go
+++ b/vendor/github.com/ugorji/go/codec/binc.go
@@ -705,7 +705,7 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
}
func (d *bincDecDriver) DecodeString() (s string) {
- // DecodeBytes does not accomodate symbols, whose impl stores string version in map.
+ // DecodeBytes does not accommodate symbols, whose impl stores string version in map.
// Use decStringAndBytes directly.
// return string(d.DecodeBytes(d.b[:], true, true))
_, s = d.decStringAndBytes(d.b[:], true, true)
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go
rename to vendor/github.com/ugorji/go/codec/cbor.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go
rename to vendor/github.com/ugorji/go/codec/decode.go
index b87ea630ee9dff97191a5556eedf4bdd914b1800..c7a9a4d99478fd34ff5020c1968ccdc03684a06e 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go
+++ b/vendor/github.com/ugorji/go/codec/decode.go
@@ -1169,7 +1169,7 @@ type decRtidFn struct {
// primitives are being decoded.
//
// maps and arrays are not handled by this mechanism.
-// However, RawExt is, and we accomodate for extensions that decode
+// However, RawExt is, and we accommodate for extensions that decode
// RawExt from DecodeNaked, but need to decode the value subsequently.
// kInterfaceNaked and swallow, which call DecodeNaked, handle this caveat.
//
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go
rename to vendor/github.com/ugorji/go/codec/encode.go
index a60daa2360b8072607a9465d797f3bf9a5f4ec4e..e3e3bc267d37cd95a2490f7eebbbd2a65bacd90a 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go
+++ b/vendor/github.com/ugorji/go/codec/encode.go
@@ -119,6 +119,12 @@ type EncodeOptions struct {
// This is opt-in, as there may be a performance hit to checking circular references.
CheckCircularRef bool
+ // RecursiveEmptyCheck controls whether we descend into interfaces, structs and pointers
+ // when checking if a value is empty.
+ //
+ // Note that this may make OmitEmpty more expensive, as it incurs a lot more reflect calls.
+ RecursiveEmptyCheck bool
+
// AsSymbols defines what should be encoded as symbols.
//
// Encoding as symbols can reduce the encoded size significantly.
@@ -242,8 +248,8 @@ func (z *bytesEncWriter) writen1(b1 byte) {
func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
c := z.grow(2)
- z.b[c] = b1
z.b[c+1] = b2
+ z.b[c] = b1
}
func (z *bytesEncWriter) atEndOfEncode() {
@@ -308,7 +314,7 @@ func (f *encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v
v = rv.Interface()
} else if indir == -1 {
// If a non-pointer was passed to Encode(), then that value is not addressable.
- // Take addr if addresable, else copy value to an addressable value.
+ // Take addr if addressable, else copy value to an addressable value.
if rv.CanAddr() {
v = rv.Addr().Interface()
} else {
@@ -524,20 +530,20 @@ func (f *encFnInfo) kStruct(rv reflect.Value) {
}
newlen = 0
var kv stringRv
+ recur := e.h.RecursiveEmptyCheck
for _, si := range tisfi {
kv.r = si.field(rv, false)
if toMap {
- if si.omitEmpty && isEmptyValue(kv.r) {
+ if si.omitEmpty && isEmptyValue(kv.r, recur, recur) {
continue
}
kv.v = si.encName
} else {
// use the zero value.
// if a reference or struct, set to nil (so you do not output too much)
- if si.omitEmpty && isEmptyValue(kv.r) {
+ if si.omitEmpty && isEmptyValue(kv.r, recur, recur) {
switch kv.r.Kind() {
- case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array,
- reflect.Map, reflect.Slice:
+ case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice:
kv.r = reflect.Value{} //encode as nil
}
}
@@ -548,7 +554,7 @@ func (f *encFnInfo) kStruct(rv reflect.Value) {
// debugf(">>>> kStruct: newlen: %v", newlen)
// sep := !e.be
- ee := e.e //don't dereference everytime
+ ee := e.e //don't dereference every time
if toMap {
ee.EncodeMapStart(newlen)
@@ -935,7 +941,7 @@ func newEncoder(h Handle) *Encoder {
// Reset the Encoder with a new output stream.
//
-// This accomodates using the state of the Encoder,
+// This accommodates using the state of the Encoder,
// where it has "cached" information about sub-engines.
func (e *Encoder) Reset(w io.Writer) {
ww, ok := w.(ioEncWriterWriter)
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go
rename to vendor/github.com/ugorji/go/codec/fast-path.generated.go
index cf6e00df217403b4879c6b30e9e65454a7d59e57..f2e5d2dcf66eef4dab2a817f340dd871ed5767d4 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
@@ -23,7 +23,7 @@ package codec
// Currently support
// - slice of all builtin types,
// - map of all builtin types to string or interface value
-// - symetrical maps of all builtin types (e.g. str-str, uint8-uint8)
+// - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
// This should provide adequate "typical" implementations.
//
// Note that fast track decode functions must handle values for which an address cannot be obtained.
@@ -38,6 +38,8 @@ import (
"sort"
)
+const fastpathEnabled = true
+
const fastpathCheckNilFalse = false // for reflect
const fastpathCheckNilTrue = true // for type switch
@@ -81,9 +83,6 @@ var fastpathAV fastpathA
// due to possible initialization loop error, make fastpath in an init()
func init() {
- if !fastpathEnabled {
- return
- }
i := 0
fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
xrt := reflect.TypeOf(v)
@@ -373,9 +372,6 @@ func init() {
// -- -- fast path type switch
func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
case []interface{}:
@@ -1741,9 +1737,6 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
}
func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
case []interface{}:
@@ -1829,9 +1822,6 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
}
func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
case map[interface{}]interface{}:
@@ -15954,9 +15944,6 @@ func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
// -- -- fast path type switch
func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
case []interface{}:
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
similarity index 98%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl
rename to vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
index 04c173fbaaae511cde99ac4bcaa3d6e0f32711f5..c3ffdf93d96045fb926dc5f148faa1d78fcc7e48 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
@@ -23,7 +23,7 @@ package codec
// Currently support
// - slice of all builtin types,
// - map of all builtin types to string or interface value
-// - symetrical maps of all builtin types (e.g. str-str, uint8-uint8)
+// - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
// This should provide adequate "typical" implementations.
//
// Note that fast track decode functions must handle values for which an address cannot be obtained.
@@ -38,6 +38,8 @@ import (
"sort"
)
+const fastpathEnabled = true
+
const fastpathCheckNilFalse = false // for reflect
const fastpathCheckNilTrue = true // for type switch
@@ -81,9 +83,6 @@ var fastpathAV fastpathA
// due to possible initialization loop error, make fastpath in an init()
func init() {
- if !fastpathEnabled {
- return
- }
i := 0
fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
xrt := reflect.TypeOf(v)
@@ -106,9 +105,6 @@ func init() {
// -- -- fast path type switch
func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
case []{{ .Elem }}:{{else}}
@@ -126,9 +122,6 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
}
func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
case []{{ .Elem }}:
@@ -144,9 +137,6 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
}
func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
case map[{{ .MapKey }}]{{ .Elem }}:
@@ -286,9 +276,6 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele
// -- -- fast path type switch
func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
- if !fastpathEnabled {
- return false
- }
switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
case []{{ .Elem }}:{{else}}
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go b/vendor/github.com/ugorji/go/codec/fast-path.not.go
similarity index 97%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go
rename to vendor/github.com/ugorji/go/codec/fast-path.not.go
index d6f5f0c911be73ab8893a2299633e8acf3c1e73e..63e59114529b355c53f140b89e8b4a7c76a0cfa5 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.not.go
@@ -4,6 +4,8 @@ package codec
import "reflect"
+const fastpathEnabled = false
+
// The generated fast-path code is very large, and adds a few seconds to the build time.
// This causes test execution, execution of small tools which use codec, etc
// to take a long time.
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
rename to vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
rename to vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go
rename to vendor/github.com/ugorji/go/codec/gen-helper.generated.go
index 22bce776bb2bbbe448fd93247bc183b9fb5907ec..6ee80e4628d8928c4643d600268d65f2b51201ac 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
@@ -17,7 +17,7 @@ import (
// This file is used to generate helper code for codecgen.
// The values here i.e. genHelper(En|De)coder are not to be used directly by
-// library users. They WILL change continously and without notice.
+// library users. They WILL change continuously and without notice.
//
// To help enforce this, we create an unexported type with exported members.
// The only way to get the type is via the one exported type that we control (somewhat).
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl
rename to vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
index 31958574ffcc1b3a966637a47ec3974cac3a3561..1e1b07689c1920ccd705458df50d4c21369b3593 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
@@ -17,7 +17,7 @@ import (
// This file is used to generate helper code for codecgen.
// The values here i.e. genHelper(En|De)coder are not to be used directly by
-// library users. They WILL change continously and without notice.
+// library users. They WILL change continuously and without notice.
//
// To help enforce this, we create an unexported type with exported members.
// The only way to get the type is via the one exported type that we control (somewhat).
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go
rename to vendor/github.com/ugorji/go/codec/gen.generated.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go
rename to vendor/github.com/ugorji/go/codec/gen.go
index ac8cc6ddc9880ef99df97ea99b372ce6367ff329..e3998444a16746e793744180fbfa90a03806c4f5 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go
+++ b/vendor/github.com/ugorji/go/codec/gen.go
@@ -77,7 +77,7 @@ import (
// codecgen will panic if the file was generated with an old version of the library in use.
//
// Note:
-// It was a concious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil.
+// It was a conscious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil.
// This way, there isn't a function call overhead just to see that we should not enter a block of code.
// GenVersion is the current version of codecgen.
@@ -1421,7 +1421,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
if si.i != -1 {
t2 = t.Field(int(si.i))
} else {
- //we must accomodate anonymous fields, where the embedded field is a nil pointer in the value.
+ //we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
// t2 = t.FieldByIndex(si.is)
t2typ := t
varname3 := varname
@@ -1509,7 +1509,7 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
if si.i != -1 {
t2 = t.Field(int(si.i))
} else {
- //we must accomodate anonymous fields, where the embedded field is a nil pointer in the value.
+ //we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
// t2 = t.FieldByIndex(si.is)
t2typ := t
varname3 := varname
@@ -1931,7 +1931,7 @@ func genInternalInit() {
}
var gt genInternal
- // For each slice or map type, there must be a (symetrical) Encode and Decode fast-path function
+ // For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function
for _, s := range types {
gt.Values = append(gt.Values, genV{Primitive: s, Size: mapvaltypes2[s]})
if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen_15.go b/vendor/github.com/ugorji/go/codec/gen_15.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen_15.go
rename to vendor/github.com/ugorji/go/codec/gen_15.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen_16.go b/vendor/github.com/ugorji/go/codec/gen_16.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/gen_16.go
rename to vendor/github.com/ugorji/go/codec/gen_16.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go b/vendor/github.com/ugorji/go/codec/helper.go
similarity index 90%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go
rename to vendor/github.com/ugorji/go/codec/helper.go
index f3d2600d3e56ca6261b982564d651086cbac7e42..a012c8b2df11dbfe18359b0751f0dcd27d27d2f6 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go
+++ b/vendor/github.com/ugorji/go/codec/helper.go
@@ -137,17 +137,6 @@ const (
// Note that this will always cause rpc tests to fail, since they need io.EOF sent via panic.
recoverPanicToErr = true
- // Fast path functions try to create a fast path encode or decode implementation
- // for common maps and slices, by by-passing reflection altogether.
- fastpathEnabled = true
-
- // if checkStructForEmptyValue, check structs fields to see if an empty value.
- // This could be an expensive call, so possibly disable it.
- checkStructForEmptyValue = false
-
- // if derefForIsEmptyValue, deref pointers and interfaces when checking isEmptyValue
- derefForIsEmptyValue = false
-
// if resetSliceElemToZeroValue, then on decoding a slice, reset the element to a zero value first.
// Only concern is that, if the slice already contained some garbage, we will decode into that garbage.
// The chances of this are slim, so leave this "optimization".
@@ -217,16 +206,21 @@ const (
containerArrayEnd
)
-type rgetPoolT struct {
- encNames [8]string
- fNames [8]string
- etypes [8]uintptr
- sfis [8]*structFieldInfo
+// sfiIdx used for tracking where a fieldName is seen in a []*structFieldInfo
+type sfiIdx struct {
+ fieldName string
+ index int
}
-var rgetPool = sync.Pool{
- New: func() interface{} { return new(rgetPoolT) },
-}
+// do not recurse if a containing type refers to an embedded type
+// which refers back to its containing type (via a pointer).
+// The second time this back-reference happens, break out,
+// so as not to cause an infinite loop.
+const rgetMaxRecursion = 2
+
+// Anecdotally, we believe most types have <= 12 fields.
+// Java's PMD rules set TooManyFields threshold to 15.
+const rgetPoolTArrayLen = 12
type rgetT struct {
fNames []string
@@ -235,6 +229,18 @@ type rgetT struct {
sfis []*structFieldInfo
}
+type rgetPoolT struct {
+ fNames [rgetPoolTArrayLen]string
+ encNames [rgetPoolTArrayLen]string
+ etypes [rgetPoolTArrayLen]uintptr
+ sfis [rgetPoolTArrayLen]*structFieldInfo
+ sfiidx [rgetPoolTArrayLen]sfiIdx
+}
+
+var rgetPool = sync.Pool{
+ New: func() interface{} { return new(rgetPoolT) },
+}
+
type containerStateRecv interface {
sendContainerState(containerState)
}
@@ -545,7 +551,7 @@ func (o *extHandle) AddExt(
func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
// o is a pointer, because we may need to initialize it
if rt.PkgPath() == "" || rt.Kind() == reflect.Interface {
- err = fmt.Errorf("codec.Handle.AddExt: Takes named type, especially not a pointer or interface: %T",
+ err = fmt.Errorf("codec.Handle.AddExt: Takes named type, not a pointer or interface: %T",
reflect.Zero(rt).Interface())
return
}
@@ -588,7 +594,8 @@ func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn {
}
type structFieldInfo struct {
- encName string // encode name
+ encName string // encode name
+ fieldName string // field name
// only one of 'i' or 'is' can be set. If 'i' is -1, then 'is' has been set.
@@ -849,21 +856,18 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
}
if rt.Kind() == reflect.Struct {
- var siInfo *structFieldInfo
+ var omitEmpty bool
if f, ok := rt.FieldByName(structInfoFieldName); ok {
- siInfo = parseStructFieldInfo(structInfoFieldName, x.structTag(f.Tag))
+ siInfo := parseStructFieldInfo(structInfoFieldName, x.structTag(f.Tag))
ti.toArray = siInfo.toArray
+ omitEmpty = siInfo.omitEmpty
}
pi := rgetPool.Get()
pv := pi.(*rgetPoolT)
pv.etypes[0] = ti.baseId
vv := rgetT{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
- x.rget(rt, rtid, nil, &vv, siInfo)
- ti.sfip = make([]*structFieldInfo, len(vv.sfis))
- ti.sfi = make([]*structFieldInfo, len(vv.sfis))
- copy(ti.sfip, vv.sfis)
- sort.Sort(sfiSortedByEncName(vv.sfis))
- copy(ti.sfi, vv.sfis)
+ x.rget(rt, rtid, omitEmpty, nil, &vv)
+ ti.sfip, ti.sfi = rgetResolveSFI(vv.sfis, pv.sfiidx[:0])
rgetPool.Put(pi)
}
// sfi = sfip
@@ -877,26 +881,17 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
return
}
-func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr,
- indexstack []int, pv *rgetT, siInfo *structFieldInfo,
+func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
+ indexstack []int, pv *rgetT,
) {
- // This will read up the fields and store how to access the value.
- // It uses the go language's rules for embedding, as below:
- // - if a field has been seen while traversing, skip it
- // - if an encName has been seen while traversing, skip it
- // - if an embedded type has been seen, skip it
+ // Read up fields and store how to access the value.
//
- // Also, per Go's rules, embedded fields must be analyzed AFTER all top-level fields.
+ // It uses go's rules for message selectors,
+ // which say that the field with the shallowest depth is selected.
//
// Note: we consciously use slices, not a map, to simulate a set.
- // Typically, types have < 16 fields, and iteration using equals is faster than maps there
-
- type anonField struct {
- ft reflect.Type
- idx int
- }
-
- var anonFields []anonField
+ // Typically, types have < 16 fields,
+ // and iteration using equals is faster than maps there
LOOP:
for j, jlen := 0, rt.NumField(); j < jlen; j++ {
@@ -908,7 +903,8 @@ LOOP:
continue LOOP
}
- // if r1, _ := utf8.DecodeRuneInString(f.Name); r1 == utf8.RuneError || !unicode.IsUpper(r1) {
+ // if r1, _ := utf8.DecodeRuneInString(f.Name);
+ // r1 == utf8.RuneError || !unicode.IsUpper(r1) {
if f.PkgPath != "" && !f.Anonymous { // unexported, not embedded
continue
}
@@ -917,7 +913,8 @@ LOOP:
continue
}
var si *structFieldInfo
- // if anonymous and no struct tag (or it's blank), and a struct (or pointer to struct), inline it.
+ // if anonymous and no struct tag (or it's blank),
+ // and a struct (or pointer to struct), inline it.
if f.Anonymous && fkind != reflect.Interface {
doInline := stag == ""
if !doInline {
@@ -931,8 +928,31 @@ LOOP:
ft = ft.Elem()
}
if ft.Kind() == reflect.Struct {
- // handle anonymous fields after handling all the non-anon fields
- anonFields = append(anonFields, anonField{ft, j})
+ // if etypes contains this, don't call rget again (as fields are already seen here)
+ ftid := reflect.ValueOf(ft).Pointer()
+ // We cannot recurse forever, but we need to track other field depths.
+ // So - we break if we see a type twice (not the first time).
+ // This should be sufficient to handle an embedded type that refers to its
+ // owning type, which then refers to its embedded type.
+ processIt := true
+ numk := 0
+ for _, k := range pv.etypes {
+ if k == ftid {
+ numk++
+ if numk == rgetMaxRecursion {
+ processIt = false
+ break
+ }
+ }
+ }
+ if processIt {
+ pv.etypes = append(pv.etypes, ftid)
+ indexstack2 := make([]int, len(indexstack)+1)
+ copy(indexstack2, indexstack)
+ indexstack2[len(indexstack)] = j
+ // indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
+ x.rget(ft, ftid, omitEmpty, indexstack2, pv)
+ }
continue
}
}
@@ -947,11 +967,6 @@ LOOP:
panic(noFieldNameToStructFieldInfoErr)
}
- for _, k := range pv.fNames {
- if k == f.Name {
- continue LOOP
- }
- }
pv.fNames = append(pv.fNames, f.Name)
if si == nil {
@@ -959,12 +974,8 @@ LOOP:
} else if si.encName == "" {
si.encName = f.Name
}
+ si.fieldName = f.Name
- for _, k := range pv.encNames {
- if k == si.encName {
- continue LOOP
- }
- }
pv.encNames = append(pv.encNames, si.encName)
// si.ikind = int(f.Type.Kind())
@@ -978,32 +989,51 @@ LOOP:
// si.is = append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
}
- if siInfo != nil {
- if siInfo.omitEmpty {
- si.omitEmpty = true
- }
+ if omitEmpty {
+ si.omitEmpty = true
}
pv.sfis = append(pv.sfis, si)
}
+}
- // now handle anonymous fields
-LOOP2:
- for _, af := range anonFields {
- // if etypes contains this, then do not call rget again (as the fields are already seen here)
- ftid := reflect.ValueOf(af.ft).Pointer()
- for _, k := range pv.etypes {
- if k == ftid {
- continue LOOP2
+// resolves the struct field info get from a call to rget2.
+// Returns a trimmed, unsorted and sorted []*structFieldInfo.
+func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo) {
+ var n int
+ for i, v := range x {
+ xf := v.fieldName
+ var found bool
+ for _, k := range pv {
+ if k.fieldName == xf {
+ if len(v.is) < len(x[k.index].is) {
+ x[k.index] = nil
+ k.index = i
+ n++
+ }
+ found = true
+ break
}
}
- pv.etypes = append(pv.etypes, ftid)
+ if !found {
+ pv = append(pv, sfiIdx{xf, i})
+ }
+ }
- indexstack2 := make([]int, len(indexstack)+1)
- copy(indexstack2, indexstack)
- indexstack2[len(indexstack)] = af.idx
- // indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
- x.rget(af.ft, ftid, indexstack2, pv, siInfo)
+ // remove all the nils
+ y = make([]*structFieldInfo, len(x)-n)
+ n = 0
+ for _, v := range x {
+ if v == nil {
+ continue
+ }
+ y[n] = v
+ n++
}
+
+ z = make([]*structFieldInfo, len(y))
+ copy(z, y)
+ sort.Sort(sfiSortedByEncName(z))
+ return
}
func panicToErr(err *error) {
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper_internal.go b/vendor/github.com/ugorji/go/codec/helper_internal.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/helper_internal.go
rename to vendor/github.com/ugorji/go/codec/helper_internal.go
index dea981fbb7bee13a6e34c090ec762998d092add4..5d0727f77f600c3f5298f21bba6c9bc1b2b92352 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper_internal.go
+++ b/vendor/github.com/ugorji/go/codec/helper_internal.go
@@ -70,8 +70,8 @@ func hIsEmptyValue(v reflect.Value, deref, checkStruct bool) bool {
return false
}
-func isEmptyValue(v reflect.Value) bool {
- return hIsEmptyValue(v, derefForIsEmptyValue, checkStructForEmptyValue)
+func isEmptyValue(v reflect.Value, deref, checkStruct bool) bool {
+ return hIsEmptyValue(v, deref, checkStruct)
}
func pruneSignExt(v []byte, pos bool) (n int) {
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper_not_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/helper_not_unsafe.go
rename to vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/helper_unsafe.go
rename to vendor/github.com/ugorji/go/codec/helper_unsafe.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/json.go b/vendor/github.com/ugorji/go/codec/json.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/json.go
rename to vendor/github.com/ugorji/go/codec/json.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/msgpack.go
rename to vendor/github.com/ugorji/go/codec/msgpack.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go b/vendor/github.com/ugorji/go/codec/noop.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go
rename to vendor/github.com/ugorji/go/codec/noop.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.go b/vendor/github.com/ugorji/go/codec/prebuild.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.go
rename to vendor/github.com/ugorji/go/codec/prebuild.go
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh b/vendor/github.com/ugorji/go/codec/prebuild.sh
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh
rename to vendor/github.com/ugorji/go/codec/prebuild.sh
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/rpc.go b/vendor/github.com/ugorji/go/codec/rpc.go
similarity index 98%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/rpc.go
rename to vendor/github.com/ugorji/go/codec/rpc.go
index dad53d0c61e60e3782ae49ed5404fd252ab19ad7..8062bed3130b7d12e89632b6791e44597d2bde2e 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/rpc.go
+++ b/vendor/github.com/ugorji/go/codec/rpc.go
@@ -25,7 +25,7 @@ type Rpc interface {
}
// RpcCodecBuffered allows access to the underlying bufio.Reader/Writer
-// used by the rpc connection. It accomodates use-cases where the connection
+// used by the rpc connection. It accommodates use-cases where the connection
// should be used by rpc and non-rpc functions, e.g. streaming a file after
// sending an rpc response.
type RpcCodecBuffered interface {
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/simple.go b/vendor/github.com/ugorji/go/codec/simple.go
similarity index 99%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/simple.go
rename to vendor/github.com/ugorji/go/codec/simple.go
index 7c0ba7affc77581aa6decd78f39098bcc3b21e20..9619b2bff9f7b25dec4eb1ad4fd1c5e784825ea9 100644
--- a/Godeps/_workspace/src/github.com/ugorji/go/codec/simple.go
+++ b/vendor/github.com/ugorji/go/codec/simple.go
@@ -474,7 +474,7 @@ func (d *simpleDecDriver) DecodeNaked() {
// SimpleHandle is a Handle for a very simple encoding format.
//
// simple is a simplistic codec similar to binc, but not as compact.
-// - Encoding of a value is always preceeded by the descriptor byte (bd)
+// - Encoding of a value is always preceded by the descriptor byte (bd)
// - True, false, nil are encoded fully in 1 byte (the descriptor)
// - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
// There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/test-cbor-goldens.json b/vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/test-cbor-goldens.json
rename to vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/test.py b/vendor/github.com/ugorji/go/codec/test.py
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/test.py
rename to vendor/github.com/ugorji/go/codec/test.py
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/tests.sh b/vendor/github.com/ugorji/go/codec/tests.sh
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/tests.sh
rename to vendor/github.com/ugorji/go/codec/tests.sh
diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/time.go b/vendor/github.com/ugorji/go/codec/time.go
similarity index 100%
rename from Godeps/_workspace/src/github.com/ugorji/go/codec/time.go
rename to vendor/github.com/ugorji/go/codec/time.go
diff --git a/Godeps/_workspace/src/golang.org/x/net/LICENSE b/vendor/golang.org/x/net/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/golang.org/x/net/LICENSE
rename to vendor/golang.org/x/net/LICENSE
diff --git a/Godeps/_workspace/src/golang.org/x/net/PATENTS b/vendor/golang.org/x/net/PATENTS
similarity index 100%
rename from Godeps/_workspace/src/golang.org/x/net/PATENTS
rename to vendor/golang.org/x/net/PATENTS
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.go
similarity index 98%
rename from Godeps/_workspace/src/golang.org/x/net/context/context.go
rename to vendor/golang.org/x/net/context/context.go
index 56efb95b913c009bbc991a4e3b7f624550fabb32..ea1a7cd53a12ea89f899ecd48138b22c6c79f493 100644
--- a/Godeps/_workspace/src/golang.org/x/net/context/context.go
+++ b/vendor/golang.org/x/net/context/context.go
@@ -61,7 +61,7 @@ type Context interface {
//
// // Stream generates values with DoSomething and sends them to out
// // until DoSomething returns an error or ctx.Done is closed.
- // func Stream(ctx context.Context, out <-chan Value) error {
+ // func Stream(ctx context.Context, out chan<- Value) error {
// for {
// v, err := DoSomething(ctx)
// if err != nil {
diff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go
new file mode 100644
index 0000000000000000000000000000000000000000..22eabffe5f7302c25018e2f5a167f7f845bd87bc
--- /dev/null
+++ b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go
@@ -0,0 +1,74 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+// Package ctxhttp provides helper functions for performing context-aware HTTP requests.
+package ctxhttp
+
+import (
+ "io"
+ "net/http"
+ "net/url"
+ "strings"
+
+ "golang.org/x/net/context"
+)
+
+// Do sends an HTTP request with the provided http.Client and returns
+// an HTTP response.
+//
+// If the client is nil, http.DefaultClient is used.
+//
+// The provided ctx must be non-nil. If it is canceled or times out,
+// ctx.Err() will be returned.
+func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
+ if client == nil {
+ client = http.DefaultClient
+ }
+ resp, err := client.Do(req.WithContext(ctx))
+ // If we got an error, and the context has been canceled,
+ // the context's error is probably more useful.
+ if err != nil {
+ select {
+ case <-ctx.Done():
+ err = ctx.Err()
+ default:
+ }
+ }
+ return resp, err
+}
+
+// Get issues a GET request via the Do function.
+func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Head issues a HEAD request via the Do function.
+func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("HEAD", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Post issues a POST request via the Do function.
+func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
+ req, err := http.NewRequest("POST", url, body)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", bodyType)
+ return Do(ctx, client, req)
+}
+
+// PostForm issues a POST request via the Do function.
+func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {
+ return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
+}
diff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go
new file mode 100644
index 0000000000000000000000000000000000000000..7564b203276adefc1cd1d9dde5d39b82608935c5
--- /dev/null
+++ b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go
@@ -0,0 +1,147 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.7
+
+package ctxhttp
+
+import (
+ "io"
+ "net/http"
+ "net/url"
+ "strings"
+
+ "golang.org/x/net/context"
+)
+
+func nop() {}
+
+var (
+ testHookContextDoneBeforeHeaders = nop
+ testHookDoReturned = nop
+ testHookDidBodyClose = nop
+)
+
+// Do sends an HTTP request with the provided http.Client and returns an HTTP response.
+// If the client is nil, http.DefaultClient is used.
+// If the context is canceled or times out, ctx.Err() will be returned.
+func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
+ if client == nil {
+ client = http.DefaultClient
+ }
+
+ // TODO(djd): Respect any existing value of req.Cancel.
+ cancel := make(chan struct{})
+ req.Cancel = cancel
+
+ type responseAndError struct {
+ resp *http.Response
+ err error
+ }
+ result := make(chan responseAndError, 1)
+
+ // Make local copies of test hooks closed over by goroutines below.
+ // Prevents data races in tests.
+ testHookDoReturned := testHookDoReturned
+ testHookDidBodyClose := testHookDidBodyClose
+
+ go func() {
+ resp, err := client.Do(req)
+ testHookDoReturned()
+ result <- responseAndError{resp, err}
+ }()
+
+ var resp *http.Response
+
+ select {
+ case <-ctx.Done():
+ testHookContextDoneBeforeHeaders()
+ close(cancel)
+ // Clean up after the goroutine calling client.Do:
+ go func() {
+ if r := <-result; r.resp != nil {
+ testHookDidBodyClose()
+ r.resp.Body.Close()
+ }
+ }()
+ return nil, ctx.Err()
+ case r := <-result:
+ var err error
+ resp, err = r.resp, r.err
+ if err != nil {
+ return resp, err
+ }
+ }
+
+ c := make(chan struct{})
+ go func() {
+ select {
+ case <-ctx.Done():
+ close(cancel)
+ case <-c:
+ // The response's Body is closed.
+ }
+ }()
+ resp.Body = ¬ifyingReader{resp.Body, c}
+
+ return resp, nil
+}
+
+// Get issues a GET request via the Do function.
+func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Head issues a HEAD request via the Do function.
+func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("HEAD", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Post issues a POST request via the Do function.
+func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
+ req, err := http.NewRequest("POST", url, body)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", bodyType)
+ return Do(ctx, client, req)
+}
+
+// PostForm issues a POST request via the Do function.
+func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {
+ return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
+}
+
+// notifyingReader is an io.ReadCloser that closes the notify channel after
+// Close is called or a Read fails on the underlying ReadCloser.
+type notifyingReader struct {
+ io.ReadCloser
+ notify chan<- struct{}
+}
+
+func (r *notifyingReader) Read(p []byte) (int, error) {
+ n, err := r.ReadCloser.Read(p)
+ if err != nil && r.notify != nil {
+ close(r.notify)
+ r.notify = nil
+ }
+ return n, err
+}
+
+func (r *notifyingReader) Close() error {
+ err := r.ReadCloser.Close()
+ if r.notify != nil {
+ close(r.notify)
+ r.notify = nil
+ }
+ return err
+}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/go17.go b/vendor/golang.org/x/net/context/go17.go
similarity index 100%
rename from Godeps/_workspace/src/golang.org/x/net/context/go17.go
rename to vendor/golang.org/x/net/context/go17.go
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/pre_go17.go b/vendor/golang.org/x/net/context/pre_go17.go
similarity index 100%
rename from Godeps/_workspace/src/golang.org/x/net/context/pre_go17.go
rename to vendor/golang.org/x/net/context/pre_go17.go
diff --git a/vendor/golang.org/x/net/http2/.gitignore b/vendor/golang.org/x/net/http2/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..190f12234adf847a915f13ff69d9048d7d3b4d73
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/.gitignore
@@ -0,0 +1,2 @@
+*~
+h2i/h2i
diff --git a/vendor/golang.org/x/net/http2/Dockerfile b/vendor/golang.org/x/net/http2/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..53fc52579744539dc9d223be13fe7be565396bf2
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/Dockerfile
@@ -0,0 +1,51 @@
+#
+# This Dockerfile builds a recent curl with HTTP/2 client support, using
+# a recent nghttp2 build.
+#
+# See the Makefile for how to tag it. If Docker and that image is found, the
+# Go tests use this curl binary for integration tests.
+#
+
+FROM ubuntu:trusty
+
+RUN apt-get update && \
+ apt-get upgrade -y && \
+ apt-get install -y git-core build-essential wget
+
+RUN apt-get install -y --no-install-recommends \
+ autotools-dev libtool pkg-config zlib1g-dev \
+ libcunit1-dev libssl-dev libxml2-dev libevent-dev \
+ automake autoconf
+
+# The list of packages nghttp2 recommends for h2load:
+RUN apt-get install -y --no-install-recommends make binutils \
+ autoconf automake autotools-dev \
+ libtool pkg-config zlib1g-dev libcunit1-dev libssl-dev libxml2-dev \
+ libev-dev libevent-dev libjansson-dev libjemalloc-dev \
+ cython python3.4-dev python-setuptools
+
+# Note: setting NGHTTP2_VER before the git clone, so an old git clone isn't cached:
+ENV NGHTTP2_VER 895da9a
+RUN cd /root && git clone https://github.com/tatsuhiro-t/nghttp2.git
+
+WORKDIR /root/nghttp2
+RUN git reset --hard $NGHTTP2_VER
+RUN autoreconf -i
+RUN automake
+RUN autoconf
+RUN ./configure
+RUN make
+RUN make install
+
+WORKDIR /root
+RUN wget http://curl.haxx.se/download/curl-7.45.0.tar.gz
+RUN tar -zxvf curl-7.45.0.tar.gz
+WORKDIR /root/curl-7.45.0
+RUN ./configure --with-ssl --with-nghttp2=/usr/local
+RUN make
+RUN make install
+RUN ldconfig
+
+CMD ["-h"]
+ENTRYPOINT ["/usr/local/bin/curl"]
+
diff --git a/vendor/golang.org/x/net/http2/Makefile b/vendor/golang.org/x/net/http2/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..55fd826f77bd99fac0e546e42b921ac5ca1e9d12
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/Makefile
@@ -0,0 +1,3 @@
+curlimage:
+ docker build -t gohttp2/curl .
+
diff --git a/vendor/golang.org/x/net/http2/README b/vendor/golang.org/x/net/http2/README
new file mode 100644
index 0000000000000000000000000000000000000000..360d5aa37905731ba08c31978556e8d571ee5478
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/README
@@ -0,0 +1,20 @@
+This is a work-in-progress HTTP/2 implementation for Go.
+
+It will eventually live in the Go standard library and won't require
+any changes to your code to use. It will just be automatic.
+
+Status:
+
+* The server support is pretty good. A few things are missing
+ but are being worked on.
+* The client work has just started but shares a lot of code
+ is coming along much quicker.
+
+Docs are at https://godoc.org/golang.org/x/net/http2
+
+Demo test server at https://http2.golang.org/
+
+Help & bug reports welcome!
+
+Contributing: https://golang.org/doc/contribute.html
+Bugs: https://golang.org/issue/new?title=x/net/http2:+
diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..b13941258a35cd6e44262d7b2b16bc556ffc39d3
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/client_conn_pool.go
@@ -0,0 +1,256 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Transport code's client connection pooling.
+
+package http2
+
+import (
+ "crypto/tls"
+ "net/http"
+ "sync"
+)
+
+// ClientConnPool manages a pool of HTTP/2 client connections.
+type ClientConnPool interface {
+ GetClientConn(req *http.Request, addr string) (*ClientConn, error)
+ MarkDead(*ClientConn)
+}
+
+// clientConnPoolIdleCloser is the interface implemented by ClientConnPool
+// implementations which can close their idle connections.
+type clientConnPoolIdleCloser interface {
+ ClientConnPool
+ closeIdleConnections()
+}
+
+var (
+ _ clientConnPoolIdleCloser = (*clientConnPool)(nil)
+ _ clientConnPoolIdleCloser = noDialClientConnPool{}
+)
+
+// TODO: use singleflight for dialing and addConnCalls?
+type clientConnPool struct {
+ t *Transport
+
+ mu sync.Mutex // TODO: maybe switch to RWMutex
+ // TODO: add support for sharing conns based on cert names
+ // (e.g. share conn for googleapis.com and appspot.com)
+ conns map[string][]*ClientConn // key is host:port
+ dialing map[string]*dialCall // currently in-flight dials
+ keys map[*ClientConn][]string
+ addConnCalls map[string]*addConnCall // in-flight addConnIfNeede calls
+}
+
+func (p *clientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
+ return p.getClientConn(req, addr, dialOnMiss)
+}
+
+const (
+ dialOnMiss = true
+ noDialOnMiss = false
+)
+
+func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) {
+ if isConnectionCloseRequest(req) && dialOnMiss {
+ // It gets its own connection.
+ const singleUse = true
+ cc, err := p.t.dialClientConn(addr, singleUse)
+ if err != nil {
+ return nil, err
+ }
+ return cc, nil
+ }
+ p.mu.Lock()
+ for _, cc := range p.conns[addr] {
+ if cc.CanTakeNewRequest() {
+ p.mu.Unlock()
+ return cc, nil
+ }
+ }
+ if !dialOnMiss {
+ p.mu.Unlock()
+ return nil, ErrNoCachedConn
+ }
+ call := p.getStartDialLocked(addr)
+ p.mu.Unlock()
+ <-call.done
+ return call.res, call.err
+}
+
+// dialCall is an in-flight Transport dial call to a host.
+type dialCall struct {
+ p *clientConnPool
+ done chan struct{} // closed when done
+ res *ClientConn // valid after done is closed
+ err error // valid after done is closed
+}
+
+// requires p.mu is held.
+func (p *clientConnPool) getStartDialLocked(addr string) *dialCall {
+ if call, ok := p.dialing[addr]; ok {
+ // A dial is already in-flight. Don't start another.
+ return call
+ }
+ call := &dialCall{p: p, done: make(chan struct{})}
+ if p.dialing == nil {
+ p.dialing = make(map[string]*dialCall)
+ }
+ p.dialing[addr] = call
+ go call.dial(addr)
+ return call
+}
+
+// run in its own goroutine.
+func (c *dialCall) dial(addr string) {
+ const singleUse = false // shared conn
+ c.res, c.err = c.p.t.dialClientConn(addr, singleUse)
+ close(c.done)
+
+ c.p.mu.Lock()
+ delete(c.p.dialing, addr)
+ if c.err == nil {
+ c.p.addConnLocked(addr, c.res)
+ }
+ c.p.mu.Unlock()
+}
+
+// addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't
+// already exist. It coalesces concurrent calls with the same key.
+// This is used by the http1 Transport code when it creates a new connection. Because
+// the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know
+// the protocol), it can get into a situation where it has multiple TLS connections.
+// This code decides which ones live or die.
+// The return value used is whether c was used.
+// c is never closed.
+func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) {
+ p.mu.Lock()
+ for _, cc := range p.conns[key] {
+ if cc.CanTakeNewRequest() {
+ p.mu.Unlock()
+ return false, nil
+ }
+ }
+ call, dup := p.addConnCalls[key]
+ if !dup {
+ if p.addConnCalls == nil {
+ p.addConnCalls = make(map[string]*addConnCall)
+ }
+ call = &addConnCall{
+ p: p,
+ done: make(chan struct{}),
+ }
+ p.addConnCalls[key] = call
+ go call.run(t, key, c)
+ }
+ p.mu.Unlock()
+
+ <-call.done
+ if call.err != nil {
+ return false, call.err
+ }
+ return !dup, nil
+}
+
+type addConnCall struct {
+ p *clientConnPool
+ done chan struct{} // closed when done
+ err error
+}
+
+func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) {
+ cc, err := t.NewClientConn(tc)
+
+ p := c.p
+ p.mu.Lock()
+ if err != nil {
+ c.err = err
+ } else {
+ p.addConnLocked(key, cc)
+ }
+ delete(p.addConnCalls, key)
+ p.mu.Unlock()
+ close(c.done)
+}
+
+func (p *clientConnPool) addConn(key string, cc *ClientConn) {
+ p.mu.Lock()
+ p.addConnLocked(key, cc)
+ p.mu.Unlock()
+}
+
+// p.mu must be held
+func (p *clientConnPool) addConnLocked(key string, cc *ClientConn) {
+ for _, v := range p.conns[key] {
+ if v == cc {
+ return
+ }
+ }
+ if p.conns == nil {
+ p.conns = make(map[string][]*ClientConn)
+ }
+ if p.keys == nil {
+ p.keys = make(map[*ClientConn][]string)
+ }
+ p.conns[key] = append(p.conns[key], cc)
+ p.keys[cc] = append(p.keys[cc], key)
+}
+
+func (p *clientConnPool) MarkDead(cc *ClientConn) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ for _, key := range p.keys[cc] {
+ vv, ok := p.conns[key]
+ if !ok {
+ continue
+ }
+ newList := filterOutClientConn(vv, cc)
+ if len(newList) > 0 {
+ p.conns[key] = newList
+ } else {
+ delete(p.conns, key)
+ }
+ }
+ delete(p.keys, cc)
+}
+
+func (p *clientConnPool) closeIdleConnections() {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ // TODO: don't close a cc if it was just added to the pool
+ // milliseconds ago and has never been used. There's currently
+ // a small race window with the HTTP/1 Transport's integration
+ // where it can add an idle conn just before using it, and
+ // somebody else can concurrently call CloseIdleConns and
+ // break some caller's RoundTrip.
+ for _, vv := range p.conns {
+ for _, cc := range vv {
+ cc.closeIfIdle()
+ }
+ }
+}
+
+func filterOutClientConn(in []*ClientConn, exclude *ClientConn) []*ClientConn {
+ out := in[:0]
+ for _, v := range in {
+ if v != exclude {
+ out = append(out, v)
+ }
+ }
+ // If we filtered it out, zero out the last item to prevent
+ // the GC from seeing it.
+ if len(in) != len(out) {
+ in[len(in)-1] = nil
+ }
+ return out
+}
+
+// noDialClientConnPool is an implementation of http2.ClientConnPool
+// which never dials. We let the HTTP/1.1 client dial and use its TLS
+// connection instead.
+type noDialClientConnPool struct{ *clientConnPool }
+
+func (p noDialClientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
+ return p.getClientConn(req, addr, noDialOnMiss)
+}
diff --git a/vendor/golang.org/x/net/http2/configure_transport.go b/vendor/golang.org/x/net/http2/configure_transport.go
new file mode 100644
index 0000000000000000000000000000000000000000..4f720f530b00951668b0dc95f6192b1e3613961b
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/configure_transport.go
@@ -0,0 +1,80 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.6
+
+package http2
+
+import (
+ "crypto/tls"
+ "fmt"
+ "net/http"
+)
+
+func configureTransport(t1 *http.Transport) (*Transport, error) {
+ connPool := new(clientConnPool)
+ t2 := &Transport{
+ ConnPool: noDialClientConnPool{connPool},
+ t1: t1,
+ }
+ connPool.t = t2
+ if err := registerHTTPSProtocol(t1, noDialH2RoundTripper{t2}); err != nil {
+ return nil, err
+ }
+ if t1.TLSClientConfig == nil {
+ t1.TLSClientConfig = new(tls.Config)
+ }
+ if !strSliceContains(t1.TLSClientConfig.NextProtos, "h2") {
+ t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...)
+ }
+ if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") {
+ t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
+ }
+ upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper {
+ addr := authorityAddr("https", authority)
+ if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
+ go c.Close()
+ return erringRoundTripper{err}
+ } else if !used {
+ // Turns out we don't need this c.
+ // For example, two goroutines made requests to the same host
+ // at the same time, both kicking off TCP dials. (since protocol
+ // was unknown)
+ go c.Close()
+ }
+ return t2
+ }
+ if m := t1.TLSNextProto; len(m) == 0 {
+ t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{
+ "h2": upgradeFn,
+ }
+ } else {
+ m["h2"] = upgradeFn
+ }
+ return t2, nil
+}
+
+// registerHTTPSProtocol calls Transport.RegisterProtocol but
+// convering panics into errors.
+func registerHTTPSProtocol(t *http.Transport, rt http.RoundTripper) (err error) {
+ defer func() {
+ if e := recover(); e != nil {
+ err = fmt.Errorf("%v", e)
+ }
+ }()
+ t.RegisterProtocol("https", rt)
+ return nil
+}
+
+// noDialH2RoundTripper is a RoundTripper which only tries to complete the request
+// if there's already has a cached connection to the host.
+type noDialH2RoundTripper struct{ t *Transport }
+
+func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+ res, err := rt.t.RoundTrip(req)
+ if err == ErrNoCachedConn {
+ return nil, http.ErrSkipAltProtocol
+ }
+ return res, err
+}
diff --git a/vendor/golang.org/x/net/http2/errors.go b/vendor/golang.org/x/net/http2/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..20fd7626a56db0a80c66f3424380b9c9735af06e
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/errors.go
@@ -0,0 +1,130 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "errors"
+ "fmt"
+)
+
+// An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec.
+type ErrCode uint32
+
+const (
+ ErrCodeNo ErrCode = 0x0
+ ErrCodeProtocol ErrCode = 0x1
+ ErrCodeInternal ErrCode = 0x2
+ ErrCodeFlowControl ErrCode = 0x3
+ ErrCodeSettingsTimeout ErrCode = 0x4
+ ErrCodeStreamClosed ErrCode = 0x5
+ ErrCodeFrameSize ErrCode = 0x6
+ ErrCodeRefusedStream ErrCode = 0x7
+ ErrCodeCancel ErrCode = 0x8
+ ErrCodeCompression ErrCode = 0x9
+ ErrCodeConnect ErrCode = 0xa
+ ErrCodeEnhanceYourCalm ErrCode = 0xb
+ ErrCodeInadequateSecurity ErrCode = 0xc
+ ErrCodeHTTP11Required ErrCode = 0xd
+)
+
+var errCodeName = map[ErrCode]string{
+ ErrCodeNo: "NO_ERROR",
+ ErrCodeProtocol: "PROTOCOL_ERROR",
+ ErrCodeInternal: "INTERNAL_ERROR",
+ ErrCodeFlowControl: "FLOW_CONTROL_ERROR",
+ ErrCodeSettingsTimeout: "SETTINGS_TIMEOUT",
+ ErrCodeStreamClosed: "STREAM_CLOSED",
+ ErrCodeFrameSize: "FRAME_SIZE_ERROR",
+ ErrCodeRefusedStream: "REFUSED_STREAM",
+ ErrCodeCancel: "CANCEL",
+ ErrCodeCompression: "COMPRESSION_ERROR",
+ ErrCodeConnect: "CONNECT_ERROR",
+ ErrCodeEnhanceYourCalm: "ENHANCE_YOUR_CALM",
+ ErrCodeInadequateSecurity: "INADEQUATE_SECURITY",
+ ErrCodeHTTP11Required: "HTTP_1_1_REQUIRED",
+}
+
+func (e ErrCode) String() string {
+ if s, ok := errCodeName[e]; ok {
+ return s
+ }
+ return fmt.Sprintf("unknown error code 0x%x", uint32(e))
+}
+
+// ConnectionError is an error that results in the termination of the
+// entire connection.
+type ConnectionError ErrCode
+
+func (e ConnectionError) Error() string { return fmt.Sprintf("connection error: %s", ErrCode(e)) }
+
+// StreamError is an error that only affects one stream within an
+// HTTP/2 connection.
+type StreamError struct {
+ StreamID uint32
+ Code ErrCode
+ Cause error // optional additional detail
+}
+
+func streamError(id uint32, code ErrCode) StreamError {
+ return StreamError{StreamID: id, Code: code}
+}
+
+func (e StreamError) Error() string {
+ if e.Cause != nil {
+ return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
+ }
+ return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
+}
+
+// 6.9.1 The Flow Control Window
+// "If a sender receives a WINDOW_UPDATE that causes a flow control
+// window to exceed this maximum it MUST terminate either the stream
+// or the connection, as appropriate. For streams, [...]; for the
+// connection, a GOAWAY frame with a FLOW_CONTROL_ERROR code."
+type goAwayFlowError struct{}
+
+func (goAwayFlowError) Error() string { return "connection exceeded flow control window size" }
+
+// connErrorReason wraps a ConnectionError with an informative error about why it occurs.
+
+// Errors of this type are only returned by the frame parser functions
+// and converted into ConnectionError(ErrCodeProtocol).
+type connError struct {
+ Code ErrCode
+ Reason string
+}
+
+func (e connError) Error() string {
+ return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
+}
+
+type pseudoHeaderError string
+
+func (e pseudoHeaderError) Error() string {
+ return fmt.Sprintf("invalid pseudo-header %q", string(e))
+}
+
+type duplicatePseudoHeaderError string
+
+func (e duplicatePseudoHeaderError) Error() string {
+ return fmt.Sprintf("duplicate pseudo-header %q", string(e))
+}
+
+type headerFieldNameError string
+
+func (e headerFieldNameError) Error() string {
+ return fmt.Sprintf("invalid header field name %q", string(e))
+}
+
+type headerFieldValueError string
+
+func (e headerFieldValueError) Error() string {
+ return fmt.Sprintf("invalid header field value %q", string(e))
+}
+
+var (
+ errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
+ errPseudoAfterRegular = errors.New("pseudo header field after regular")
+)
diff --git a/vendor/golang.org/x/net/http2/fixed_buffer.go b/vendor/golang.org/x/net/http2/fixed_buffer.go
new file mode 100644
index 0000000000000000000000000000000000000000..47da0f0bf71f0dbb36d90e7adc9249004ed199e4
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/fixed_buffer.go
@@ -0,0 +1,60 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "errors"
+)
+
+// fixedBuffer is an io.ReadWriter backed by a fixed size buffer.
+// It never allocates, but moves old data as new data is written.
+type fixedBuffer struct {
+ buf []byte
+ r, w int
+}
+
+var (
+ errReadEmpty = errors.New("read from empty fixedBuffer")
+ errWriteFull = errors.New("write on full fixedBuffer")
+)
+
+// Read copies bytes from the buffer into p.
+// It is an error to read when no data is available.
+func (b *fixedBuffer) Read(p []byte) (n int, err error) {
+ if b.r == b.w {
+ return 0, errReadEmpty
+ }
+ n = copy(p, b.buf[b.r:b.w])
+ b.r += n
+ if b.r == b.w {
+ b.r = 0
+ b.w = 0
+ }
+ return n, nil
+}
+
+// Len returns the number of bytes of the unread portion of the buffer.
+func (b *fixedBuffer) Len() int {
+ return b.w - b.r
+}
+
+// Write copies bytes from p into the buffer.
+// It is an error to write more data than the buffer can hold.
+func (b *fixedBuffer) Write(p []byte) (n int, err error) {
+ // Slide existing data to beginning.
+ if b.r > 0 && len(p) > len(b.buf)-b.w {
+ copy(b.buf, b.buf[b.r:b.w])
+ b.w -= b.r
+ b.r = 0
+ }
+
+ // Write new data.
+ n = copy(b.buf[b.w:], p)
+ b.w += n
+ if n < len(p) {
+ err = errWriteFull
+ }
+ return n, err
+}
diff --git a/vendor/golang.org/x/net/http2/flow.go b/vendor/golang.org/x/net/http2/flow.go
new file mode 100644
index 0000000000000000000000000000000000000000..957de25420d91798efe32d86e82b3c4a1f2bc6f6
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/flow.go
@@ -0,0 +1,50 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Flow control
+
+package http2
+
+// flow is the flow control window's size.
+type flow struct {
+ // n is the number of DATA bytes we're allowed to send.
+ // A flow is kept both on a conn and a per-stream.
+ n int32
+
+ // conn points to the shared connection-level flow that is
+ // shared by all streams on that conn. It is nil for the flow
+ // that's on the conn directly.
+ conn *flow
+}
+
+func (f *flow) setConnFlow(cf *flow) { f.conn = cf }
+
+func (f *flow) available() int32 {
+ n := f.n
+ if f.conn != nil && f.conn.n < n {
+ n = f.conn.n
+ }
+ return n
+}
+
+func (f *flow) take(n int32) {
+ if n > f.available() {
+ panic("internal error: took too much")
+ }
+ f.n -= n
+ if f.conn != nil {
+ f.conn.n -= n
+ }
+}
+
+// add adds n bytes (positive or negative) to the flow control window.
+// It returns false if the sum would exceed 2^31-1.
+func (f *flow) add(n int32) bool {
+ remain := (1<<31 - 1) - f.n
+ if n > remain {
+ return false
+ }
+ f.n += n
+ return true
+}
diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go
new file mode 100644
index 0000000000000000000000000000000000000000..c9b09bb6753f6fc8b08db4b73f80d9eec3be518b
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/frame.go
@@ -0,0 +1,1539 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "io"
+ "log"
+ "strings"
+ "sync"
+
+ "golang.org/x/net/http2/hpack"
+ "golang.org/x/net/lex/httplex"
+)
+
+const frameHeaderLen = 9
+
+var padZeros = make([]byte, 255) // zeros for padding
+
+// A FrameType is a registered frame type as defined in
+// http://http2.github.io/http2-spec/#rfc.section.11.2
+type FrameType uint8
+
+const (
+ FrameData FrameType = 0x0
+ FrameHeaders FrameType = 0x1
+ FramePriority FrameType = 0x2
+ FrameRSTStream FrameType = 0x3
+ FrameSettings FrameType = 0x4
+ FramePushPromise FrameType = 0x5
+ FramePing FrameType = 0x6
+ FrameGoAway FrameType = 0x7
+ FrameWindowUpdate FrameType = 0x8
+ FrameContinuation FrameType = 0x9
+)
+
+var frameName = map[FrameType]string{
+ FrameData: "DATA",
+ FrameHeaders: "HEADERS",
+ FramePriority: "PRIORITY",
+ FrameRSTStream: "RST_STREAM",
+ FrameSettings: "SETTINGS",
+ FramePushPromise: "PUSH_PROMISE",
+ FramePing: "PING",
+ FrameGoAway: "GOAWAY",
+ FrameWindowUpdate: "WINDOW_UPDATE",
+ FrameContinuation: "CONTINUATION",
+}
+
+func (t FrameType) String() string {
+ if s, ok := frameName[t]; ok {
+ return s
+ }
+ return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
+}
+
+// Flags is a bitmask of HTTP/2 flags.
+// The meaning of flags varies depending on the frame type.
+type Flags uint8
+
+// Has reports whether f contains all (0 or more) flags in v.
+func (f Flags) Has(v Flags) bool {
+ return (f & v) == v
+}
+
+// Frame-specific FrameHeader flag bits.
+const (
+ // Data Frame
+ FlagDataEndStream Flags = 0x1
+ FlagDataPadded Flags = 0x8
+
+ // Headers Frame
+ FlagHeadersEndStream Flags = 0x1
+ FlagHeadersEndHeaders Flags = 0x4
+ FlagHeadersPadded Flags = 0x8
+ FlagHeadersPriority Flags = 0x20
+
+ // Settings Frame
+ FlagSettingsAck Flags = 0x1
+
+ // Ping Frame
+ FlagPingAck Flags = 0x1
+
+ // Continuation Frame
+ FlagContinuationEndHeaders Flags = 0x4
+
+ FlagPushPromiseEndHeaders Flags = 0x4
+ FlagPushPromisePadded Flags = 0x8
+)
+
+var flagName = map[FrameType]map[Flags]string{
+ FrameData: {
+ FlagDataEndStream: "END_STREAM",
+ FlagDataPadded: "PADDED",
+ },
+ FrameHeaders: {
+ FlagHeadersEndStream: "END_STREAM",
+ FlagHeadersEndHeaders: "END_HEADERS",
+ FlagHeadersPadded: "PADDED",
+ FlagHeadersPriority: "PRIORITY",
+ },
+ FrameSettings: {
+ FlagSettingsAck: "ACK",
+ },
+ FramePing: {
+ FlagPingAck: "ACK",
+ },
+ FrameContinuation: {
+ FlagContinuationEndHeaders: "END_HEADERS",
+ },
+ FramePushPromise: {
+ FlagPushPromiseEndHeaders: "END_HEADERS",
+ FlagPushPromisePadded: "PADDED",
+ },
+}
+
+// a frameParser parses a frame given its FrameHeader and payload
+// bytes. The length of payload will always equal fh.Length (which
+// might be 0).
+type frameParser func(fh FrameHeader, payload []byte) (Frame, error)
+
+var frameParsers = map[FrameType]frameParser{
+ FrameData: parseDataFrame,
+ FrameHeaders: parseHeadersFrame,
+ FramePriority: parsePriorityFrame,
+ FrameRSTStream: parseRSTStreamFrame,
+ FrameSettings: parseSettingsFrame,
+ FramePushPromise: parsePushPromise,
+ FramePing: parsePingFrame,
+ FrameGoAway: parseGoAwayFrame,
+ FrameWindowUpdate: parseWindowUpdateFrame,
+ FrameContinuation: parseContinuationFrame,
+}
+
+func typeFrameParser(t FrameType) frameParser {
+ if f := frameParsers[t]; f != nil {
+ return f
+ }
+ return parseUnknownFrame
+}
+
+// A FrameHeader is the 9 byte header of all HTTP/2 frames.
+//
+// See http://http2.github.io/http2-spec/#FrameHeader
+type FrameHeader struct {
+ valid bool // caller can access []byte fields in the Frame
+
+ // Type is the 1 byte frame type. There are ten standard frame
+ // types, but extension frame types may be written by WriteRawFrame
+ // and will be returned by ReadFrame (as UnknownFrame).
+ Type FrameType
+
+ // Flags are the 1 byte of 8 potential bit flags per frame.
+ // They are specific to the frame type.
+ Flags Flags
+
+ // Length is the length of the frame, not including the 9 byte header.
+ // The maximum size is one byte less than 16MB (uint24), but only
+ // frames up to 16KB are allowed without peer agreement.
+ Length uint32
+
+ // StreamID is which stream this frame is for. Certain frames
+ // are not stream-specific, in which case this field is 0.
+ StreamID uint32
+}
+
+// Header returns h. It exists so FrameHeaders can be embedded in other
+// specific frame types and implement the Frame interface.
+func (h FrameHeader) Header() FrameHeader { return h }
+
+func (h FrameHeader) String() string {
+ var buf bytes.Buffer
+ buf.WriteString("[FrameHeader ")
+ h.writeDebug(&buf)
+ buf.WriteByte(']')
+ return buf.String()
+}
+
+func (h FrameHeader) writeDebug(buf *bytes.Buffer) {
+ buf.WriteString(h.Type.String())
+ if h.Flags != 0 {
+ buf.WriteString(" flags=")
+ set := 0
+ for i := uint8(0); i < 8; i++ {
+ if h.Flags&(1<<i) == 0 {
+ continue
+ }
+ set++
+ if set > 1 {
+ buf.WriteByte('|')
+ }
+ name := flagName[h.Type][Flags(1<<i)]
+ if name != "" {
+ buf.WriteString(name)
+ } else {
+ fmt.Fprintf(buf, "0x%x", 1<<i)
+ }
+ }
+ }
+ if h.StreamID != 0 {
+ fmt.Fprintf(buf, " stream=%d", h.StreamID)
+ }
+ fmt.Fprintf(buf, " len=%d", h.Length)
+}
+
+func (h *FrameHeader) checkValid() {
+ if !h.valid {
+ panic("Frame accessor called on non-owned Frame")
+ }
+}
+
+func (h *FrameHeader) invalidate() { h.valid = false }
+
+// frame header bytes.
+// Used only by ReadFrameHeader.
+var fhBytes = sync.Pool{
+ New: func() interface{} {
+ buf := make([]byte, frameHeaderLen)
+ return &buf
+ },
+}
+
+// ReadFrameHeader reads 9 bytes from r and returns a FrameHeader.
+// Most users should use Framer.ReadFrame instead.
+func ReadFrameHeader(r io.Reader) (FrameHeader, error) {
+ bufp := fhBytes.Get().(*[]byte)
+ defer fhBytes.Put(bufp)
+ return readFrameHeader(*bufp, r)
+}
+
+func readFrameHeader(buf []byte, r io.Reader) (FrameHeader, error) {
+ _, err := io.ReadFull(r, buf[:frameHeaderLen])
+ if err != nil {
+ return FrameHeader{}, err
+ }
+ return FrameHeader{
+ Length: (uint32(buf[0])<<16 | uint32(buf[1])<<8 | uint32(buf[2])),
+ Type: FrameType(buf[3]),
+ Flags: Flags(buf[4]),
+ StreamID: binary.BigEndian.Uint32(buf[5:]) & (1<<31 - 1),
+ valid: true,
+ }, nil
+}
+
+// A Frame is the base interface implemented by all frame types.
+// Callers will generally type-assert the specific frame type:
+// *HeadersFrame, *SettingsFrame, *WindowUpdateFrame, etc.
+//
+// Frames are only valid until the next call to Framer.ReadFrame.
+type Frame interface {
+ Header() FrameHeader
+
+ // invalidate is called by Framer.ReadFrame to make this
+ // frame's buffers as being invalid, since the subsequent
+ // frame will reuse them.
+ invalidate()
+}
+
+// A Framer reads and writes Frames.
+type Framer struct {
+ r io.Reader
+ lastFrame Frame
+ errDetail error
+
+ // lastHeaderStream is non-zero if the last frame was an
+ // unfinished HEADERS/CONTINUATION.
+ lastHeaderStream uint32
+
+ maxReadSize uint32
+ headerBuf [frameHeaderLen]byte
+
+ // TODO: let getReadBuf be configurable, and use a less memory-pinning
+ // allocator in server.go to minimize memory pinned for many idle conns.
+ // Will probably also need to make frame invalidation have a hook too.
+ getReadBuf func(size uint32) []byte
+ readBuf []byte // cache for default getReadBuf
+
+ maxWriteSize uint32 // zero means unlimited; TODO: implement
+
+ w io.Writer
+ wbuf []byte
+
+ // AllowIllegalWrites permits the Framer's Write methods to
+ // write frames that do not conform to the HTTP/2 spec. This
+ // permits using the Framer to test other HTTP/2
+ // implementations' conformance to the spec.
+ // If false, the Write methods will prefer to return an error
+ // rather than comply.
+ AllowIllegalWrites bool
+
+ // AllowIllegalReads permits the Framer's ReadFrame method
+ // to return non-compliant frames or frame orders.
+ // This is for testing and permits using the Framer to test
+ // other HTTP/2 implementations' conformance to the spec.
+ // It is not compatible with ReadMetaHeaders.
+ AllowIllegalReads bool
+
+ // ReadMetaHeaders if non-nil causes ReadFrame to merge
+ // HEADERS and CONTINUATION frames together and return
+ // MetaHeadersFrame instead.
+ ReadMetaHeaders *hpack.Decoder
+
+ // MaxHeaderListSize is the http2 MAX_HEADER_LIST_SIZE.
+ // It's used only if ReadMetaHeaders is set; 0 means a sane default
+ // (currently 16MB)
+ // If the limit is hit, MetaHeadersFrame.Truncated is set true.
+ MaxHeaderListSize uint32
+
+ // TODO: track which type of frame & with which flags was sent
+ // last. Then return an error (unless AllowIllegalWrites) if
+ // we're in the middle of a header block and a
+ // non-Continuation or Continuation on a different stream is
+ // attempted to be written.
+
+ logReads bool
+
+ debugFramer *Framer // only use for logging written writes
+ debugFramerBuf *bytes.Buffer
+}
+
+func (fr *Framer) maxHeaderListSize() uint32 {
+ if fr.MaxHeaderListSize == 0 {
+ return 16 << 20 // sane default, per docs
+ }
+ return fr.MaxHeaderListSize
+}
+
+func (f *Framer) startWrite(ftype FrameType, flags Flags, streamID uint32) {
+ // Write the FrameHeader.
+ f.wbuf = append(f.wbuf[:0],
+ 0, // 3 bytes of length, filled in in endWrite
+ 0,
+ 0,
+ byte(ftype),
+ byte(flags),
+ byte(streamID>>24),
+ byte(streamID>>16),
+ byte(streamID>>8),
+ byte(streamID))
+}
+
+func (f *Framer) endWrite() error {
+ // Now that we know the final size, fill in the FrameHeader in
+ // the space previously reserved for it. Abuse append.
+ length := len(f.wbuf) - frameHeaderLen
+ if length >= (1 << 24) {
+ return ErrFrameTooLarge
+ }
+ _ = append(f.wbuf[:0],
+ byte(length>>16),
+ byte(length>>8),
+ byte(length))
+ if logFrameWrites {
+ f.logWrite()
+ }
+
+ n, err := f.w.Write(f.wbuf)
+ if err == nil && n != len(f.wbuf) {
+ err = io.ErrShortWrite
+ }
+ return err
+}
+
+func (f *Framer) logWrite() {
+ if f.debugFramer == nil {
+ f.debugFramerBuf = new(bytes.Buffer)
+ f.debugFramer = NewFramer(nil, f.debugFramerBuf)
+ f.debugFramer.logReads = false // we log it ourselves, saying "wrote" below
+ // Let us read anything, even if we accidentally wrote it
+ // in the wrong order:
+ f.debugFramer.AllowIllegalReads = true
+ }
+ f.debugFramerBuf.Write(f.wbuf)
+ fr, err := f.debugFramer.ReadFrame()
+ if err != nil {
+ log.Printf("http2: Framer %p: failed to decode just-written frame", f)
+ return
+ }
+ log.Printf("http2: Framer %p: wrote %v", f, summarizeFrame(fr))
+}
+
+func (f *Framer) writeByte(v byte) { f.wbuf = append(f.wbuf, v) }
+func (f *Framer) writeBytes(v []byte) { f.wbuf = append(f.wbuf, v...) }
+func (f *Framer) writeUint16(v uint16) { f.wbuf = append(f.wbuf, byte(v>>8), byte(v)) }
+func (f *Framer) writeUint32(v uint32) {
+ f.wbuf = append(f.wbuf, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+const (
+ minMaxFrameSize = 1 << 14
+ maxFrameSize = 1<<24 - 1
+)
+
+// NewFramer returns a Framer that writes frames to w and reads them from r.
+func NewFramer(w io.Writer, r io.Reader) *Framer {
+ fr := &Framer{
+ w: w,
+ r: r,
+ logReads: logFrameReads,
+ }
+ fr.getReadBuf = func(size uint32) []byte {
+ if cap(fr.readBuf) >= int(size) {
+ return fr.readBuf[:size]
+ }
+ fr.readBuf = make([]byte, size)
+ return fr.readBuf
+ }
+ fr.SetMaxReadFrameSize(maxFrameSize)
+ return fr
+}
+
+// SetMaxReadFrameSize sets the maximum size of a frame
+// that will be read by a subsequent call to ReadFrame.
+// It is the caller's responsibility to advertise this
+// limit with a SETTINGS frame.
+func (fr *Framer) SetMaxReadFrameSize(v uint32) {
+ if v > maxFrameSize {
+ v = maxFrameSize
+ }
+ fr.maxReadSize = v
+}
+
+// ErrorDetail returns a more detailed error of the last error
+// returned by Framer.ReadFrame. For instance, if ReadFrame
+// returns a StreamError with code PROTOCOL_ERROR, ErrorDetail
+// will say exactly what was invalid. ErrorDetail is not guaranteed
+// to return a non-nil value and like the rest of the http2 package,
+// its return value is not protected by an API compatibility promise.
+// ErrorDetail is reset after the next call to ReadFrame.
+func (fr *Framer) ErrorDetail() error {
+ return fr.errDetail
+}
+
+// ErrFrameTooLarge is returned from Framer.ReadFrame when the peer
+// sends a frame that is larger than declared with SetMaxReadFrameSize.
+var ErrFrameTooLarge = errors.New("http2: frame too large")
+
+// terminalReadFrameError reports whether err is an unrecoverable
+// error from ReadFrame and no other frames should be read.
+func terminalReadFrameError(err error) bool {
+ if _, ok := err.(StreamError); ok {
+ return false
+ }
+ return err != nil
+}
+
+// ReadFrame reads a single frame. The returned Frame is only valid
+// until the next call to ReadFrame.
+//
+// If the frame is larger than previously set with SetMaxReadFrameSize, the
+// returned error is ErrFrameTooLarge. Other errors may be of type
+// ConnectionError, StreamError, or anything else from the underlying
+// reader.
+func (fr *Framer) ReadFrame() (Frame, error) {
+ fr.errDetail = nil
+ if fr.lastFrame != nil {
+ fr.lastFrame.invalidate()
+ }
+ fh, err := readFrameHeader(fr.headerBuf[:], fr.r)
+ if err != nil {
+ return nil, err
+ }
+ if fh.Length > fr.maxReadSize {
+ return nil, ErrFrameTooLarge
+ }
+ payload := fr.getReadBuf(fh.Length)
+ if _, err := io.ReadFull(fr.r, payload); err != nil {
+ return nil, err
+ }
+ f, err := typeFrameParser(fh.Type)(fh, payload)
+ if err != nil {
+ if ce, ok := err.(connError); ok {
+ return nil, fr.connError(ce.Code, ce.Reason)
+ }
+ return nil, err
+ }
+ if err := fr.checkFrameOrder(f); err != nil {
+ return nil, err
+ }
+ if fr.logReads {
+ log.Printf("http2: Framer %p: read %v", fr, summarizeFrame(f))
+ }
+ if fh.Type == FrameHeaders && fr.ReadMetaHeaders != nil {
+ return fr.readMetaFrame(f.(*HeadersFrame))
+ }
+ return f, nil
+}
+
+// connError returns ConnectionError(code) but first
+// stashes away a public reason to the caller can optionally relay it
+// to the peer before hanging up on them. This might help others debug
+// their implementations.
+func (fr *Framer) connError(code ErrCode, reason string) error {
+ fr.errDetail = errors.New(reason)
+ return ConnectionError(code)
+}
+
+// checkFrameOrder reports an error if f is an invalid frame to return
+// next from ReadFrame. Mostly it checks whether HEADERS and
+// CONTINUATION frames are contiguous.
+func (fr *Framer) checkFrameOrder(f Frame) error {
+ last := fr.lastFrame
+ fr.lastFrame = f
+ if fr.AllowIllegalReads {
+ return nil
+ }
+
+ fh := f.Header()
+ if fr.lastHeaderStream != 0 {
+ if fh.Type != FrameContinuation {
+ return fr.connError(ErrCodeProtocol,
+ fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
+ fh.Type, fh.StreamID,
+ last.Header().Type, fr.lastHeaderStream))
+ }
+ if fh.StreamID != fr.lastHeaderStream {
+ return fr.connError(ErrCodeProtocol,
+ fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
+ fh.StreamID, fr.lastHeaderStream))
+ }
+ } else if fh.Type == FrameContinuation {
+ return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
+ }
+
+ switch fh.Type {
+ case FrameHeaders, FrameContinuation:
+ if fh.Flags.Has(FlagHeadersEndHeaders) {
+ fr.lastHeaderStream = 0
+ } else {
+ fr.lastHeaderStream = fh.StreamID
+ }
+ }
+
+ return nil
+}
+
+// A DataFrame conveys arbitrary, variable-length sequences of octets
+// associated with a stream.
+// See http://http2.github.io/http2-spec/#rfc.section.6.1
+type DataFrame struct {
+ FrameHeader
+ data []byte
+}
+
+func (f *DataFrame) StreamEnded() bool {
+ return f.FrameHeader.Flags.Has(FlagDataEndStream)
+}
+
+// Data returns the frame's data octets, not including any padding
+// size byte or padding suffix bytes.
+// The caller must not retain the returned memory past the next
+// call to ReadFrame.
+func (f *DataFrame) Data() []byte {
+ f.checkValid()
+ return f.data
+}
+
+func parseDataFrame(fh FrameHeader, payload []byte) (Frame, error) {
+ if fh.StreamID == 0 {
+ // DATA frames MUST be associated with a stream. If a
+ // DATA frame is received whose stream identifier
+ // field is 0x0, the recipient MUST respond with a
+ // connection error (Section 5.4.1) of type
+ // PROTOCOL_ERROR.
+ return nil, connError{ErrCodeProtocol, "DATA frame with stream ID 0"}
+ }
+ f := &DataFrame{
+ FrameHeader: fh,
+ }
+ var padSize byte
+ if fh.Flags.Has(FlagDataPadded) {
+ var err error
+ payload, padSize, err = readByte(payload)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if int(padSize) > len(payload) {
+ // If the length of the padding is greater than the
+ // length of the frame payload, the recipient MUST
+ // treat this as a connection error.
+ // Filed: https://github.com/http2/http2-spec/issues/610
+ return nil, connError{ErrCodeProtocol, "pad size larger than data payload"}
+ }
+ f.data = payload[:len(payload)-int(padSize)]
+ return f, nil
+}
+
+var (
+ errStreamID = errors.New("invalid stream ID")
+ errDepStreamID = errors.New("invalid dependent stream ID")
+ errPadLength = errors.New("pad length too large")
+)
+
+func validStreamIDOrZero(streamID uint32) bool {
+ return streamID&(1<<31) == 0
+}
+
+func validStreamID(streamID uint32) bool {
+ return streamID != 0 && streamID&(1<<31) == 0
+}
+
+// WriteData writes a DATA frame.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility not to violate the maximum frame size
+// and to not call other Write methods concurrently.
+func (f *Framer) WriteData(streamID uint32, endStream bool, data []byte) error {
+ return f.WriteDataPadded(streamID, endStream, data, nil)
+}
+
+// WriteData writes a DATA frame with optional padding.
+//
+// If pad is nil, the padding bit is not sent.
+// The length of pad must not exceed 255 bytes.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility not to violate the maximum frame size
+// and to not call other Write methods concurrently.
+func (f *Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
+ if !validStreamID(streamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ if len(pad) > 255 {
+ return errPadLength
+ }
+ var flags Flags
+ if endStream {
+ flags |= FlagDataEndStream
+ }
+ if pad != nil {
+ flags |= FlagDataPadded
+ }
+ f.startWrite(FrameData, flags, streamID)
+ if pad != nil {
+ f.wbuf = append(f.wbuf, byte(len(pad)))
+ }
+ f.wbuf = append(f.wbuf, data...)
+ f.wbuf = append(f.wbuf, pad...)
+ return f.endWrite()
+}
+
+// A SettingsFrame conveys configuration parameters that affect how
+// endpoints communicate, such as preferences and constraints on peer
+// behavior.
+//
+// See http://http2.github.io/http2-spec/#SETTINGS
+type SettingsFrame struct {
+ FrameHeader
+ p []byte
+}
+
+func parseSettingsFrame(fh FrameHeader, p []byte) (Frame, error) {
+ if fh.Flags.Has(FlagSettingsAck) && fh.Length > 0 {
+ // When this (ACK 0x1) bit is set, the payload of the
+ // SETTINGS frame MUST be empty. Receipt of a
+ // SETTINGS frame with the ACK flag set and a length
+ // field value other than 0 MUST be treated as a
+ // connection error (Section 5.4.1) of type
+ // FRAME_SIZE_ERROR.
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ if fh.StreamID != 0 {
+ // SETTINGS frames always apply to a connection,
+ // never a single stream. The stream identifier for a
+ // SETTINGS frame MUST be zero (0x0). If an endpoint
+ // receives a SETTINGS frame whose stream identifier
+ // field is anything other than 0x0, the endpoint MUST
+ // respond with a connection error (Section 5.4.1) of
+ // type PROTOCOL_ERROR.
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ if len(p)%6 != 0 {
+ // Expecting even number of 6 byte settings.
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ f := &SettingsFrame{FrameHeader: fh, p: p}
+ if v, ok := f.Value(SettingInitialWindowSize); ok && v > (1<<31)-1 {
+ // Values above the maximum flow control window size of 2^31 - 1 MUST
+ // be treated as a connection error (Section 5.4.1) of type
+ // FLOW_CONTROL_ERROR.
+ return nil, ConnectionError(ErrCodeFlowControl)
+ }
+ return f, nil
+}
+
+func (f *SettingsFrame) IsAck() bool {
+ return f.FrameHeader.Flags.Has(FlagSettingsAck)
+}
+
+func (f *SettingsFrame) Value(s SettingID) (v uint32, ok bool) {
+ f.checkValid()
+ buf := f.p
+ for len(buf) > 0 {
+ settingID := SettingID(binary.BigEndian.Uint16(buf[:2]))
+ if settingID == s {
+ return binary.BigEndian.Uint32(buf[2:6]), true
+ }
+ buf = buf[6:]
+ }
+ return 0, false
+}
+
+// ForeachSetting runs fn for each setting.
+// It stops and returns the first error.
+func (f *SettingsFrame) ForeachSetting(fn func(Setting) error) error {
+ f.checkValid()
+ buf := f.p
+ for len(buf) > 0 {
+ if err := fn(Setting{
+ SettingID(binary.BigEndian.Uint16(buf[:2])),
+ binary.BigEndian.Uint32(buf[2:6]),
+ }); err != nil {
+ return err
+ }
+ buf = buf[6:]
+ }
+ return nil
+}
+
+// WriteSettings writes a SETTINGS frame with zero or more settings
+// specified and the ACK bit not set.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WriteSettings(settings ...Setting) error {
+ f.startWrite(FrameSettings, 0, 0)
+ for _, s := range settings {
+ f.writeUint16(uint16(s.ID))
+ f.writeUint32(s.Val)
+ }
+ return f.endWrite()
+}
+
+// WriteSettings writes an empty SETTINGS frame with the ACK bit set.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WriteSettingsAck() error {
+ f.startWrite(FrameSettings, FlagSettingsAck, 0)
+ return f.endWrite()
+}
+
+// A PingFrame is a mechanism for measuring a minimal round trip time
+// from the sender, as well as determining whether an idle connection
+// is still functional.
+// See http://http2.github.io/http2-spec/#rfc.section.6.7
+type PingFrame struct {
+ FrameHeader
+ Data [8]byte
+}
+
+func (f *PingFrame) IsAck() bool { return f.Flags.Has(FlagPingAck) }
+
+func parsePingFrame(fh FrameHeader, payload []byte) (Frame, error) {
+ if len(payload) != 8 {
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ if fh.StreamID != 0 {
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ f := &PingFrame{FrameHeader: fh}
+ copy(f.Data[:], payload)
+ return f, nil
+}
+
+func (f *Framer) WritePing(ack bool, data [8]byte) error {
+ var flags Flags
+ if ack {
+ flags = FlagPingAck
+ }
+ f.startWrite(FramePing, flags, 0)
+ f.writeBytes(data[:])
+ return f.endWrite()
+}
+
+// A GoAwayFrame informs the remote peer to stop creating streams on this connection.
+// See http://http2.github.io/http2-spec/#rfc.section.6.8
+type GoAwayFrame struct {
+ FrameHeader
+ LastStreamID uint32
+ ErrCode ErrCode
+ debugData []byte
+}
+
+// DebugData returns any debug data in the GOAWAY frame. Its contents
+// are not defined.
+// The caller must not retain the returned memory past the next
+// call to ReadFrame.
+func (f *GoAwayFrame) DebugData() []byte {
+ f.checkValid()
+ return f.debugData
+}
+
+func parseGoAwayFrame(fh FrameHeader, p []byte) (Frame, error) {
+ if fh.StreamID != 0 {
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ if len(p) < 8 {
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ return &GoAwayFrame{
+ FrameHeader: fh,
+ LastStreamID: binary.BigEndian.Uint32(p[:4]) & (1<<31 - 1),
+ ErrCode: ErrCode(binary.BigEndian.Uint32(p[4:8])),
+ debugData: p[8:],
+ }, nil
+}
+
+func (f *Framer) WriteGoAway(maxStreamID uint32, code ErrCode, debugData []byte) error {
+ f.startWrite(FrameGoAway, 0, 0)
+ f.writeUint32(maxStreamID & (1<<31 - 1))
+ f.writeUint32(uint32(code))
+ f.writeBytes(debugData)
+ return f.endWrite()
+}
+
+// An UnknownFrame is the frame type returned when the frame type is unknown
+// or no specific frame type parser exists.
+type UnknownFrame struct {
+ FrameHeader
+ p []byte
+}
+
+// Payload returns the frame's payload (after the header). It is not
+// valid to call this method after a subsequent call to
+// Framer.ReadFrame, nor is it valid to retain the returned slice.
+// The memory is owned by the Framer and is invalidated when the next
+// frame is read.
+func (f *UnknownFrame) Payload() []byte {
+ f.checkValid()
+ return f.p
+}
+
+func parseUnknownFrame(fh FrameHeader, p []byte) (Frame, error) {
+ return &UnknownFrame{fh, p}, nil
+}
+
+// A WindowUpdateFrame is used to implement flow control.
+// See http://http2.github.io/http2-spec/#rfc.section.6.9
+type WindowUpdateFrame struct {
+ FrameHeader
+ Increment uint32 // never read with high bit set
+}
+
+func parseWindowUpdateFrame(fh FrameHeader, p []byte) (Frame, error) {
+ if len(p) != 4 {
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff // mask off high reserved bit
+ if inc == 0 {
+ // A receiver MUST treat the receipt of a
+ // WINDOW_UPDATE frame with an flow control window
+ // increment of 0 as a stream error (Section 5.4.2) of
+ // type PROTOCOL_ERROR; errors on the connection flow
+ // control window MUST be treated as a connection
+ // error (Section 5.4.1).
+ if fh.StreamID == 0 {
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ return nil, streamError(fh.StreamID, ErrCodeProtocol)
+ }
+ return &WindowUpdateFrame{
+ FrameHeader: fh,
+ Increment: inc,
+ }, nil
+}
+
+// WriteWindowUpdate writes a WINDOW_UPDATE frame.
+// The increment value must be between 1 and 2,147,483,647, inclusive.
+// If the Stream ID is zero, the window update applies to the
+// connection as a whole.
+func (f *Framer) WriteWindowUpdate(streamID, incr uint32) error {
+ // "The legal range for the increment to the flow control window is 1 to 2^31-1 (2,147,483,647) octets."
+ if (incr < 1 || incr > 2147483647) && !f.AllowIllegalWrites {
+ return errors.New("illegal window increment value")
+ }
+ f.startWrite(FrameWindowUpdate, 0, streamID)
+ f.writeUint32(incr)
+ return f.endWrite()
+}
+
+// A HeadersFrame is used to open a stream and additionally carries a
+// header block fragment.
+type HeadersFrame struct {
+ FrameHeader
+
+ // Priority is set if FlagHeadersPriority is set in the FrameHeader.
+ Priority PriorityParam
+
+ headerFragBuf []byte // not owned
+}
+
+func (f *HeadersFrame) HeaderBlockFragment() []byte {
+ f.checkValid()
+ return f.headerFragBuf
+}
+
+func (f *HeadersFrame) HeadersEnded() bool {
+ return f.FrameHeader.Flags.Has(FlagHeadersEndHeaders)
+}
+
+func (f *HeadersFrame) StreamEnded() bool {
+ return f.FrameHeader.Flags.Has(FlagHeadersEndStream)
+}
+
+func (f *HeadersFrame) HasPriority() bool {
+ return f.FrameHeader.Flags.Has(FlagHeadersPriority)
+}
+
+func parseHeadersFrame(fh FrameHeader, p []byte) (_ Frame, err error) {
+ hf := &HeadersFrame{
+ FrameHeader: fh,
+ }
+ if fh.StreamID == 0 {
+ // HEADERS frames MUST be associated with a stream. If a HEADERS frame
+ // is received whose stream identifier field is 0x0, the recipient MUST
+ // respond with a connection error (Section 5.4.1) of type
+ // PROTOCOL_ERROR.
+ return nil, connError{ErrCodeProtocol, "HEADERS frame with stream ID 0"}
+ }
+ var padLength uint8
+ if fh.Flags.Has(FlagHeadersPadded) {
+ if p, padLength, err = readByte(p); err != nil {
+ return
+ }
+ }
+ if fh.Flags.Has(FlagHeadersPriority) {
+ var v uint32
+ p, v, err = readUint32(p)
+ if err != nil {
+ return nil, err
+ }
+ hf.Priority.StreamDep = v & 0x7fffffff
+ hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set
+ p, hf.Priority.Weight, err = readByte(p)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if len(p)-int(padLength) <= 0 {
+ return nil, streamError(fh.StreamID, ErrCodeProtocol)
+ }
+ hf.headerFragBuf = p[:len(p)-int(padLength)]
+ return hf, nil
+}
+
+// HeadersFrameParam are the parameters for writing a HEADERS frame.
+type HeadersFrameParam struct {
+ // StreamID is the required Stream ID to initiate.
+ StreamID uint32
+ // BlockFragment is part (or all) of a Header Block.
+ BlockFragment []byte
+
+ // EndStream indicates that the header block is the last that
+ // the endpoint will send for the identified stream. Setting
+ // this flag causes the stream to enter one of "half closed"
+ // states.
+ EndStream bool
+
+ // EndHeaders indicates that this frame contains an entire
+ // header block and is not followed by any
+ // CONTINUATION frames.
+ EndHeaders bool
+
+ // PadLength is the optional number of bytes of zeros to add
+ // to this frame.
+ PadLength uint8
+
+ // Priority, if non-zero, includes stream priority information
+ // in the HEADER frame.
+ Priority PriorityParam
+}
+
+// WriteHeaders writes a single HEADERS frame.
+//
+// This is a low-level header writing method. Encoding headers and
+// splitting them into any necessary CONTINUATION frames is handled
+// elsewhere.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WriteHeaders(p HeadersFrameParam) error {
+ if !validStreamID(p.StreamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ var flags Flags
+ if p.PadLength != 0 {
+ flags |= FlagHeadersPadded
+ }
+ if p.EndStream {
+ flags |= FlagHeadersEndStream
+ }
+ if p.EndHeaders {
+ flags |= FlagHeadersEndHeaders
+ }
+ if !p.Priority.IsZero() {
+ flags |= FlagHeadersPriority
+ }
+ f.startWrite(FrameHeaders, flags, p.StreamID)
+ if p.PadLength != 0 {
+ f.writeByte(p.PadLength)
+ }
+ if !p.Priority.IsZero() {
+ v := p.Priority.StreamDep
+ if !validStreamIDOrZero(v) && !f.AllowIllegalWrites {
+ return errDepStreamID
+ }
+ if p.Priority.Exclusive {
+ v |= 1 << 31
+ }
+ f.writeUint32(v)
+ f.writeByte(p.Priority.Weight)
+ }
+ f.wbuf = append(f.wbuf, p.BlockFragment...)
+ f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...)
+ return f.endWrite()
+}
+
+// A PriorityFrame specifies the sender-advised priority of a stream.
+// See http://http2.github.io/http2-spec/#rfc.section.6.3
+type PriorityFrame struct {
+ FrameHeader
+ PriorityParam
+}
+
+// PriorityParam are the stream prioritzation parameters.
+type PriorityParam struct {
+ // StreamDep is a 31-bit stream identifier for the
+ // stream that this stream depends on. Zero means no
+ // dependency.
+ StreamDep uint32
+
+ // Exclusive is whether the dependency is exclusive.
+ Exclusive bool
+
+ // Weight is the stream's zero-indexed weight. It should be
+ // set together with StreamDep, or neither should be set. Per
+ // the spec, "Add one to the value to obtain a weight between
+ // 1 and 256."
+ Weight uint8
+}
+
+func (p PriorityParam) IsZero() bool {
+ return p == PriorityParam{}
+}
+
+func parsePriorityFrame(fh FrameHeader, payload []byte) (Frame, error) {
+ if fh.StreamID == 0 {
+ return nil, connError{ErrCodeProtocol, "PRIORITY frame with stream ID 0"}
+ }
+ if len(payload) != 5 {
+ return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
+ }
+ v := binary.BigEndian.Uint32(payload[:4])
+ streamID := v & 0x7fffffff // mask off high bit
+ return &PriorityFrame{
+ FrameHeader: fh,
+ PriorityParam: PriorityParam{
+ Weight: payload[4],
+ StreamDep: streamID,
+ Exclusive: streamID != v, // was high bit set?
+ },
+ }, nil
+}
+
+// WritePriority writes a PRIORITY frame.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WritePriority(streamID uint32, p PriorityParam) error {
+ if !validStreamID(streamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ if !validStreamIDOrZero(p.StreamDep) {
+ return errDepStreamID
+ }
+ f.startWrite(FramePriority, 0, streamID)
+ v := p.StreamDep
+ if p.Exclusive {
+ v |= 1 << 31
+ }
+ f.writeUint32(v)
+ f.writeByte(p.Weight)
+ return f.endWrite()
+}
+
+// A RSTStreamFrame allows for abnormal termination of a stream.
+// See http://http2.github.io/http2-spec/#rfc.section.6.4
+type RSTStreamFrame struct {
+ FrameHeader
+ ErrCode ErrCode
+}
+
+func parseRSTStreamFrame(fh FrameHeader, p []byte) (Frame, error) {
+ if len(p) != 4 {
+ return nil, ConnectionError(ErrCodeFrameSize)
+ }
+ if fh.StreamID == 0 {
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ return &RSTStreamFrame{fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil
+}
+
+// WriteRSTStream writes a RST_STREAM frame.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WriteRSTStream(streamID uint32, code ErrCode) error {
+ if !validStreamID(streamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ f.startWrite(FrameRSTStream, 0, streamID)
+ f.writeUint32(uint32(code))
+ return f.endWrite()
+}
+
+// A ContinuationFrame is used to continue a sequence of header block fragments.
+// See http://http2.github.io/http2-spec/#rfc.section.6.10
+type ContinuationFrame struct {
+ FrameHeader
+ headerFragBuf []byte
+}
+
+func parseContinuationFrame(fh FrameHeader, p []byte) (Frame, error) {
+ if fh.StreamID == 0 {
+ return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"}
+ }
+ return &ContinuationFrame{fh, p}, nil
+}
+
+func (f *ContinuationFrame) HeaderBlockFragment() []byte {
+ f.checkValid()
+ return f.headerFragBuf
+}
+
+func (f *ContinuationFrame) HeadersEnded() bool {
+ return f.FrameHeader.Flags.Has(FlagContinuationEndHeaders)
+}
+
+// WriteContinuation writes a CONTINUATION frame.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
+ if !validStreamID(streamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ var flags Flags
+ if endHeaders {
+ flags |= FlagContinuationEndHeaders
+ }
+ f.startWrite(FrameContinuation, flags, streamID)
+ f.wbuf = append(f.wbuf, headerBlockFragment...)
+ return f.endWrite()
+}
+
+// A PushPromiseFrame is used to initiate a server stream.
+// See http://http2.github.io/http2-spec/#rfc.section.6.6
+type PushPromiseFrame struct {
+ FrameHeader
+ PromiseID uint32
+ headerFragBuf []byte // not owned
+}
+
+func (f *PushPromiseFrame) HeaderBlockFragment() []byte {
+ f.checkValid()
+ return f.headerFragBuf
+}
+
+func (f *PushPromiseFrame) HeadersEnded() bool {
+ return f.FrameHeader.Flags.Has(FlagPushPromiseEndHeaders)
+}
+
+func parsePushPromise(fh FrameHeader, p []byte) (_ Frame, err error) {
+ pp := &PushPromiseFrame{
+ FrameHeader: fh,
+ }
+ if pp.StreamID == 0 {
+ // PUSH_PROMISE frames MUST be associated with an existing,
+ // peer-initiated stream. The stream identifier of a
+ // PUSH_PROMISE frame indicates the stream it is associated
+ // with. If the stream identifier field specifies the value
+ // 0x0, a recipient MUST respond with a connection error
+ // (Section 5.4.1) of type PROTOCOL_ERROR.
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ // The PUSH_PROMISE frame includes optional padding.
+ // Padding fields and flags are identical to those defined for DATA frames
+ var padLength uint8
+ if fh.Flags.Has(FlagPushPromisePadded) {
+ if p, padLength, err = readByte(p); err != nil {
+ return
+ }
+ }
+
+ p, pp.PromiseID, err = readUint32(p)
+ if err != nil {
+ return
+ }
+ pp.PromiseID = pp.PromiseID & (1<<31 - 1)
+
+ if int(padLength) > len(p) {
+ // like the DATA frame, error out if padding is longer than the body.
+ return nil, ConnectionError(ErrCodeProtocol)
+ }
+ pp.headerFragBuf = p[:len(p)-int(padLength)]
+ return pp, nil
+}
+
+// PushPromiseParam are the parameters for writing a PUSH_PROMISE frame.
+type PushPromiseParam struct {
+ // StreamID is the required Stream ID to initiate.
+ StreamID uint32
+
+ // PromiseID is the required Stream ID which this
+ // Push Promises
+ PromiseID uint32
+
+ // BlockFragment is part (or all) of a Header Block.
+ BlockFragment []byte
+
+ // EndHeaders indicates that this frame contains an entire
+ // header block and is not followed by any
+ // CONTINUATION frames.
+ EndHeaders bool
+
+ // PadLength is the optional number of bytes of zeros to add
+ // to this frame.
+ PadLength uint8
+}
+
+// WritePushPromise writes a single PushPromise Frame.
+//
+// As with Header Frames, This is the low level call for writing
+// individual frames. Continuation frames are handled elsewhere.
+//
+// It will perform exactly one Write to the underlying Writer.
+// It is the caller's responsibility to not call other Write methods concurrently.
+func (f *Framer) WritePushPromise(p PushPromiseParam) error {
+ if !validStreamID(p.StreamID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ var flags Flags
+ if p.PadLength != 0 {
+ flags |= FlagPushPromisePadded
+ }
+ if p.EndHeaders {
+ flags |= FlagPushPromiseEndHeaders
+ }
+ f.startWrite(FramePushPromise, flags, p.StreamID)
+ if p.PadLength != 0 {
+ f.writeByte(p.PadLength)
+ }
+ if !validStreamID(p.PromiseID) && !f.AllowIllegalWrites {
+ return errStreamID
+ }
+ f.writeUint32(p.PromiseID)
+ f.wbuf = append(f.wbuf, p.BlockFragment...)
+ f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...)
+ return f.endWrite()
+}
+
+// WriteRawFrame writes a raw frame. This can be used to write
+// extension frames unknown to this package.
+func (f *Framer) WriteRawFrame(t FrameType, flags Flags, streamID uint32, payload []byte) error {
+ f.startWrite(t, flags, streamID)
+ f.writeBytes(payload)
+ return f.endWrite()
+}
+
+func readByte(p []byte) (remain []byte, b byte, err error) {
+ if len(p) == 0 {
+ return nil, 0, io.ErrUnexpectedEOF
+ }
+ return p[1:], p[0], nil
+}
+
+func readUint32(p []byte) (remain []byte, v uint32, err error) {
+ if len(p) < 4 {
+ return nil, 0, io.ErrUnexpectedEOF
+ }
+ return p[4:], binary.BigEndian.Uint32(p[:4]), nil
+}
+
+type streamEnder interface {
+ StreamEnded() bool
+}
+
+type headersEnder interface {
+ HeadersEnded() bool
+}
+
+type headersOrContinuation interface {
+ headersEnder
+ HeaderBlockFragment() []byte
+}
+
+// A MetaHeadersFrame is the representation of one HEADERS frame and
+// zero or more contiguous CONTINUATION frames and the decoding of
+// their HPACK-encoded contents.
+//
+// This type of frame does not appear on the wire and is only returned
+// by the Framer when Framer.ReadMetaHeaders is set.
+type MetaHeadersFrame struct {
+ *HeadersFrame
+
+ // Fields are the fields contained in the HEADERS and
+ // CONTINUATION frames. The underlying slice is owned by the
+ // Framer and must not be retained after the next call to
+ // ReadFrame.
+ //
+ // Fields are guaranteed to be in the correct http2 order and
+ // not have unknown pseudo header fields or invalid header
+ // field names or values. Required pseudo header fields may be
+ // missing, however. Use the MetaHeadersFrame.Pseudo accessor
+ // method access pseudo headers.
+ Fields []hpack.HeaderField
+
+ // Truncated is whether the max header list size limit was hit
+ // and Fields is incomplete. The hpack decoder state is still
+ // valid, however.
+ Truncated bool
+}
+
+// PseudoValue returns the given pseudo header field's value.
+// The provided pseudo field should not contain the leading colon.
+func (mh *MetaHeadersFrame) PseudoValue(pseudo string) string {
+ for _, hf := range mh.Fields {
+ if !hf.IsPseudo() {
+ return ""
+ }
+ if hf.Name[1:] == pseudo {
+ return hf.Value
+ }
+ }
+ return ""
+}
+
+// RegularFields returns the regular (non-pseudo) header fields of mh.
+// The caller does not own the returned slice.
+func (mh *MetaHeadersFrame) RegularFields() []hpack.HeaderField {
+ for i, hf := range mh.Fields {
+ if !hf.IsPseudo() {
+ return mh.Fields[i:]
+ }
+ }
+ return nil
+}
+
+// PseudoFields returns the pseudo header fields of mh.
+// The caller does not own the returned slice.
+func (mh *MetaHeadersFrame) PseudoFields() []hpack.HeaderField {
+ for i, hf := range mh.Fields {
+ if !hf.IsPseudo() {
+ return mh.Fields[:i]
+ }
+ }
+ return mh.Fields
+}
+
+func (mh *MetaHeadersFrame) checkPseudos() error {
+ var isRequest, isResponse bool
+ pf := mh.PseudoFields()
+ for i, hf := range pf {
+ switch hf.Name {
+ case ":method", ":path", ":scheme", ":authority":
+ isRequest = true
+ case ":status":
+ isResponse = true
+ default:
+ return pseudoHeaderError(hf.Name)
+ }
+ // Check for duplicates.
+ // This would be a bad algorithm, but N is 4.
+ // And this doesn't allocate.
+ for _, hf2 := range pf[:i] {
+ if hf.Name == hf2.Name {
+ return duplicatePseudoHeaderError(hf.Name)
+ }
+ }
+ }
+ if isRequest && isResponse {
+ return errMixPseudoHeaderTypes
+ }
+ return nil
+}
+
+func (fr *Framer) maxHeaderStringLen() int {
+ v := fr.maxHeaderListSize()
+ if uint32(int(v)) == v {
+ return int(v)
+ }
+ // They had a crazy big number for MaxHeaderBytes anyway,
+ // so give them unlimited header lengths:
+ return 0
+}
+
+// readMetaFrame returns 0 or more CONTINUATION frames from fr and
+// merge them into into the provided hf and returns a MetaHeadersFrame
+// with the decoded hpack values.
+func (fr *Framer) readMetaFrame(hf *HeadersFrame) (*MetaHeadersFrame, error) {
+ if fr.AllowIllegalReads {
+ return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
+ }
+ mh := &MetaHeadersFrame{
+ HeadersFrame: hf,
+ }
+ var remainSize = fr.maxHeaderListSize()
+ var sawRegular bool
+
+ var invalid error // pseudo header field errors
+ hdec := fr.ReadMetaHeaders
+ hdec.SetEmitEnabled(true)
+ hdec.SetMaxStringLength(fr.maxHeaderStringLen())
+ hdec.SetEmitFunc(func(hf hpack.HeaderField) {
+ if VerboseLogs && logFrameReads {
+ log.Printf("http2: decoded hpack field %+v", hf)
+ }
+ if !httplex.ValidHeaderFieldValue(hf.Value) {
+ invalid = headerFieldValueError(hf.Value)
+ }
+ isPseudo := strings.HasPrefix(hf.Name, ":")
+ if isPseudo {
+ if sawRegular {
+ invalid = errPseudoAfterRegular
+ }
+ } else {
+ sawRegular = true
+ if !validWireHeaderFieldName(hf.Name) {
+ invalid = headerFieldNameError(hf.Name)
+ }
+ }
+
+ if invalid != nil {
+ hdec.SetEmitEnabled(false)
+ return
+ }
+
+ size := hf.Size()
+ if size > remainSize {
+ hdec.SetEmitEnabled(false)
+ mh.Truncated = true
+ return
+ }
+ remainSize -= size
+
+ mh.Fields = append(mh.Fields, hf)
+ })
+ // Lose reference to MetaHeadersFrame:
+ defer hdec.SetEmitFunc(func(hf hpack.HeaderField) {})
+
+ var hc headersOrContinuation = hf
+ for {
+ frag := hc.HeaderBlockFragment()
+ if _, err := hdec.Write(frag); err != nil {
+ return nil, ConnectionError(ErrCodeCompression)
+ }
+
+ if hc.HeadersEnded() {
+ break
+ }
+ if f, err := fr.ReadFrame(); err != nil {
+ return nil, err
+ } else {
+ hc = f.(*ContinuationFrame) // guaranteed by checkFrameOrder
+ }
+ }
+
+ mh.HeadersFrame.headerFragBuf = nil
+ mh.HeadersFrame.invalidate()
+
+ if err := hdec.Close(); err != nil {
+ return nil, ConnectionError(ErrCodeCompression)
+ }
+ if invalid != nil {
+ fr.errDetail = invalid
+ if VerboseLogs {
+ log.Printf("http2: invalid header: %v", invalid)
+ }
+ return nil, StreamError{mh.StreamID, ErrCodeProtocol, invalid}
+ }
+ if err := mh.checkPseudos(); err != nil {
+ fr.errDetail = err
+ if VerboseLogs {
+ log.Printf("http2: invalid pseudo headers: %v", err)
+ }
+ return nil, StreamError{mh.StreamID, ErrCodeProtocol, err}
+ }
+ return mh, nil
+}
+
+func summarizeFrame(f Frame) string {
+ var buf bytes.Buffer
+ f.Header().writeDebug(&buf)
+ switch f := f.(type) {
+ case *SettingsFrame:
+ n := 0
+ f.ForeachSetting(func(s Setting) error {
+ n++
+ if n == 1 {
+ buf.WriteString(", settings:")
+ }
+ fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
+ return nil
+ })
+ if n > 0 {
+ buf.Truncate(buf.Len() - 1) // remove trailing comma
+ }
+ case *DataFrame:
+ data := f.Data()
+ const max = 256
+ if len(data) > max {
+ data = data[:max]
+ }
+ fmt.Fprintf(&buf, " data=%q", data)
+ if len(f.Data()) > max {
+ fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
+ }
+ case *WindowUpdateFrame:
+ if f.StreamID == 0 {
+ buf.WriteString(" (conn)")
+ }
+ fmt.Fprintf(&buf, " incr=%v", f.Increment)
+ case *PingFrame:
+ fmt.Fprintf(&buf, " ping=%q", f.Data[:])
+ case *GoAwayFrame:
+ fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
+ f.LastStreamID, f.ErrCode, f.debugData)
+ case *RSTStreamFrame:
+ fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)
+ }
+ return buf.String()
+}
diff --git a/vendor/golang.org/x/net/http2/go16.go b/vendor/golang.org/x/net/http2/go16.go
new file mode 100644
index 0000000000000000000000000000000000000000..2b72855f552103b240eb8f086e5aaae88380a586
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/go16.go
@@ -0,0 +1,43 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.6
+
+package http2
+
+import (
+ "crypto/tls"
+ "net/http"
+ "time"
+)
+
+func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
+ return t1.ExpectContinueTimeout
+}
+
+// isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec.
+func isBadCipher(cipher uint16) bool {
+ switch cipher {
+ case tls.TLS_RSA_WITH_RC4_128_SHA,
+ tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+ tls.TLS_RSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_RSA_WITH_AES_256_CBC_SHA,
+ tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
+ tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
+ tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+ tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
+ // Reject cipher suites from Appendix A.
+ // "This list includes those cipher suites that do not
+ // offer an ephemeral key exchange and those that are
+ // based on the TLS null, stream or block cipher type"
+ return true
+ default:
+ return false
+ }
+}
diff --git a/vendor/golang.org/x/net/http2/go17.go b/vendor/golang.org/x/net/http2/go17.go
new file mode 100644
index 0000000000000000000000000000000000000000..730319dd5ac7824a9e5175cabf29235e1ec25291
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/go17.go
@@ -0,0 +1,94 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.7
+
+package http2
+
+import (
+ "context"
+ "net"
+ "net/http"
+ "net/http/httptrace"
+ "time"
+)
+
+type contextContext interface {
+ context.Context
+}
+
+func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) {
+ ctx, cancel = context.WithCancel(context.Background())
+ ctx = context.WithValue(ctx, http.LocalAddrContextKey, c.LocalAddr())
+ if hs := opts.baseConfig(); hs != nil {
+ ctx = context.WithValue(ctx, http.ServerContextKey, hs)
+ }
+ return
+}
+
+func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) {
+ return context.WithCancel(ctx)
+}
+
+func requestWithContext(req *http.Request, ctx contextContext) *http.Request {
+ return req.WithContext(ctx)
+}
+
+type clientTrace httptrace.ClientTrace
+
+func reqContext(r *http.Request) context.Context { return r.Context() }
+
+func setResponseUncompressed(res *http.Response) { res.Uncompressed = true }
+
+func traceGotConn(req *http.Request, cc *ClientConn) {
+ trace := httptrace.ContextClientTrace(req.Context())
+ if trace == nil || trace.GotConn == nil {
+ return
+ }
+ ci := httptrace.GotConnInfo{Conn: cc.tconn}
+ cc.mu.Lock()
+ ci.Reused = cc.nextStreamID > 1
+ ci.WasIdle = len(cc.streams) == 0 && ci.Reused
+ if ci.WasIdle && !cc.lastActive.IsZero() {
+ ci.IdleTime = time.Now().Sub(cc.lastActive)
+ }
+ cc.mu.Unlock()
+
+ trace.GotConn(ci)
+}
+
+func traceWroteHeaders(trace *clientTrace) {
+ if trace != nil && trace.WroteHeaders != nil {
+ trace.WroteHeaders()
+ }
+}
+
+func traceGot100Continue(trace *clientTrace) {
+ if trace != nil && trace.Got100Continue != nil {
+ trace.Got100Continue()
+ }
+}
+
+func traceWait100Continue(trace *clientTrace) {
+ if trace != nil && trace.Wait100Continue != nil {
+ trace.Wait100Continue()
+ }
+}
+
+func traceWroteRequest(trace *clientTrace, err error) {
+ if trace != nil && trace.WroteRequest != nil {
+ trace.WroteRequest(httptrace.WroteRequestInfo{Err: err})
+ }
+}
+
+func traceFirstResponseByte(trace *clientTrace) {
+ if trace != nil && trace.GotFirstResponseByte != nil {
+ trace.GotFirstResponseByte()
+ }
+}
+
+func requestTrace(req *http.Request) *clientTrace {
+ trace := httptrace.ContextClientTrace(req.Context())
+ return (*clientTrace)(trace)
+}
diff --git a/vendor/golang.org/x/net/http2/gotrack.go b/vendor/golang.org/x/net/http2/gotrack.go
new file mode 100644
index 0000000000000000000000000000000000000000..9933c9f8c7487b62324558e18c2c878cb5e363d7
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/gotrack.go
@@ -0,0 +1,170 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Defensive debug-only utility to track that functions run on the
+// goroutine that they're supposed to.
+
+package http2
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "os"
+ "runtime"
+ "strconv"
+ "sync"
+)
+
+var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
+
+type goroutineLock uint64
+
+func newGoroutineLock() goroutineLock {
+ if !DebugGoroutines {
+ return 0
+ }
+ return goroutineLock(curGoroutineID())
+}
+
+func (g goroutineLock) check() {
+ if !DebugGoroutines {
+ return
+ }
+ if curGoroutineID() != uint64(g) {
+ panic("running on the wrong goroutine")
+ }
+}
+
+func (g goroutineLock) checkNotOn() {
+ if !DebugGoroutines {
+ return
+ }
+ if curGoroutineID() == uint64(g) {
+ panic("running on the wrong goroutine")
+ }
+}
+
+var goroutineSpace = []byte("goroutine ")
+
+func curGoroutineID() uint64 {
+ bp := littleBuf.Get().(*[]byte)
+ defer littleBuf.Put(bp)
+ b := *bp
+ b = b[:runtime.Stack(b, false)]
+ // Parse the 4707 out of "goroutine 4707 ["
+ b = bytes.TrimPrefix(b, goroutineSpace)
+ i := bytes.IndexByte(b, ' ')
+ if i < 0 {
+ panic(fmt.Sprintf("No space found in %q", b))
+ }
+ b = b[:i]
+ n, err := parseUintBytes(b, 10, 64)
+ if err != nil {
+ panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
+ }
+ return n
+}
+
+var littleBuf = sync.Pool{
+ New: func() interface{} {
+ buf := make([]byte, 64)
+ return &buf
+ },
+}
+
+// parseUintBytes is like strconv.ParseUint, but using a []byte.
+func parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) {
+ var cutoff, maxVal uint64
+
+ if bitSize == 0 {
+ bitSize = int(strconv.IntSize)
+ }
+
+ s0 := s
+ switch {
+ case len(s) < 1:
+ err = strconv.ErrSyntax
+ goto Error
+
+ case 2 <= base && base <= 36:
+ // valid base; nothing to do
+
+ case base == 0:
+ // Look for octal, hex prefix.
+ switch {
+ case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
+ base = 16
+ s = s[2:]
+ if len(s) < 1 {
+ err = strconv.ErrSyntax
+ goto Error
+ }
+ case s[0] == '0':
+ base = 8
+ default:
+ base = 10
+ }
+
+ default:
+ err = errors.New("invalid base " + strconv.Itoa(base))
+ goto Error
+ }
+
+ n = 0
+ cutoff = cutoff64(base)
+ maxVal = 1<<uint(bitSize) - 1
+
+ for i := 0; i < len(s); i++ {
+ var v byte
+ d := s[i]
+ switch {
+ case '0' <= d && d <= '9':
+ v = d - '0'
+ case 'a' <= d && d <= 'z':
+ v = d - 'a' + 10
+ case 'A' <= d && d <= 'Z':
+ v = d - 'A' + 10
+ default:
+ n = 0
+ err = strconv.ErrSyntax
+ goto Error
+ }
+ if int(v) >= base {
+ n = 0
+ err = strconv.ErrSyntax
+ goto Error
+ }
+
+ if n >= cutoff {
+ // n*base overflows
+ n = 1<<64 - 1
+ err = strconv.ErrRange
+ goto Error
+ }
+ n *= uint64(base)
+
+ n1 := n + uint64(v)
+ if n1 < n || n1 > maxVal {
+ // n+v overflows
+ n = 1<<64 - 1
+ err = strconv.ErrRange
+ goto Error
+ }
+ n = n1
+ }
+
+ return n, nil
+
+Error:
+ return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err}
+}
+
+// Return the first number n such that n*base >= 1<<64.
+func cutoff64(base int) uint64 {
+ if base < 2 {
+ return 0
+ }
+ return (1<<64-1)/uint64(base) + 1
+}
diff --git a/vendor/golang.org/x/net/http2/headermap.go b/vendor/golang.org/x/net/http2/headermap.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2805f6ac4d53394e6bae0a0dfb0b0f5b03c224f
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/headermap.go
@@ -0,0 +1,78 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "net/http"
+ "strings"
+)
+
+var (
+ commonLowerHeader = map[string]string{} // Go-Canonical-Case -> lower-case
+ commonCanonHeader = map[string]string{} // lower-case -> Go-Canonical-Case
+)
+
+func init() {
+ for _, v := range []string{
+ "accept",
+ "accept-charset",
+ "accept-encoding",
+ "accept-language",
+ "accept-ranges",
+ "age",
+ "access-control-allow-origin",
+ "allow",
+ "authorization",
+ "cache-control",
+ "content-disposition",
+ "content-encoding",
+ "content-language",
+ "content-length",
+ "content-location",
+ "content-range",
+ "content-type",
+ "cookie",
+ "date",
+ "etag",
+ "expect",
+ "expires",
+ "from",
+ "host",
+ "if-match",
+ "if-modified-since",
+ "if-none-match",
+ "if-unmodified-since",
+ "last-modified",
+ "link",
+ "location",
+ "max-forwards",
+ "proxy-authenticate",
+ "proxy-authorization",
+ "range",
+ "referer",
+ "refresh",
+ "retry-after",
+ "server",
+ "set-cookie",
+ "strict-transport-security",
+ "trailer",
+ "transfer-encoding",
+ "user-agent",
+ "vary",
+ "via",
+ "www-authenticate",
+ } {
+ chk := http.CanonicalHeaderKey(v)
+ commonLowerHeader[chk] = v
+ commonCanonHeader[v] = chk
+ }
+}
+
+func lowerHeader(v string) string {
+ if s, ok := commonLowerHeader[v]; ok {
+ return s
+ }
+ return strings.ToLower(v)
+}
diff --git a/vendor/golang.org/x/net/http2/hpack/encode.go b/vendor/golang.org/x/net/http2/hpack/encode.go
new file mode 100644
index 0000000000000000000000000000000000000000..f9bb03398483533dac826a0f7febcaf1343e1ecf
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/hpack/encode.go
@@ -0,0 +1,251 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package hpack
+
+import (
+ "io"
+)
+
+const (
+ uint32Max = ^uint32(0)
+ initialHeaderTableSize = 4096
+)
+
+type Encoder struct {
+ dynTab dynamicTable
+ // minSize is the minimum table size set by
+ // SetMaxDynamicTableSize after the previous Header Table Size
+ // Update.
+ minSize uint32
+ // maxSizeLimit is the maximum table size this encoder
+ // supports. This will protect the encoder from too large
+ // size.
+ maxSizeLimit uint32
+ // tableSizeUpdate indicates whether "Header Table Size
+ // Update" is required.
+ tableSizeUpdate bool
+ w io.Writer
+ buf []byte
+}
+
+// NewEncoder returns a new Encoder which performs HPACK encoding. An
+// encoded data is written to w.
+func NewEncoder(w io.Writer) *Encoder {
+ e := &Encoder{
+ minSize: uint32Max,
+ maxSizeLimit: initialHeaderTableSize,
+ tableSizeUpdate: false,
+ w: w,
+ }
+ e.dynTab.setMaxSize(initialHeaderTableSize)
+ return e
+}
+
+// WriteField encodes f into a single Write to e's underlying Writer.
+// This function may also produce bytes for "Header Table Size Update"
+// if necessary. If produced, it is done before encoding f.
+func (e *Encoder) WriteField(f HeaderField) error {
+ e.buf = e.buf[:0]
+
+ if e.tableSizeUpdate {
+ e.tableSizeUpdate = false
+ if e.minSize < e.dynTab.maxSize {
+ e.buf = appendTableSize(e.buf, e.minSize)
+ }
+ e.minSize = uint32Max
+ e.buf = appendTableSize(e.buf, e.dynTab.maxSize)
+ }
+
+ idx, nameValueMatch := e.searchTable(f)
+ if nameValueMatch {
+ e.buf = appendIndexed(e.buf, idx)
+ } else {
+ indexing := e.shouldIndex(f)
+ if indexing {
+ e.dynTab.add(f)
+ }
+
+ if idx == 0 {
+ e.buf = appendNewName(e.buf, f, indexing)
+ } else {
+ e.buf = appendIndexedName(e.buf, f, idx, indexing)
+ }
+ }
+ n, err := e.w.Write(e.buf)
+ if err == nil && n != len(e.buf) {
+ err = io.ErrShortWrite
+ }
+ return err
+}
+
+// searchTable searches f in both stable and dynamic header tables.
+// The static header table is searched first. Only when there is no
+// exact match for both name and value, the dynamic header table is
+// then searched. If there is no match, i is 0. If both name and value
+// match, i is the matched index and nameValueMatch becomes true. If
+// only name matches, i points to that index and nameValueMatch
+// becomes false.
+func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) {
+ for idx, hf := range staticTable {
+ if !constantTimeStringCompare(hf.Name, f.Name) {
+ continue
+ }
+ if i == 0 {
+ i = uint64(idx + 1)
+ }
+ if f.Sensitive {
+ continue
+ }
+ if !constantTimeStringCompare(hf.Value, f.Value) {
+ continue
+ }
+ i = uint64(idx + 1)
+ nameValueMatch = true
+ return
+ }
+
+ j, nameValueMatch := e.dynTab.search(f)
+ if nameValueMatch || (i == 0 && j != 0) {
+ i = j + uint64(len(staticTable))
+ }
+ return
+}
+
+// SetMaxDynamicTableSize changes the dynamic header table size to v.
+// The actual size is bounded by the value passed to
+// SetMaxDynamicTableSizeLimit.
+func (e *Encoder) SetMaxDynamicTableSize(v uint32) {
+ if v > e.maxSizeLimit {
+ v = e.maxSizeLimit
+ }
+ if v < e.minSize {
+ e.minSize = v
+ }
+ e.tableSizeUpdate = true
+ e.dynTab.setMaxSize(v)
+}
+
+// SetMaxDynamicTableSizeLimit changes the maximum value that can be
+// specified in SetMaxDynamicTableSize to v. By default, it is set to
+// 4096, which is the same size of the default dynamic header table
+// size described in HPACK specification. If the current maximum
+// dynamic header table size is strictly greater than v, "Header Table
+// Size Update" will be done in the next WriteField call and the
+// maximum dynamic header table size is truncated to v.
+func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) {
+ e.maxSizeLimit = v
+ if e.dynTab.maxSize > v {
+ e.tableSizeUpdate = true
+ e.dynTab.setMaxSize(v)
+ }
+}
+
+// shouldIndex reports whether f should be indexed.
+func (e *Encoder) shouldIndex(f HeaderField) bool {
+ return !f.Sensitive && f.Size() <= e.dynTab.maxSize
+}
+
+// appendIndexed appends index i, as encoded in "Indexed Header Field"
+// representation, to dst and returns the extended buffer.
+func appendIndexed(dst []byte, i uint64) []byte {
+ first := len(dst)
+ dst = appendVarInt(dst, 7, i)
+ dst[first] |= 0x80
+ return dst
+}
+
+// appendNewName appends f, as encoded in one of "Literal Header field
+// - New Name" representation variants, to dst and returns the
+// extended buffer.
+//
+// If f.Sensitive is true, "Never Indexed" representation is used. If
+// f.Sensitive is false and indexing is true, "Inremental Indexing"
+// representation is used.
+func appendNewName(dst []byte, f HeaderField, indexing bool) []byte {
+ dst = append(dst, encodeTypeByte(indexing, f.Sensitive))
+ dst = appendHpackString(dst, f.Name)
+ return appendHpackString(dst, f.Value)
+}
+
+// appendIndexedName appends f and index i referring indexed name
+// entry, as encoded in one of "Literal Header field - Indexed Name"
+// representation variants, to dst and returns the extended buffer.
+//
+// If f.Sensitive is true, "Never Indexed" representation is used. If
+// f.Sensitive is false and indexing is true, "Incremental Indexing"
+// representation is used.
+func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
+ first := len(dst)
+ var n byte
+ if indexing {
+ n = 6
+ } else {
+ n = 4
+ }
+ dst = appendVarInt(dst, n, i)
+ dst[first] |= encodeTypeByte(indexing, f.Sensitive)
+ return appendHpackString(dst, f.Value)
+}
+
+// appendTableSize appends v, as encoded in "Header Table Size Update"
+// representation, to dst and returns the extended buffer.
+func appendTableSize(dst []byte, v uint32) []byte {
+ first := len(dst)
+ dst = appendVarInt(dst, 5, uint64(v))
+ dst[first] |= 0x20
+ return dst
+}
+
+// appendVarInt appends i, as encoded in variable integer form using n
+// bit prefix, to dst and returns the extended buffer.
+//
+// See
+// http://http2.github.io/http2-spec/compression.html#integer.representation
+func appendVarInt(dst []byte, n byte, i uint64) []byte {
+ k := uint64((1 << n) - 1)
+ if i < k {
+ return append(dst, byte(i))
+ }
+ dst = append(dst, byte(k))
+ i -= k
+ for ; i >= 128; i >>= 7 {
+ dst = append(dst, byte(0x80|(i&0x7f)))
+ }
+ return append(dst, byte(i))
+}
+
+// appendHpackString appends s, as encoded in "String Literal"
+// representation, to dst and returns the the extended buffer.
+//
+// s will be encoded in Huffman codes only when it produces strictly
+// shorter byte string.
+func appendHpackString(dst []byte, s string) []byte {
+ huffmanLength := HuffmanEncodeLength(s)
+ if huffmanLength < uint64(len(s)) {
+ first := len(dst)
+ dst = appendVarInt(dst, 7, huffmanLength)
+ dst = AppendHuffmanString(dst, s)
+ dst[first] |= 0x80
+ } else {
+ dst = appendVarInt(dst, 7, uint64(len(s)))
+ dst = append(dst, s...)
+ }
+ return dst
+}
+
+// encodeTypeByte returns type byte. If sensitive is true, type byte
+// for "Never Indexed" representation is returned. If sensitive is
+// false and indexing is true, type byte for "Incremental Indexing"
+// representation is returned. Otherwise, type byte for "Without
+// Indexing" is returned.
+func encodeTypeByte(indexing, sensitive bool) byte {
+ if sensitive {
+ return 0x10
+ }
+ if indexing {
+ return 0x40
+ }
+ return 0
+}
diff --git a/vendor/golang.org/x/net/http2/hpack/hpack.go b/vendor/golang.org/x/net/http2/hpack/hpack.go
new file mode 100644
index 0000000000000000000000000000000000000000..8aa197ad678d3ba8d627644a3cf91d8948c44a20
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/hpack/hpack.go
@@ -0,0 +1,542 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package hpack implements HPACK, a compression format for
+// efficiently representing HTTP header fields in the context of HTTP/2.
+//
+// See http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09
+package hpack
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+)
+
+// A DecodingError is something the spec defines as a decoding error.
+type DecodingError struct {
+ Err error
+}
+
+func (de DecodingError) Error() string {
+ return fmt.Sprintf("decoding error: %v", de.Err)
+}
+
+// An InvalidIndexError is returned when an encoder references a table
+// entry before the static table or after the end of the dynamic table.
+type InvalidIndexError int
+
+func (e InvalidIndexError) Error() string {
+ return fmt.Sprintf("invalid indexed representation index %d", int(e))
+}
+
+// A HeaderField is a name-value pair. Both the name and value are
+// treated as opaque sequences of octets.
+type HeaderField struct {
+ Name, Value string
+
+ // Sensitive means that this header field should never be
+ // indexed.
+ Sensitive bool
+}
+
+// IsPseudo reports whether the header field is an http2 pseudo header.
+// That is, it reports whether it starts with a colon.
+// It is not otherwise guaranteed to be a valid pseudo header field,
+// though.
+func (hf HeaderField) IsPseudo() bool {
+ return len(hf.Name) != 0 && hf.Name[0] == ':'
+}
+
+func (hf HeaderField) String() string {
+ var suffix string
+ if hf.Sensitive {
+ suffix = " (sensitive)"
+ }
+ return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix)
+}
+
+// Size returns the size of an entry per RFC 7540 section 5.2.
+func (hf HeaderField) Size() uint32 {
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.4.1
+ // "The size of the dynamic table is the sum of the size of
+ // its entries. The size of an entry is the sum of its name's
+ // length in octets (as defined in Section 5.2), its value's
+ // length in octets (see Section 5.2), plus 32. The size of
+ // an entry is calculated using the length of the name and
+ // value without any Huffman encoding applied."
+
+ // This can overflow if somebody makes a large HeaderField
+ // Name and/or Value by hand, but we don't care, because that
+ // won't happen on the wire because the encoding doesn't allow
+ // it.
+ return uint32(len(hf.Name) + len(hf.Value) + 32)
+}
+
+// A Decoder is the decoding context for incremental processing of
+// header blocks.
+type Decoder struct {
+ dynTab dynamicTable
+ emit func(f HeaderField)
+
+ emitEnabled bool // whether calls to emit are enabled
+ maxStrLen int // 0 means unlimited
+
+ // buf is the unparsed buffer. It's only written to
+ // saveBuf if it was truncated in the middle of a header
+ // block. Because it's usually not owned, we can only
+ // process it under Write.
+ buf []byte // not owned; only valid during Write
+
+ // saveBuf is previous data passed to Write which we weren't able
+ // to fully parse before. Unlike buf, we own this data.
+ saveBuf bytes.Buffer
+}
+
+// NewDecoder returns a new decoder with the provided maximum dynamic
+// table size. The emitFunc will be called for each valid field
+// parsed, in the same goroutine as calls to Write, before Write returns.
+func NewDecoder(maxDynamicTableSize uint32, emitFunc func(f HeaderField)) *Decoder {
+ d := &Decoder{
+ emit: emitFunc,
+ emitEnabled: true,
+ }
+ d.dynTab.allowedMaxSize = maxDynamicTableSize
+ d.dynTab.setMaxSize(maxDynamicTableSize)
+ return d
+}
+
+// ErrStringLength is returned by Decoder.Write when the max string length
+// (as configured by Decoder.SetMaxStringLength) would be violated.
+var ErrStringLength = errors.New("hpack: string too long")
+
+// SetMaxStringLength sets the maximum size of a HeaderField name or
+// value string. If a string exceeds this length (even after any
+// decompression), Write will return ErrStringLength.
+// A value of 0 means unlimited and is the default from NewDecoder.
+func (d *Decoder) SetMaxStringLength(n int) {
+ d.maxStrLen = n
+}
+
+// SetEmitFunc changes the callback used when new header fields
+// are decoded.
+// It must be non-nil. It does not affect EmitEnabled.
+func (d *Decoder) SetEmitFunc(emitFunc func(f HeaderField)) {
+ d.emit = emitFunc
+}
+
+// SetEmitEnabled controls whether the emitFunc provided to NewDecoder
+// should be called. The default is true.
+//
+// This facility exists to let servers enforce MAX_HEADER_LIST_SIZE
+// while still decoding and keeping in-sync with decoder state, but
+// without doing unnecessary decompression or generating unnecessary
+// garbage for header fields past the limit.
+func (d *Decoder) SetEmitEnabled(v bool) { d.emitEnabled = v }
+
+// EmitEnabled reports whether calls to the emitFunc provided to NewDecoder
+// are currently enabled. The default is true.
+func (d *Decoder) EmitEnabled() bool { return d.emitEnabled }
+
+// TODO: add method *Decoder.Reset(maxSize, emitFunc) to let callers re-use Decoders and their
+// underlying buffers for garbage reasons.
+
+func (d *Decoder) SetMaxDynamicTableSize(v uint32) {
+ d.dynTab.setMaxSize(v)
+}
+
+// SetAllowedMaxDynamicTableSize sets the upper bound that the encoded
+// stream (via dynamic table size updates) may set the maximum size
+// to.
+func (d *Decoder) SetAllowedMaxDynamicTableSize(v uint32) {
+ d.dynTab.allowedMaxSize = v
+}
+
+type dynamicTable struct {
+ // ents is the FIFO described at
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.2.3.2
+ // The newest (low index) is append at the end, and items are
+ // evicted from the front.
+ ents []HeaderField
+ size uint32
+ maxSize uint32 // current maxSize
+ allowedMaxSize uint32 // maxSize may go up to this, inclusive
+}
+
+func (dt *dynamicTable) setMaxSize(v uint32) {
+ dt.maxSize = v
+ dt.evict()
+}
+
+// TODO: change dynamicTable to be a struct with a slice and a size int field,
+// per http://http2.github.io/http2-spec/compression.html#rfc.section.4.1:
+//
+//
+// Then make add increment the size. maybe the max size should move from Decoder to
+// dynamicTable and add should return an ok bool if there was enough space.
+//
+// Later we'll need a remove operation on dynamicTable.
+
+func (dt *dynamicTable) add(f HeaderField) {
+ dt.ents = append(dt.ents, f)
+ dt.size += f.Size()
+ dt.evict()
+}
+
+// If we're too big, evict old stuff (front of the slice)
+func (dt *dynamicTable) evict() {
+ base := dt.ents // keep base pointer of slice
+ for dt.size > dt.maxSize {
+ dt.size -= dt.ents[0].Size()
+ dt.ents = dt.ents[1:]
+ }
+
+ // Shift slice contents down if we evicted things.
+ if len(dt.ents) != len(base) {
+ copy(base, dt.ents)
+ dt.ents = base[:len(dt.ents)]
+ }
+}
+
+// constantTimeStringCompare compares string a and b in a constant
+// time manner.
+func constantTimeStringCompare(a, b string) bool {
+ if len(a) != len(b) {
+ return false
+ }
+
+ c := byte(0)
+
+ for i := 0; i < len(a); i++ {
+ c |= a[i] ^ b[i]
+ }
+
+ return c == 0
+}
+
+// Search searches f in the table. The return value i is 0 if there is
+// no name match. If there is name match or name/value match, i is the
+// index of that entry (1-based). If both name and value match,
+// nameValueMatch becomes true.
+func (dt *dynamicTable) search(f HeaderField) (i uint64, nameValueMatch bool) {
+ l := len(dt.ents)
+ for j := l - 1; j >= 0; j-- {
+ ent := dt.ents[j]
+ if !constantTimeStringCompare(ent.Name, f.Name) {
+ continue
+ }
+ if i == 0 {
+ i = uint64(l - j)
+ }
+ if f.Sensitive {
+ continue
+ }
+ if !constantTimeStringCompare(ent.Value, f.Value) {
+ continue
+ }
+ i = uint64(l - j)
+ nameValueMatch = true
+ return
+ }
+ return
+}
+
+func (d *Decoder) maxTableIndex() int {
+ return len(d.dynTab.ents) + len(staticTable)
+}
+
+func (d *Decoder) at(i uint64) (hf HeaderField, ok bool) {
+ if i < 1 {
+ return
+ }
+ if i > uint64(d.maxTableIndex()) {
+ return
+ }
+ if i <= uint64(len(staticTable)) {
+ return staticTable[i-1], true
+ }
+ dents := d.dynTab.ents
+ return dents[len(dents)-(int(i)-len(staticTable))], true
+}
+
+// Decode decodes an entire block.
+//
+// TODO: remove this method and make it incremental later? This is
+// easier for debugging now.
+func (d *Decoder) DecodeFull(p []byte) ([]HeaderField, error) {
+ var hf []HeaderField
+ saveFunc := d.emit
+ defer func() { d.emit = saveFunc }()
+ d.emit = func(f HeaderField) { hf = append(hf, f) }
+ if _, err := d.Write(p); err != nil {
+ return nil, err
+ }
+ if err := d.Close(); err != nil {
+ return nil, err
+ }
+ return hf, nil
+}
+
+func (d *Decoder) Close() error {
+ if d.saveBuf.Len() > 0 {
+ d.saveBuf.Reset()
+ return DecodingError{errors.New("truncated headers")}
+ }
+ return nil
+}
+
+func (d *Decoder) Write(p []byte) (n int, err error) {
+ if len(p) == 0 {
+ // Prevent state machine CPU attacks (making us redo
+ // work up to the point of finding out we don't have
+ // enough data)
+ return
+ }
+ // Only copy the data if we have to. Optimistically assume
+ // that p will contain a complete header block.
+ if d.saveBuf.Len() == 0 {
+ d.buf = p
+ } else {
+ d.saveBuf.Write(p)
+ d.buf = d.saveBuf.Bytes()
+ d.saveBuf.Reset()
+ }
+
+ for len(d.buf) > 0 {
+ err = d.parseHeaderFieldRepr()
+ if err == errNeedMore {
+ // Extra paranoia, making sure saveBuf won't
+ // get too large. All the varint and string
+ // reading code earlier should already catch
+ // overlong things and return ErrStringLength,
+ // but keep this as a last resort.
+ const varIntOverhead = 8 // conservative
+ if d.maxStrLen != 0 && int64(len(d.buf)) > 2*(int64(d.maxStrLen)+varIntOverhead) {
+ return 0, ErrStringLength
+ }
+ d.saveBuf.Write(d.buf)
+ return len(p), nil
+ }
+ if err != nil {
+ break
+ }
+ }
+ return len(p), err
+}
+
+// errNeedMore is an internal sentinel error value that means the
+// buffer is truncated and we need to read more data before we can
+// continue parsing.
+var errNeedMore = errors.New("need more data")
+
+type indexType int
+
+const (
+ indexedTrue indexType = iota
+ indexedFalse
+ indexedNever
+)
+
+func (v indexType) indexed() bool { return v == indexedTrue }
+func (v indexType) sensitive() bool { return v == indexedNever }
+
+// returns errNeedMore if there isn't enough data available.
+// any other error is fatal.
+// consumes d.buf iff it returns nil.
+// precondition: must be called with len(d.buf) > 0
+func (d *Decoder) parseHeaderFieldRepr() error {
+ b := d.buf[0]
+ switch {
+ case b&128 != 0:
+ // Indexed representation.
+ // High bit set?
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.6.1
+ return d.parseFieldIndexed()
+ case b&192 == 64:
+ // 6.2.1 Literal Header Field with Incremental Indexing
+ // 0b10xxxxxx: top two bits are 10
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.1
+ return d.parseFieldLiteral(6, indexedTrue)
+ case b&240 == 0:
+ // 6.2.2 Literal Header Field without Indexing
+ // 0b0000xxxx: top four bits are 0000
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.2
+ return d.parseFieldLiteral(4, indexedFalse)
+ case b&240 == 16:
+ // 6.2.3 Literal Header Field never Indexed
+ // 0b0001xxxx: top four bits are 0001
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.3
+ return d.parseFieldLiteral(4, indexedNever)
+ case b&224 == 32:
+ // 6.3 Dynamic Table Size Update
+ // Top three bits are '001'.
+ // http://http2.github.io/http2-spec/compression.html#rfc.section.6.3
+ return d.parseDynamicTableSizeUpdate()
+ }
+
+ return DecodingError{errors.New("invalid encoding")}
+}
+
+// (same invariants and behavior as parseHeaderFieldRepr)
+func (d *Decoder) parseFieldIndexed() error {
+ buf := d.buf
+ idx, buf, err := readVarInt(7, buf)
+ if err != nil {
+ return err
+ }
+ hf, ok := d.at(idx)
+ if !ok {
+ return DecodingError{InvalidIndexError(idx)}
+ }
+ d.buf = buf
+ return d.callEmit(HeaderField{Name: hf.Name, Value: hf.Value})
+}
+
+// (same invariants and behavior as parseHeaderFieldRepr)
+func (d *Decoder) parseFieldLiteral(n uint8, it indexType) error {
+ buf := d.buf
+ nameIdx, buf, err := readVarInt(n, buf)
+ if err != nil {
+ return err
+ }
+
+ var hf HeaderField
+ wantStr := d.emitEnabled || it.indexed()
+ if nameIdx > 0 {
+ ihf, ok := d.at(nameIdx)
+ if !ok {
+ return DecodingError{InvalidIndexError(nameIdx)}
+ }
+ hf.Name = ihf.Name
+ } else {
+ hf.Name, buf, err = d.readString(buf, wantStr)
+ if err != nil {
+ return err
+ }
+ }
+ hf.Value, buf, err = d.readString(buf, wantStr)
+ if err != nil {
+ return err
+ }
+ d.buf = buf
+ if it.indexed() {
+ d.dynTab.add(hf)
+ }
+ hf.Sensitive = it.sensitive()
+ return d.callEmit(hf)
+}
+
+func (d *Decoder) callEmit(hf HeaderField) error {
+ if d.maxStrLen != 0 {
+ if len(hf.Name) > d.maxStrLen || len(hf.Value) > d.maxStrLen {
+ return ErrStringLength
+ }
+ }
+ if d.emitEnabled {
+ d.emit(hf)
+ }
+ return nil
+}
+
+// (same invariants and behavior as parseHeaderFieldRepr)
+func (d *Decoder) parseDynamicTableSizeUpdate() error {
+ buf := d.buf
+ size, buf, err := readVarInt(5, buf)
+ if err != nil {
+ return err
+ }
+ if size > uint64(d.dynTab.allowedMaxSize) {
+ return DecodingError{errors.New("dynamic table size update too large")}
+ }
+ d.dynTab.setMaxSize(uint32(size))
+ d.buf = buf
+ return nil
+}
+
+var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
+
+// readVarInt reads an unsigned variable length integer off the
+// beginning of p. n is the parameter as described in
+// http://http2.github.io/http2-spec/compression.html#rfc.section.5.1.
+//
+// n must always be between 1 and 8.
+//
+// The returned remain buffer is either a smaller suffix of p, or err != nil.
+// The error is errNeedMore if p doesn't contain a complete integer.
+func readVarInt(n byte, p []byte) (i uint64, remain []byte, err error) {
+ if n < 1 || n > 8 {
+ panic("bad n")
+ }
+ if len(p) == 0 {
+ return 0, p, errNeedMore
+ }
+ i = uint64(p[0])
+ if n < 8 {
+ i &= (1 << uint64(n)) - 1
+ }
+ if i < (1<<uint64(n))-1 {
+ return i, p[1:], nil
+ }
+
+ origP := p
+ p = p[1:]
+ var m uint64
+ for len(p) > 0 {
+ b := p[0]
+ p = p[1:]
+ i += uint64(b&127) << m
+ if b&128 == 0 {
+ return i, p, nil
+ }
+ m += 7
+ if m >= 63 { // TODO: proper overflow check. making this up.
+ return 0, origP, errVarintOverflow
+ }
+ }
+ return 0, origP, errNeedMore
+}
+
+// readString decodes an hpack string from p.
+//
+// wantStr is whether s will be used. If false, decompression and
+// []byte->string garbage are skipped if s will be ignored
+// anyway. This does mean that huffman decoding errors for non-indexed
+// strings past the MAX_HEADER_LIST_SIZE are ignored, but the server
+// is returning an error anyway, and because they're not indexed, the error
+// won't affect the decoding state.
+func (d *Decoder) readString(p []byte, wantStr bool) (s string, remain []byte, err error) {
+ if len(p) == 0 {
+ return "", p, errNeedMore
+ }
+ isHuff := p[0]&128 != 0
+ strLen, p, err := readVarInt(7, p)
+ if err != nil {
+ return "", p, err
+ }
+ if d.maxStrLen != 0 && strLen > uint64(d.maxStrLen) {
+ return "", nil, ErrStringLength
+ }
+ if uint64(len(p)) < strLen {
+ return "", p, errNeedMore
+ }
+ if !isHuff {
+ if wantStr {
+ s = string(p[:strLen])
+ }
+ return s, p[strLen:], nil
+ }
+
+ if wantStr {
+ buf := bufPool.Get().(*bytes.Buffer)
+ buf.Reset() // don't trust others
+ defer bufPool.Put(buf)
+ if err := huffmanDecode(buf, d.maxStrLen, p[:strLen]); err != nil {
+ buf.Reset()
+ return "", nil, err
+ }
+ s = buf.String()
+ buf.Reset() // be nice to GC
+ }
+ return s, p[strLen:], nil
+}
diff --git a/vendor/golang.org/x/net/http2/hpack/huffman.go b/vendor/golang.org/x/net/http2/hpack/huffman.go
new file mode 100644
index 0000000000000000000000000000000000000000..8850e3946770ea09203ddb3ea15d4c818e5eeea0
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/hpack/huffman.go
@@ -0,0 +1,212 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package hpack
+
+import (
+ "bytes"
+ "errors"
+ "io"
+ "sync"
+)
+
+var bufPool = sync.Pool{
+ New: func() interface{} { return new(bytes.Buffer) },
+}
+
+// HuffmanDecode decodes the string in v and writes the expanded
+// result to w, returning the number of bytes written to w and the
+// Write call's return value. At most one Write call is made.
+func HuffmanDecode(w io.Writer, v []byte) (int, error) {
+ buf := bufPool.Get().(*bytes.Buffer)
+ buf.Reset()
+ defer bufPool.Put(buf)
+ if err := huffmanDecode(buf, 0, v); err != nil {
+ return 0, err
+ }
+ return w.Write(buf.Bytes())
+}
+
+// HuffmanDecodeToString decodes the string in v.
+func HuffmanDecodeToString(v []byte) (string, error) {
+ buf := bufPool.Get().(*bytes.Buffer)
+ buf.Reset()
+ defer bufPool.Put(buf)
+ if err := huffmanDecode(buf, 0, v); err != nil {
+ return "", err
+ }
+ return buf.String(), nil
+}
+
+// ErrInvalidHuffman is returned for errors found decoding
+// Huffman-encoded strings.
+var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
+
+// huffmanDecode decodes v to buf.
+// If maxLen is greater than 0, attempts to write more to buf than
+// maxLen bytes will return ErrStringLength.
+func huffmanDecode(buf *bytes.Buffer, maxLen int, v []byte) error {
+ n := rootHuffmanNode
+ // cur is the bit buffer that has not been fed into n.
+ // cbits is the number of low order bits in cur that are valid.
+ // sbits is the number of bits of the symbol prefix being decoded.
+ cur, cbits, sbits := uint(0), uint8(0), uint8(0)
+ for _, b := range v {
+ cur = cur<<8 | uint(b)
+ cbits += 8
+ sbits += 8
+ for cbits >= 8 {
+ idx := byte(cur >> (cbits - 8))
+ n = n.children[idx]
+ if n == nil {
+ return ErrInvalidHuffman
+ }
+ if n.children == nil {
+ if maxLen != 0 && buf.Len() == maxLen {
+ return ErrStringLength
+ }
+ buf.WriteByte(n.sym)
+ cbits -= n.codeLen
+ n = rootHuffmanNode
+ sbits = cbits
+ } else {
+ cbits -= 8
+ }
+ }
+ }
+ for cbits > 0 {
+ n = n.children[byte(cur<<(8-cbits))]
+ if n == nil {
+ return ErrInvalidHuffman
+ }
+ if n.children != nil || n.codeLen > cbits {
+ break
+ }
+ if maxLen != 0 && buf.Len() == maxLen {
+ return ErrStringLength
+ }
+ buf.WriteByte(n.sym)
+ cbits -= n.codeLen
+ n = rootHuffmanNode
+ sbits = cbits
+ }
+ if sbits > 7 {
+ // Either there was an incomplete symbol, or overlong padding.
+ // Both are decoding errors per RFC 7541 section 5.2.
+ return ErrInvalidHuffman
+ }
+ if mask := uint(1<<cbits - 1); cur&mask != mask {
+ // Trailing bits must be a prefix of EOS per RFC 7541 section 5.2.
+ return ErrInvalidHuffman
+ }
+
+ return nil
+}
+
+type node struct {
+ // children is non-nil for internal nodes
+ children []*node
+
+ // The following are only valid if children is nil:
+ codeLen uint8 // number of bits that led to the output of sym
+ sym byte // output symbol
+}
+
+func newInternalNode() *node {
+ return &node{children: make([]*node, 256)}
+}
+
+var rootHuffmanNode = newInternalNode()
+
+func init() {
+ if len(huffmanCodes) != 256 {
+ panic("unexpected size")
+ }
+ for i, code := range huffmanCodes {
+ addDecoderNode(byte(i), code, huffmanCodeLen[i])
+ }
+}
+
+func addDecoderNode(sym byte, code uint32, codeLen uint8) {
+ cur := rootHuffmanNode
+ for codeLen > 8 {
+ codeLen -= 8
+ i := uint8(code >> codeLen)
+ if cur.children[i] == nil {
+ cur.children[i] = newInternalNode()
+ }
+ cur = cur.children[i]
+ }
+ shift := 8 - codeLen
+ start, end := int(uint8(code<<shift)), int(1<<shift)
+ for i := start; i < start+end; i++ {
+ cur.children[i] = &node{sym: sym, codeLen: codeLen}
+ }
+}
+
+// AppendHuffmanString appends s, as encoded in Huffman codes, to dst
+// and returns the extended buffer.
+func AppendHuffmanString(dst []byte, s string) []byte {
+ rembits := uint8(8)
+
+ for i := 0; i < len(s); i++ {
+ if rembits == 8 {
+ dst = append(dst, 0)
+ }
+ dst, rembits = appendByteToHuffmanCode(dst, rembits, s[i])
+ }
+
+ if rembits < 8 {
+ // special EOS symbol
+ code := uint32(0x3fffffff)
+ nbits := uint8(30)
+
+ t := uint8(code >> (nbits - rembits))
+ dst[len(dst)-1] |= t
+ }
+
+ return dst
+}
+
+// HuffmanEncodeLength returns the number of bytes required to encode
+// s in Huffman codes. The result is round up to byte boundary.
+func HuffmanEncodeLength(s string) uint64 {
+ n := uint64(0)
+ for i := 0; i < len(s); i++ {
+ n += uint64(huffmanCodeLen[s[i]])
+ }
+ return (n + 7) / 8
+}
+
+// appendByteToHuffmanCode appends Huffman code for c to dst and
+// returns the extended buffer and the remaining bits in the last
+// element. The appending is not byte aligned and the remaining bits
+// in the last element of dst is given in rembits.
+func appendByteToHuffmanCode(dst []byte, rembits uint8, c byte) ([]byte, uint8) {
+ code := huffmanCodes[c]
+ nbits := huffmanCodeLen[c]
+
+ for {
+ if rembits > nbits {
+ t := uint8(code << (rembits - nbits))
+ dst[len(dst)-1] |= t
+ rembits -= nbits
+ break
+ }
+
+ t := uint8(code >> (nbits - rembits))
+ dst[len(dst)-1] |= t
+
+ nbits -= rembits
+ rembits = 8
+
+ if nbits == 0 {
+ break
+ }
+
+ dst = append(dst, 0)
+ }
+
+ return dst, rembits
+}
diff --git a/vendor/golang.org/x/net/http2/hpack/tables.go b/vendor/golang.org/x/net/http2/hpack/tables.go
new file mode 100644
index 0000000000000000000000000000000000000000..b9283a023302311c3719bc2cc2db94b458c53edf
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/hpack/tables.go
@@ -0,0 +1,352 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package hpack
+
+func pair(name, value string) HeaderField {
+ return HeaderField{Name: name, Value: value}
+}
+
+// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-07#appendix-B
+var staticTable = [...]HeaderField{
+ pair(":authority", ""), // index 1 (1-based)
+ pair(":method", "GET"),
+ pair(":method", "POST"),
+ pair(":path", "/"),
+ pair(":path", "/index.html"),
+ pair(":scheme", "http"),
+ pair(":scheme", "https"),
+ pair(":status", "200"),
+ pair(":status", "204"),
+ pair(":status", "206"),
+ pair(":status", "304"),
+ pair(":status", "400"),
+ pair(":status", "404"),
+ pair(":status", "500"),
+ pair("accept-charset", ""),
+ pair("accept-encoding", "gzip, deflate"),
+ pair("accept-language", ""),
+ pair("accept-ranges", ""),
+ pair("accept", ""),
+ pair("access-control-allow-origin", ""),
+ pair("age", ""),
+ pair("allow", ""),
+ pair("authorization", ""),
+ pair("cache-control", ""),
+ pair("content-disposition", ""),
+ pair("content-encoding", ""),
+ pair("content-language", ""),
+ pair("content-length", ""),
+ pair("content-location", ""),
+ pair("content-range", ""),
+ pair("content-type", ""),
+ pair("cookie", ""),
+ pair("date", ""),
+ pair("etag", ""),
+ pair("expect", ""),
+ pair("expires", ""),
+ pair("from", ""),
+ pair("host", ""),
+ pair("if-match", ""),
+ pair("if-modified-since", ""),
+ pair("if-none-match", ""),
+ pair("if-range", ""),
+ pair("if-unmodified-since", ""),
+ pair("last-modified", ""),
+ pair("link", ""),
+ pair("location", ""),
+ pair("max-forwards", ""),
+ pair("proxy-authenticate", ""),
+ pair("proxy-authorization", ""),
+ pair("range", ""),
+ pair("referer", ""),
+ pair("refresh", ""),
+ pair("retry-after", ""),
+ pair("server", ""),
+ pair("set-cookie", ""),
+ pair("strict-transport-security", ""),
+ pair("transfer-encoding", ""),
+ pair("user-agent", ""),
+ pair("vary", ""),
+ pair("via", ""),
+ pair("www-authenticate", ""),
+}
+
+var huffmanCodes = [256]uint32{
+ 0x1ff8,
+ 0x7fffd8,
+ 0xfffffe2,
+ 0xfffffe3,
+ 0xfffffe4,
+ 0xfffffe5,
+ 0xfffffe6,
+ 0xfffffe7,
+ 0xfffffe8,
+ 0xffffea,
+ 0x3ffffffc,
+ 0xfffffe9,
+ 0xfffffea,
+ 0x3ffffffd,
+ 0xfffffeb,
+ 0xfffffec,
+ 0xfffffed,
+ 0xfffffee,
+ 0xfffffef,
+ 0xffffff0,
+ 0xffffff1,
+ 0xffffff2,
+ 0x3ffffffe,
+ 0xffffff3,
+ 0xffffff4,
+ 0xffffff5,
+ 0xffffff6,
+ 0xffffff7,
+ 0xffffff8,
+ 0xffffff9,
+ 0xffffffa,
+ 0xffffffb,
+ 0x14,
+ 0x3f8,
+ 0x3f9,
+ 0xffa,
+ 0x1ff9,
+ 0x15,
+ 0xf8,
+ 0x7fa,
+ 0x3fa,
+ 0x3fb,
+ 0xf9,
+ 0x7fb,
+ 0xfa,
+ 0x16,
+ 0x17,
+ 0x18,
+ 0x0,
+ 0x1,
+ 0x2,
+ 0x19,
+ 0x1a,
+ 0x1b,
+ 0x1c,
+ 0x1d,
+ 0x1e,
+ 0x1f,
+ 0x5c,
+ 0xfb,
+ 0x7ffc,
+ 0x20,
+ 0xffb,
+ 0x3fc,
+ 0x1ffa,
+ 0x21,
+ 0x5d,
+ 0x5e,
+ 0x5f,
+ 0x60,
+ 0x61,
+ 0x62,
+ 0x63,
+ 0x64,
+ 0x65,
+ 0x66,
+ 0x67,
+ 0x68,
+ 0x69,
+ 0x6a,
+ 0x6b,
+ 0x6c,
+ 0x6d,
+ 0x6e,
+ 0x6f,
+ 0x70,
+ 0x71,
+ 0x72,
+ 0xfc,
+ 0x73,
+ 0xfd,
+ 0x1ffb,
+ 0x7fff0,
+ 0x1ffc,
+ 0x3ffc,
+ 0x22,
+ 0x7ffd,
+ 0x3,
+ 0x23,
+ 0x4,
+ 0x24,
+ 0x5,
+ 0x25,
+ 0x26,
+ 0x27,
+ 0x6,
+ 0x74,
+ 0x75,
+ 0x28,
+ 0x29,
+ 0x2a,
+ 0x7,
+ 0x2b,
+ 0x76,
+ 0x2c,
+ 0x8,
+ 0x9,
+ 0x2d,
+ 0x77,
+ 0x78,
+ 0x79,
+ 0x7a,
+ 0x7b,
+ 0x7ffe,
+ 0x7fc,
+ 0x3ffd,
+ 0x1ffd,
+ 0xffffffc,
+ 0xfffe6,
+ 0x3fffd2,
+ 0xfffe7,
+ 0xfffe8,
+ 0x3fffd3,
+ 0x3fffd4,
+ 0x3fffd5,
+ 0x7fffd9,
+ 0x3fffd6,
+ 0x7fffda,
+ 0x7fffdb,
+ 0x7fffdc,
+ 0x7fffdd,
+ 0x7fffde,
+ 0xffffeb,
+ 0x7fffdf,
+ 0xffffec,
+ 0xffffed,
+ 0x3fffd7,
+ 0x7fffe0,
+ 0xffffee,
+ 0x7fffe1,
+ 0x7fffe2,
+ 0x7fffe3,
+ 0x7fffe4,
+ 0x1fffdc,
+ 0x3fffd8,
+ 0x7fffe5,
+ 0x3fffd9,
+ 0x7fffe6,
+ 0x7fffe7,
+ 0xffffef,
+ 0x3fffda,
+ 0x1fffdd,
+ 0xfffe9,
+ 0x3fffdb,
+ 0x3fffdc,
+ 0x7fffe8,
+ 0x7fffe9,
+ 0x1fffde,
+ 0x7fffea,
+ 0x3fffdd,
+ 0x3fffde,
+ 0xfffff0,
+ 0x1fffdf,
+ 0x3fffdf,
+ 0x7fffeb,
+ 0x7fffec,
+ 0x1fffe0,
+ 0x1fffe1,
+ 0x3fffe0,
+ 0x1fffe2,
+ 0x7fffed,
+ 0x3fffe1,
+ 0x7fffee,
+ 0x7fffef,
+ 0xfffea,
+ 0x3fffe2,
+ 0x3fffe3,
+ 0x3fffe4,
+ 0x7ffff0,
+ 0x3fffe5,
+ 0x3fffe6,
+ 0x7ffff1,
+ 0x3ffffe0,
+ 0x3ffffe1,
+ 0xfffeb,
+ 0x7fff1,
+ 0x3fffe7,
+ 0x7ffff2,
+ 0x3fffe8,
+ 0x1ffffec,
+ 0x3ffffe2,
+ 0x3ffffe3,
+ 0x3ffffe4,
+ 0x7ffffde,
+ 0x7ffffdf,
+ 0x3ffffe5,
+ 0xfffff1,
+ 0x1ffffed,
+ 0x7fff2,
+ 0x1fffe3,
+ 0x3ffffe6,
+ 0x7ffffe0,
+ 0x7ffffe1,
+ 0x3ffffe7,
+ 0x7ffffe2,
+ 0xfffff2,
+ 0x1fffe4,
+ 0x1fffe5,
+ 0x3ffffe8,
+ 0x3ffffe9,
+ 0xffffffd,
+ 0x7ffffe3,
+ 0x7ffffe4,
+ 0x7ffffe5,
+ 0xfffec,
+ 0xfffff3,
+ 0xfffed,
+ 0x1fffe6,
+ 0x3fffe9,
+ 0x1fffe7,
+ 0x1fffe8,
+ 0x7ffff3,
+ 0x3fffea,
+ 0x3fffeb,
+ 0x1ffffee,
+ 0x1ffffef,
+ 0xfffff4,
+ 0xfffff5,
+ 0x3ffffea,
+ 0x7ffff4,
+ 0x3ffffeb,
+ 0x7ffffe6,
+ 0x3ffffec,
+ 0x3ffffed,
+ 0x7ffffe7,
+ 0x7ffffe8,
+ 0x7ffffe9,
+ 0x7ffffea,
+ 0x7ffffeb,
+ 0xffffffe,
+ 0x7ffffec,
+ 0x7ffffed,
+ 0x7ffffee,
+ 0x7ffffef,
+ 0x7fffff0,
+ 0x3ffffee,
+}
+
+var huffmanCodeLen = [256]uint8{
+ 13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28,
+ 28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+ 6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6,
+ 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10,
+ 13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6,
+ 15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5,
+ 6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28,
+ 20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23,
+ 24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24,
+ 22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23,
+ 21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23,
+ 26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25,
+ 19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27,
+ 20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23,
+ 26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26,
+}
diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go
new file mode 100644
index 0000000000000000000000000000000000000000..a9053eeca6343a957a3a54e7f38e556647344ba4
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/http2.go
@@ -0,0 +1,352 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package http2 implements the HTTP/2 protocol.
+//
+// This package is low-level and intended to be used directly by very
+// few people. Most users will use it indirectly through the automatic
+// use by the net/http package (from Go 1.6 and later).
+// For use in earlier Go versions see ConfigureServer. (Transport support
+// requires Go 1.6 or later)
+//
+// See https://http2.github.io/ for more information on HTTP/2.
+//
+// See https://http2.golang.org/ for a test server running this code.
+//
+package http2
+
+import (
+ "bufio"
+ "crypto/tls"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+
+ "golang.org/x/net/lex/httplex"
+)
+
+var (
+ VerboseLogs bool
+ logFrameWrites bool
+ logFrameReads bool
+)
+
+func init() {
+ e := os.Getenv("GODEBUG")
+ if strings.Contains(e, "http2debug=1") {
+ VerboseLogs = true
+ }
+ if strings.Contains(e, "http2debug=2") {
+ VerboseLogs = true
+ logFrameWrites = true
+ logFrameReads = true
+ }
+}
+
+const (
+ // ClientPreface is the string that must be sent by new
+ // connections from clients.
+ ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+
+ // SETTINGS_MAX_FRAME_SIZE default
+ // http://http2.github.io/http2-spec/#rfc.section.6.5.2
+ initialMaxFrameSize = 16384
+
+ // NextProtoTLS is the NPN/ALPN protocol negotiated during
+ // HTTP/2's TLS setup.
+ NextProtoTLS = "h2"
+
+ // http://http2.github.io/http2-spec/#SettingValues
+ initialHeaderTableSize = 4096
+
+ initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size
+
+ defaultMaxReadFrameSize = 1 << 20
+)
+
+var (
+ clientPreface = []byte(ClientPreface)
+)
+
+type streamState int
+
+const (
+ stateIdle streamState = iota
+ stateOpen
+ stateHalfClosedLocal
+ stateHalfClosedRemote
+ stateResvLocal
+ stateResvRemote
+ stateClosed
+)
+
+var stateName = [...]string{
+ stateIdle: "Idle",
+ stateOpen: "Open",
+ stateHalfClosedLocal: "HalfClosedLocal",
+ stateHalfClosedRemote: "HalfClosedRemote",
+ stateResvLocal: "ResvLocal",
+ stateResvRemote: "ResvRemote",
+ stateClosed: "Closed",
+}
+
+func (st streamState) String() string {
+ return stateName[st]
+}
+
+// Setting is a setting parameter: which setting it is, and its value.
+type Setting struct {
+ // ID is which setting is being set.
+ // See http://http2.github.io/http2-spec/#SettingValues
+ ID SettingID
+
+ // Val is the value.
+ Val uint32
+}
+
+func (s Setting) String() string {
+ return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
+}
+
+// Valid reports whether the setting is valid.
+func (s Setting) Valid() error {
+ // Limits and error codes from 6.5.2 Defined SETTINGS Parameters
+ switch s.ID {
+ case SettingEnablePush:
+ if s.Val != 1 && s.Val != 0 {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ case SettingInitialWindowSize:
+ if s.Val > 1<<31-1 {
+ return ConnectionError(ErrCodeFlowControl)
+ }
+ case SettingMaxFrameSize:
+ if s.Val < 16384 || s.Val > 1<<24-1 {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ }
+ return nil
+}
+
+// A SettingID is an HTTP/2 setting as defined in
+// http://http2.github.io/http2-spec/#iana-settings
+type SettingID uint16
+
+const (
+ SettingHeaderTableSize SettingID = 0x1
+ SettingEnablePush SettingID = 0x2
+ SettingMaxConcurrentStreams SettingID = 0x3
+ SettingInitialWindowSize SettingID = 0x4
+ SettingMaxFrameSize SettingID = 0x5
+ SettingMaxHeaderListSize SettingID = 0x6
+)
+
+var settingName = map[SettingID]string{
+ SettingHeaderTableSize: "HEADER_TABLE_SIZE",
+ SettingEnablePush: "ENABLE_PUSH",
+ SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS",
+ SettingInitialWindowSize: "INITIAL_WINDOW_SIZE",
+ SettingMaxFrameSize: "MAX_FRAME_SIZE",
+ SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE",
+}
+
+func (s SettingID) String() string {
+ if v, ok := settingName[s]; ok {
+ return v
+ }
+ return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
+}
+
+var (
+ errInvalidHeaderFieldName = errors.New("http2: invalid header field name")
+ errInvalidHeaderFieldValue = errors.New("http2: invalid header field value")
+)
+
+// validWireHeaderFieldName reports whether v is a valid header field
+// name (key). See httplex.ValidHeaderName for the base rules.
+//
+// Further, http2 says:
+// "Just as in HTTP/1.x, header field names are strings of ASCII
+// characters that are compared in a case-insensitive
+// fashion. However, header field names MUST be converted to
+// lowercase prior to their encoding in HTTP/2. "
+func validWireHeaderFieldName(v string) bool {
+ if len(v) == 0 {
+ return false
+ }
+ for _, r := range v {
+ if !httplex.IsTokenRune(r) {
+ return false
+ }
+ if 'A' <= r && r <= 'Z' {
+ return false
+ }
+ }
+ return true
+}
+
+var httpCodeStringCommon = map[int]string{} // n -> strconv.Itoa(n)
+
+func init() {
+ for i := 100; i <= 999; i++ {
+ if v := http.StatusText(i); v != "" {
+ httpCodeStringCommon[i] = strconv.Itoa(i)
+ }
+ }
+}
+
+func httpCodeString(code int) string {
+ if s, ok := httpCodeStringCommon[code]; ok {
+ return s
+ }
+ return strconv.Itoa(code)
+}
+
+// from pkg io
+type stringWriter interface {
+ WriteString(s string) (n int, err error)
+}
+
+// A gate lets two goroutines coordinate their activities.
+type gate chan struct{}
+
+func (g gate) Done() { g <- struct{}{} }
+func (g gate) Wait() { <-g }
+
+// A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed).
+type closeWaiter chan struct{}
+
+// Init makes a closeWaiter usable.
+// It exists because so a closeWaiter value can be placed inside a
+// larger struct and have the Mutex and Cond's memory in the same
+// allocation.
+func (cw *closeWaiter) Init() {
+ *cw = make(chan struct{})
+}
+
+// Close marks the closeWaiter as closed and unblocks any waiters.
+func (cw closeWaiter) Close() {
+ close(cw)
+}
+
+// Wait waits for the closeWaiter to become closed.
+func (cw closeWaiter) Wait() {
+ <-cw
+}
+
+// bufferedWriter is a buffered writer that writes to w.
+// Its buffered writer is lazily allocated as needed, to minimize
+// idle memory usage with many connections.
+type bufferedWriter struct {
+ w io.Writer // immutable
+ bw *bufio.Writer // non-nil when data is buffered
+}
+
+func newBufferedWriter(w io.Writer) *bufferedWriter {
+ return &bufferedWriter{w: w}
+}
+
+var bufWriterPool = sync.Pool{
+ New: func() interface{} {
+ // TODO: pick something better? this is a bit under
+ // (3 x typical 1500 byte MTU) at least.
+ return bufio.NewWriterSize(nil, 4<<10)
+ },
+}
+
+func (w *bufferedWriter) Write(p []byte) (n int, err error) {
+ if w.bw == nil {
+ bw := bufWriterPool.Get().(*bufio.Writer)
+ bw.Reset(w.w)
+ w.bw = bw
+ }
+ return w.bw.Write(p)
+}
+
+func (w *bufferedWriter) Flush() error {
+ bw := w.bw
+ if bw == nil {
+ return nil
+ }
+ err := bw.Flush()
+ bw.Reset(nil)
+ bufWriterPool.Put(bw)
+ w.bw = nil
+ return err
+}
+
+func mustUint31(v int32) uint32 {
+ if v < 0 || v > 2147483647 {
+ panic("out of range")
+ }
+ return uint32(v)
+}
+
+// bodyAllowedForStatus reports whether a given response status code
+// permits a body. See RFC 2616, section 4.4.
+func bodyAllowedForStatus(status int) bool {
+ switch {
+ case status >= 100 && status <= 199:
+ return false
+ case status == 204:
+ return false
+ case status == 304:
+ return false
+ }
+ return true
+}
+
+type httpError struct {
+ msg string
+ timeout bool
+}
+
+func (e *httpError) Error() string { return e.msg }
+func (e *httpError) Timeout() bool { return e.timeout }
+func (e *httpError) Temporary() bool { return true }
+
+var errTimeout error = &httpError{msg: "http2: timeout awaiting response headers", timeout: true}
+
+type connectionStater interface {
+ ConnectionState() tls.ConnectionState
+}
+
+var sorterPool = sync.Pool{New: func() interface{} { return new(sorter) }}
+
+type sorter struct {
+ v []string // owned by sorter
+}
+
+func (s *sorter) Len() int { return len(s.v) }
+func (s *sorter) Swap(i, j int) { s.v[i], s.v[j] = s.v[j], s.v[i] }
+func (s *sorter) Less(i, j int) bool { return s.v[i] < s.v[j] }
+
+// Keys returns the sorted keys of h.
+//
+// The returned slice is only valid until s used again or returned to
+// its pool.
+func (s *sorter) Keys(h http.Header) []string {
+ keys := s.v[:0]
+ for k := range h {
+ keys = append(keys, k)
+ }
+ s.v = keys
+ sort.Sort(s)
+ return keys
+}
+
+func (s *sorter) SortStrings(ss []string) {
+ // Our sorter works on s.v, which sorter owners, so
+ // stash it away while we sort the user's buffer.
+ save := s.v
+ s.v = ss
+ sort.Sort(s)
+ s.v = save
+}
diff --git a/vendor/golang.org/x/net/http2/not_go16.go b/vendor/golang.org/x/net/http2/not_go16.go
new file mode 100644
index 0000000000000000000000000000000000000000..efd2e1282cf60c9b0a2ec082d147ac6ee83de06c
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/not_go16.go
@@ -0,0 +1,46 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.6
+
+package http2
+
+import (
+ "crypto/tls"
+ "net/http"
+ "time"
+)
+
+func configureTransport(t1 *http.Transport) (*Transport, error) {
+ return nil, errTransportVersion
+}
+
+func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
+ return 0
+
+}
+
+// isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec.
+func isBadCipher(cipher uint16) bool {
+ switch cipher {
+ case tls.TLS_RSA_WITH_RC4_128_SHA,
+ tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+ tls.TLS_RSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_RSA_WITH_AES_256_CBC_SHA,
+ tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA,
+ tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+ tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
+ // Reject cipher suites from Appendix A.
+ // "This list includes those cipher suites that do not
+ // offer an ephemeral key exchange and those that are
+ // based on the TLS null, stream or block cipher type"
+ return true
+ default:
+ return false
+ }
+}
diff --git a/vendor/golang.org/x/net/http2/not_go17.go b/vendor/golang.org/x/net/http2/not_go17.go
new file mode 100644
index 0000000000000000000000000000000000000000..28df0c16bf00c97fa5b99b42ed9c2e9812ad23c3
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/not_go17.go
@@ -0,0 +1,51 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.7
+
+package http2
+
+import (
+ "net"
+ "net/http"
+)
+
+type contextContext interface{}
+
+type fakeContext struct{}
+
+func (fakeContext) Done() <-chan struct{} { return nil }
+func (fakeContext) Err() error { panic("should not be called") }
+
+func reqContext(r *http.Request) fakeContext {
+ return fakeContext{}
+}
+
+func setResponseUncompressed(res *http.Response) {
+ // Nothing.
+}
+
+type clientTrace struct{}
+
+func requestTrace(*http.Request) *clientTrace { return nil }
+func traceGotConn(*http.Request, *ClientConn) {}
+func traceFirstResponseByte(*clientTrace) {}
+func traceWroteHeaders(*clientTrace) {}
+func traceWroteRequest(*clientTrace, error) {}
+func traceGot100Continue(trace *clientTrace) {}
+func traceWait100Continue(trace *clientTrace) {}
+
+func nop() {}
+
+func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) {
+ return nil, nop
+}
+
+func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) {
+ return ctx, nop
+}
+
+func requestWithContext(req *http.Request, ctx contextContext) *http.Request {
+ return req
+}
diff --git a/vendor/golang.org/x/net/http2/pipe.go b/vendor/golang.org/x/net/http2/pipe.go
new file mode 100644
index 0000000000000000000000000000000000000000..53b7a1daf630a9f9dd4895d2f3104eee4d5daad0
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/pipe.go
@@ -0,0 +1,153 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "errors"
+ "io"
+ "sync"
+)
+
+// pipe is a goroutine-safe io.Reader/io.Writer pair. It's like
+// io.Pipe except there are no PipeReader/PipeWriter halves, and the
+// underlying buffer is an interface. (io.Pipe is always unbuffered)
+type pipe struct {
+ mu sync.Mutex
+ c sync.Cond // c.L lazily initialized to &p.mu
+ b pipeBuffer
+ err error // read error once empty. non-nil means closed.
+ breakErr error // immediate read error (caller doesn't see rest of b)
+ donec chan struct{} // closed on error
+ readFn func() // optional code to run in Read before error
+}
+
+type pipeBuffer interface {
+ Len() int
+ io.Writer
+ io.Reader
+}
+
+func (p *pipe) Len() int {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ return p.b.Len()
+}
+
+// Read waits until data is available and copies bytes
+// from the buffer into p.
+func (p *pipe) Read(d []byte) (n int, err error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ if p.c.L == nil {
+ p.c.L = &p.mu
+ }
+ for {
+ if p.breakErr != nil {
+ return 0, p.breakErr
+ }
+ if p.b.Len() > 0 {
+ return p.b.Read(d)
+ }
+ if p.err != nil {
+ if p.readFn != nil {
+ p.readFn() // e.g. copy trailers
+ p.readFn = nil // not sticky like p.err
+ }
+ return 0, p.err
+ }
+ p.c.Wait()
+ }
+}
+
+var errClosedPipeWrite = errors.New("write on closed buffer")
+
+// Write copies bytes from p into the buffer and wakes a reader.
+// It is an error to write more data than the buffer can hold.
+func (p *pipe) Write(d []byte) (n int, err error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ if p.c.L == nil {
+ p.c.L = &p.mu
+ }
+ defer p.c.Signal()
+ if p.err != nil {
+ return 0, errClosedPipeWrite
+ }
+ return p.b.Write(d)
+}
+
+// CloseWithError causes the next Read (waking up a current blocked
+// Read if needed) to return the provided err after all data has been
+// read.
+//
+// The error must be non-nil.
+func (p *pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) }
+
+// BreakWithError causes the next Read (waking up a current blocked
+// Read if needed) to return the provided err immediately, without
+// waiting for unread data.
+func (p *pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) }
+
+// closeWithErrorAndCode is like CloseWithError but also sets some code to run
+// in the caller's goroutine before returning the error.
+func (p *pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) }
+
+func (p *pipe) closeWithError(dst *error, err error, fn func()) {
+ if err == nil {
+ panic("err must be non-nil")
+ }
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ if p.c.L == nil {
+ p.c.L = &p.mu
+ }
+ defer p.c.Signal()
+ if *dst != nil {
+ // Already been done.
+ return
+ }
+ p.readFn = fn
+ *dst = err
+ p.closeDoneLocked()
+}
+
+// requires p.mu be held.
+func (p *pipe) closeDoneLocked() {
+ if p.donec == nil {
+ return
+ }
+ // Close if unclosed. This isn't racy since we always
+ // hold p.mu while closing.
+ select {
+ case <-p.donec:
+ default:
+ close(p.donec)
+ }
+}
+
+// Err returns the error (if any) first set by BreakWithError or CloseWithError.
+func (p *pipe) Err() error {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ if p.breakErr != nil {
+ return p.breakErr
+ }
+ return p.err
+}
+
+// Done returns a channel which is closed if and when this pipe is closed
+// with CloseWithError.
+func (p *pipe) Done() <-chan struct{} {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+ if p.donec == nil {
+ p.donec = make(chan struct{})
+ if p.err != nil || p.breakErr != nil {
+ // Already hit an error.
+ p.closeDoneLocked()
+ }
+ }
+ return p.donec
+}
diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..8206fa79d8704df5bf9946d846d99ab1b8775e31
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/server.go
@@ -0,0 +1,2292 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// TODO: replace all <-sc.doneServing with reads from the stream's cw
+// instead, and make sure that on close we close all open
+// streams. then remove doneServing?
+
+// TODO: re-audit GOAWAY support. Consider each incoming frame type and
+// whether it should be ignored during graceful shutdown.
+
+// TODO: disconnect idle clients. GFE seems to do 4 minutes. make
+// configurable? or maximum number of idle clients and remove the
+// oldest?
+
+// TODO: turn off the serve goroutine when idle, so
+// an idle conn only has the readFrames goroutine active. (which could
+// also be optimized probably to pin less memory in crypto/tls). This
+// would involve tracking when the serve goroutine is active (atomic
+// int32 read/CAS probably?) and starting it up when frames arrive,
+// and shutting it down when all handlers exit. the occasional PING
+// packets could use time.AfterFunc to call sc.wakeStartServeLoop()
+// (which is a no-op if already running) and then queue the PING write
+// as normal. The serve loop would then exit in most cases (if no
+// Handlers running) and not be woken up again until the PING packet
+// returns.
+
+// TODO (maybe): add a mechanism for Handlers to going into
+// half-closed-local mode (rw.(io.Closer) test?) but not exit their
+// handler, and continue to be able to read from the
+// Request.Body. This would be a somewhat semantic change from HTTP/1
+// (or at least what we expose in net/http), so I'd probably want to
+// add it there too. For now, this package says that returning from
+// the Handler ServeHTTP function means you're both done reading and
+// done writing, without a way to stop just one or the other.
+
+package http2
+
+import (
+ "bufio"
+ "bytes"
+ "crypto/tls"
+ "errors"
+ "fmt"
+ "io"
+ "log"
+ "net"
+ "net/http"
+ "net/textproto"
+ "net/url"
+ "os"
+ "reflect"
+ "runtime"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/http2/hpack"
+)
+
+const (
+ prefaceTimeout = 10 * time.Second
+ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway
+ handlerChunkWriteSize = 4 << 10
+ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to?
+)
+
+var (
+ errClientDisconnected = errors.New("client disconnected")
+ errClosedBody = errors.New("body closed by handler")
+ errHandlerComplete = errors.New("http2: request body closed due to handler exiting")
+ errStreamClosed = errors.New("http2: stream closed")
+)
+
+var responseWriterStatePool = sync.Pool{
+ New: func() interface{} {
+ rws := &responseWriterState{}
+ rws.bw = bufio.NewWriterSize(chunkWriter{rws}, handlerChunkWriteSize)
+ return rws
+ },
+}
+
+// Test hooks.
+var (
+ testHookOnConn func()
+ testHookGetServerConn func(*serverConn)
+ testHookOnPanicMu *sync.Mutex // nil except in tests
+ testHookOnPanic func(sc *serverConn, panicVal interface{}) (rePanic bool)
+)
+
+// Server is an HTTP/2 server.
+type Server struct {
+ // MaxHandlers limits the number of http.Handler ServeHTTP goroutines
+ // which may run at a time over all connections.
+ // Negative or zero no limit.
+ // TODO: implement
+ MaxHandlers int
+
+ // MaxConcurrentStreams optionally specifies the number of
+ // concurrent streams that each client may have open at a
+ // time. This is unrelated to the number of http.Handler goroutines
+ // which may be active globally, which is MaxHandlers.
+ // If zero, MaxConcurrentStreams defaults to at least 100, per
+ // the HTTP/2 spec's recommendations.
+ MaxConcurrentStreams uint32
+
+ // MaxReadFrameSize optionally specifies the largest frame
+ // this server is willing to read. A valid value is between
+ // 16k and 16M, inclusive. If zero or otherwise invalid, a
+ // default value is used.
+ MaxReadFrameSize uint32
+
+ // PermitProhibitedCipherSuites, if true, permits the use of
+ // cipher suites prohibited by the HTTP/2 spec.
+ PermitProhibitedCipherSuites bool
+}
+
+func (s *Server) maxReadFrameSize() uint32 {
+ if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize {
+ return v
+ }
+ return defaultMaxReadFrameSize
+}
+
+func (s *Server) maxConcurrentStreams() uint32 {
+ if v := s.MaxConcurrentStreams; v > 0 {
+ return v
+ }
+ return defaultMaxStreams
+}
+
+// ConfigureServer adds HTTP/2 support to a net/http Server.
+//
+// The configuration conf may be nil.
+//
+// ConfigureServer must be called before s begins serving.
+func ConfigureServer(s *http.Server, conf *Server) error {
+ if conf == nil {
+ conf = new(Server)
+ }
+
+ if s.TLSConfig == nil {
+ s.TLSConfig = new(tls.Config)
+ } else if s.TLSConfig.CipherSuites != nil {
+ // If they already provided a CipherSuite list, return
+ // an error if it has a bad order or is missing
+ // ECDHE_RSA_WITH_AES_128_GCM_SHA256.
+ const requiredCipher = tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
+ haveRequired := false
+ sawBad := false
+ for i, cs := range s.TLSConfig.CipherSuites {
+ if cs == requiredCipher {
+ haveRequired = true
+ }
+ if isBadCipher(cs) {
+ sawBad = true
+ } else if sawBad {
+ return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
+ }
+ }
+ if !haveRequired {
+ return fmt.Errorf("http2: TLSConfig.CipherSuites is missing HTTP/2-required TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256")
+ }
+ }
+
+ // Note: not setting MinVersion to tls.VersionTLS12,
+ // as we don't want to interfere with HTTP/1.1 traffic
+ // on the user's server. We enforce TLS 1.2 later once
+ // we accept a connection. Ideally this should be done
+ // during next-proto selection, but using TLS <1.2 with
+ // HTTP/2 is still the client's bug.
+
+ s.TLSConfig.PreferServerCipherSuites = true
+
+ haveNPN := false
+ for _, p := range s.TLSConfig.NextProtos {
+ if p == NextProtoTLS {
+ haveNPN = true
+ break
+ }
+ }
+ if !haveNPN {
+ s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, NextProtoTLS)
+ }
+ // h2-14 is temporary (as of 2015-03-05) while we wait for all browsers
+ // to switch to "h2".
+ s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, "h2-14")
+
+ if s.TLSNextProto == nil {
+ s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){}
+ }
+ protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) {
+ if testHookOnConn != nil {
+ testHookOnConn()
+ }
+ conf.ServeConn(c, &ServeConnOpts{
+ Handler: h,
+ BaseConfig: hs,
+ })
+ }
+ s.TLSNextProto[NextProtoTLS] = protoHandler
+ s.TLSNextProto["h2-14"] = protoHandler // temporary; see above.
+ return nil
+}
+
+// ServeConnOpts are options for the Server.ServeConn method.
+type ServeConnOpts struct {
+ // BaseConfig optionally sets the base configuration
+ // for values. If nil, defaults are used.
+ BaseConfig *http.Server
+
+ // Handler specifies which handler to use for processing
+ // requests. If nil, BaseConfig.Handler is used. If BaseConfig
+ // or BaseConfig.Handler is nil, http.DefaultServeMux is used.
+ Handler http.Handler
+}
+
+func (o *ServeConnOpts) baseConfig() *http.Server {
+ if o != nil && o.BaseConfig != nil {
+ return o.BaseConfig
+ }
+ return new(http.Server)
+}
+
+func (o *ServeConnOpts) handler() http.Handler {
+ if o != nil {
+ if o.Handler != nil {
+ return o.Handler
+ }
+ if o.BaseConfig != nil && o.BaseConfig.Handler != nil {
+ return o.BaseConfig.Handler
+ }
+ }
+ return http.DefaultServeMux
+}
+
+// ServeConn serves HTTP/2 requests on the provided connection and
+// blocks until the connection is no longer readable.
+//
+// ServeConn starts speaking HTTP/2 assuming that c has not had any
+// reads or writes. It writes its initial settings frame and expects
+// to be able to read the preface and settings frame from the
+// client. If c has a ConnectionState method like a *tls.Conn, the
+// ConnectionState is used to verify the TLS ciphersuite and to set
+// the Request.TLS field in Handlers.
+//
+// ServeConn does not support h2c by itself. Any h2c support must be
+// implemented in terms of providing a suitably-behaving net.Conn.
+//
+// The opts parameter is optional. If nil, default values are used.
+func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts) {
+ baseCtx, cancel := serverConnBaseContext(c, opts)
+ defer cancel()
+
+ sc := &serverConn{
+ srv: s,
+ hs: opts.baseConfig(),
+ conn: c,
+ baseCtx: baseCtx,
+ remoteAddrStr: c.RemoteAddr().String(),
+ bw: newBufferedWriter(c),
+ handler: opts.handler(),
+ streams: make(map[uint32]*stream),
+ readFrameCh: make(chan readFrameResult),
+ wantWriteFrameCh: make(chan frameWriteMsg, 8),
+ wroteFrameCh: make(chan frameWriteResult, 1), // buffered; one send in writeFrameAsync
+ bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way
+ doneServing: make(chan struct{}),
+ advMaxStreams: s.maxConcurrentStreams(),
+ writeSched: writeScheduler{
+ maxFrameSize: initialMaxFrameSize,
+ },
+ initialWindowSize: initialWindowSize,
+ headerTableSize: initialHeaderTableSize,
+ serveG: newGoroutineLock(),
+ pushEnabled: true,
+ }
+
+ sc.flow.add(initialWindowSize)
+ sc.inflow.add(initialWindowSize)
+ sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf)
+
+ fr := NewFramer(sc.bw, c)
+ fr.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil)
+ fr.MaxHeaderListSize = sc.maxHeaderListSize()
+ fr.SetMaxReadFrameSize(s.maxReadFrameSize())
+ sc.framer = fr
+
+ if tc, ok := c.(connectionStater); ok {
+ sc.tlsState = new(tls.ConnectionState)
+ *sc.tlsState = tc.ConnectionState()
+ // 9.2 Use of TLS Features
+ // An implementation of HTTP/2 over TLS MUST use TLS
+ // 1.2 or higher with the restrictions on feature set
+ // and cipher suite described in this section. Due to
+ // implementation limitations, it might not be
+ // possible to fail TLS negotiation. An endpoint MUST
+ // immediately terminate an HTTP/2 connection that
+ // does not meet the TLS requirements described in
+ // this section with a connection error (Section
+ // 5.4.1) of type INADEQUATE_SECURITY.
+ if sc.tlsState.Version < tls.VersionTLS12 {
+ sc.rejectConn(ErrCodeInadequateSecurity, "TLS version too low")
+ return
+ }
+
+ if sc.tlsState.ServerName == "" {
+ // Client must use SNI, but we don't enforce that anymore,
+ // since it was causing problems when connecting to bare IP
+ // addresses during development.
+ //
+ // TODO: optionally enforce? Or enforce at the time we receive
+ // a new request, and verify the the ServerName matches the :authority?
+ // But that precludes proxy situations, perhaps.
+ //
+ // So for now, do nothing here again.
+ }
+
+ if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) {
+ // "Endpoints MAY choose to generate a connection error
+ // (Section 5.4.1) of type INADEQUATE_SECURITY if one of
+ // the prohibited cipher suites are negotiated."
+ //
+ // We choose that. In my opinion, the spec is weak
+ // here. It also says both parties must support at least
+ // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 so there's no
+ // excuses here. If we really must, we could allow an
+ // "AllowInsecureWeakCiphers" option on the server later.
+ // Let's see how it plays out first.
+ sc.rejectConn(ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
+ return
+ }
+ }
+
+ if hook := testHookGetServerConn; hook != nil {
+ hook(sc)
+ }
+ sc.serve()
+}
+
+func (sc *serverConn) rejectConn(err ErrCode, debug string) {
+ sc.vlogf("http2: server rejecting conn: %v, %s", err, debug)
+ // ignoring errors. hanging up anyway.
+ sc.framer.WriteGoAway(0, err, []byte(debug))
+ sc.bw.Flush()
+ sc.conn.Close()
+}
+
+type serverConn struct {
+ // Immutable:
+ srv *Server
+ hs *http.Server
+ conn net.Conn
+ bw *bufferedWriter // writing to conn
+ handler http.Handler
+ baseCtx contextContext
+ framer *Framer
+ doneServing chan struct{} // closed when serverConn.serve ends
+ readFrameCh chan readFrameResult // written by serverConn.readFrames
+ wantWriteFrameCh chan frameWriteMsg // from handlers -> serve
+ wroteFrameCh chan frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes
+ bodyReadCh chan bodyReadMsg // from handlers -> serve
+ testHookCh chan func(int) // code to run on the serve loop
+ flow flow // conn-wide (not stream-specific) outbound flow control
+ inflow flow // conn-wide inbound flow control
+ tlsState *tls.ConnectionState // shared by all handlers, like net/http
+ remoteAddrStr string
+
+ // Everything following is owned by the serve loop; use serveG.check():
+ serveG goroutineLock // used to verify funcs are on serve()
+ pushEnabled bool
+ sawFirstSettings bool // got the initial SETTINGS frame after the preface
+ needToSendSettingsAck bool
+ unackedSettings int // how many SETTINGS have we sent without ACKs?
+ clientMaxStreams uint32 // SETTINGS_MAX_CONCURRENT_STREAMS from client (our PUSH_PROMISE limit)
+ advMaxStreams uint32 // our SETTINGS_MAX_CONCURRENT_STREAMS advertised the client
+ curOpenStreams uint32 // client's number of open streams
+ maxStreamID uint32 // max ever seen
+ streams map[uint32]*stream
+ initialWindowSize int32
+ headerTableSize uint32
+ peerMaxHeaderListSize uint32 // zero means unknown (default)
+ canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case
+ writingFrame bool // started write goroutine but haven't heard back on wroteFrameCh
+ needsFrameFlush bool // last frame write wasn't a flush
+ writeSched writeScheduler
+ inGoAway bool // we've started to or sent GOAWAY
+ needToSendGoAway bool // we need to schedule a GOAWAY frame write
+ goAwayCode ErrCode
+ shutdownTimerCh <-chan time.Time // nil until used
+ shutdownTimer *time.Timer // nil until used
+ freeRequestBodyBuf []byte // if non-nil, a free initialWindowSize buffer for getRequestBodyBuf
+
+ // Owned by the writeFrameAsync goroutine:
+ headerWriteBuf bytes.Buffer
+ hpackEncoder *hpack.Encoder
+}
+
+func (sc *serverConn) maxHeaderListSize() uint32 {
+ n := sc.hs.MaxHeaderBytes
+ if n <= 0 {
+ n = http.DefaultMaxHeaderBytes
+ }
+ // http2's count is in a slightly different unit and includes 32 bytes per pair.
+ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers.
+ const perFieldOverhead = 32 // per http2 spec
+ const typicalHeaders = 10 // conservative
+ return uint32(n + typicalHeaders*perFieldOverhead)
+}
+
+// stream represents a stream. This is the minimal metadata needed by
+// the serve goroutine. Most of the actual stream state is owned by
+// the http.Handler's goroutine in the responseWriter. Because the
+// responseWriter's responseWriterState is recycled at the end of a
+// handler, this struct intentionally has no pointer to the
+// *responseWriter{,State} itself, as the Handler ending nils out the
+// responseWriter's state field.
+type stream struct {
+ // immutable:
+ sc *serverConn
+ id uint32
+ body *pipe // non-nil if expecting DATA frames
+ cw closeWaiter // closed wait stream transitions to closed state
+ ctx contextContext
+ cancelCtx func()
+
+ // owned by serverConn's serve loop:
+ bodyBytes int64 // body bytes seen so far
+ declBodyBytes int64 // or -1 if undeclared
+ flow flow // limits writing from Handler to client
+ inflow flow // what the client is allowed to POST/etc to us
+ parent *stream // or nil
+ numTrailerValues int64
+ weight uint8
+ state streamState
+ sentReset bool // only true once detached from streams map
+ gotReset bool // only true once detacted from streams map
+ gotTrailerHeader bool // HEADER frame for trailers was seen
+ wroteHeaders bool // whether we wrote headers (not status 100)
+ reqBuf []byte
+
+ trailer http.Header // accumulated trailers
+ reqTrailer http.Header // handler's Request.Trailer
+}
+
+func (sc *serverConn) Framer() *Framer { return sc.framer }
+func (sc *serverConn) CloseConn() error { return sc.conn.Close() }
+func (sc *serverConn) Flush() error { return sc.bw.Flush() }
+func (sc *serverConn) HeaderEncoder() (*hpack.Encoder, *bytes.Buffer) {
+ return sc.hpackEncoder, &sc.headerWriteBuf
+}
+
+func (sc *serverConn) state(streamID uint32) (streamState, *stream) {
+ sc.serveG.check()
+ // http://http2.github.io/http2-spec/#rfc.section.5.1
+ if st, ok := sc.streams[streamID]; ok {
+ return st.state, st
+ }
+ // "The first use of a new stream identifier implicitly closes all
+ // streams in the "idle" state that might have been initiated by
+ // that peer with a lower-valued stream identifier. For example, if
+ // a client sends a HEADERS frame on stream 7 without ever sending a
+ // frame on stream 5, then stream 5 transitions to the "closed"
+ // state when the first frame for stream 7 is sent or received."
+ if streamID <= sc.maxStreamID {
+ return stateClosed, nil
+ }
+ return stateIdle, nil
+}
+
+// setConnState calls the net/http ConnState hook for this connection, if configured.
+// Note that the net/http package does StateNew and StateClosed for us.
+// There is currently no plan for StateHijacked or hijacking HTTP/2 connections.
+func (sc *serverConn) setConnState(state http.ConnState) {
+ if sc.hs.ConnState != nil {
+ sc.hs.ConnState(sc.conn, state)
+ }
+}
+
+func (sc *serverConn) vlogf(format string, args ...interface{}) {
+ if VerboseLogs {
+ sc.logf(format, args...)
+ }
+}
+
+func (sc *serverConn) logf(format string, args ...interface{}) {
+ if lg := sc.hs.ErrorLog; lg != nil {
+ lg.Printf(format, args...)
+ } else {
+ log.Printf(format, args...)
+ }
+}
+
+// errno returns v's underlying uintptr, else 0.
+//
+// TODO: remove this helper function once http2 can use build
+// tags. See comment in isClosedConnError.
+func errno(v error) uintptr {
+ if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {
+ return uintptr(rv.Uint())
+ }
+ return 0
+}
+
+// isClosedConnError reports whether err is an error from use of a closed
+// network connection.
+func isClosedConnError(err error) bool {
+ if err == nil {
+ return false
+ }
+
+ // TODO: remove this string search and be more like the Windows
+ // case below. That might involve modifying the standard library
+ // to return better error types.
+ str := err.Error()
+ if strings.Contains(str, "use of closed network connection") {
+ return true
+ }
+
+ // TODO(bradfitz): x/tools/cmd/bundle doesn't really support
+ // build tags, so I can't make an http2_windows.go file with
+ // Windows-specific stuff. Fix that and move this, once we
+ // have a way to bundle this into std's net/http somehow.
+ if runtime.GOOS == "windows" {
+ if oe, ok := err.(*net.OpError); ok && oe.Op == "read" {
+ if se, ok := oe.Err.(*os.SyscallError); ok && se.Syscall == "wsarecv" {
+ const WSAECONNABORTED = 10053
+ const WSAECONNRESET = 10054
+ if n := errno(se.Err); n == WSAECONNRESET || n == WSAECONNABORTED {
+ return true
+ }
+ }
+ }
+ }
+ return false
+}
+
+func (sc *serverConn) condlogf(err error, format string, args ...interface{}) {
+ if err == nil {
+ return
+ }
+ if err == io.EOF || err == io.ErrUnexpectedEOF || isClosedConnError(err) {
+ // Boring, expected errors.
+ sc.vlogf(format, args...)
+ } else {
+ sc.logf(format, args...)
+ }
+}
+
+func (sc *serverConn) canonicalHeader(v string) string {
+ sc.serveG.check()
+ cv, ok := commonCanonHeader[v]
+ if ok {
+ return cv
+ }
+ cv, ok = sc.canonHeader[v]
+ if ok {
+ return cv
+ }
+ if sc.canonHeader == nil {
+ sc.canonHeader = make(map[string]string)
+ }
+ cv = http.CanonicalHeaderKey(v)
+ sc.canonHeader[v] = cv
+ return cv
+}
+
+type readFrameResult struct {
+ f Frame // valid until readMore is called
+ err error
+
+ // readMore should be called once the consumer no longer needs or
+ // retains f. After readMore, f is invalid and more frames can be
+ // read.
+ readMore func()
+}
+
+// readFrames is the loop that reads incoming frames.
+// It takes care to only read one frame at a time, blocking until the
+// consumer is done with the frame.
+// It's run on its own goroutine.
+func (sc *serverConn) readFrames() {
+ gate := make(gate)
+ gateDone := gate.Done
+ for {
+ f, err := sc.framer.ReadFrame()
+ select {
+ case sc.readFrameCh <- readFrameResult{f, err, gateDone}:
+ case <-sc.doneServing:
+ return
+ }
+ select {
+ case <-gate:
+ case <-sc.doneServing:
+ return
+ }
+ if terminalReadFrameError(err) {
+ return
+ }
+ }
+}
+
+// frameWriteResult is the message passed from writeFrameAsync to the serve goroutine.
+type frameWriteResult struct {
+ wm frameWriteMsg // what was written (or attempted)
+ err error // result of the writeFrame call
+}
+
+// writeFrameAsync runs in its own goroutine and writes a single frame
+// and then reports when it's done.
+// At most one goroutine can be running writeFrameAsync at a time per
+// serverConn.
+func (sc *serverConn) writeFrameAsync(wm frameWriteMsg) {
+ err := wm.write.writeFrame(sc)
+ sc.wroteFrameCh <- frameWriteResult{wm, err}
+}
+
+func (sc *serverConn) closeAllStreamsOnConnClose() {
+ sc.serveG.check()
+ for _, st := range sc.streams {
+ sc.closeStream(st, errClientDisconnected)
+ }
+}
+
+func (sc *serverConn) stopShutdownTimer() {
+ sc.serveG.check()
+ if t := sc.shutdownTimer; t != nil {
+ t.Stop()
+ }
+}
+
+func (sc *serverConn) notePanic() {
+ // Note: this is for serverConn.serve panicking, not http.Handler code.
+ if testHookOnPanicMu != nil {
+ testHookOnPanicMu.Lock()
+ defer testHookOnPanicMu.Unlock()
+ }
+ if testHookOnPanic != nil {
+ if e := recover(); e != nil {
+ if testHookOnPanic(sc, e) {
+ panic(e)
+ }
+ }
+ }
+}
+
+func (sc *serverConn) serve() {
+ sc.serveG.check()
+ defer sc.notePanic()
+ defer sc.conn.Close()
+ defer sc.closeAllStreamsOnConnClose()
+ defer sc.stopShutdownTimer()
+ defer close(sc.doneServing) // unblocks handlers trying to send
+
+ if VerboseLogs {
+ sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs)
+ }
+
+ sc.writeFrame(frameWriteMsg{
+ write: writeSettings{
+ {SettingMaxFrameSize, sc.srv.maxReadFrameSize()},
+ {SettingMaxConcurrentStreams, sc.advMaxStreams},
+ {SettingMaxHeaderListSize, sc.maxHeaderListSize()},
+
+ // TODO: more actual settings, notably
+ // SettingInitialWindowSize, but then we also
+ // want to bump up the conn window size the
+ // same amount here right after the settings
+ },
+ })
+ sc.unackedSettings++
+
+ if err := sc.readPreface(); err != nil {
+ sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err)
+ return
+ }
+ // Now that we've got the preface, get us out of the
+ // "StateNew" state. We can't go directly to idle, though.
+ // Active means we read some data and anticipate a request. We'll
+ // do another Active when we get a HEADERS frame.
+ sc.setConnState(http.StateActive)
+ sc.setConnState(http.StateIdle)
+
+ go sc.readFrames() // closed by defer sc.conn.Close above
+
+ settingsTimer := time.NewTimer(firstSettingsTimeout)
+ loopNum := 0
+ for {
+ loopNum++
+ select {
+ case wm := <-sc.wantWriteFrameCh:
+ sc.writeFrame(wm)
+ case res := <-sc.wroteFrameCh:
+ sc.wroteFrame(res)
+ case res := <-sc.readFrameCh:
+ if !sc.processFrameFromReader(res) {
+ return
+ }
+ res.readMore()
+ if settingsTimer.C != nil {
+ settingsTimer.Stop()
+ settingsTimer.C = nil
+ }
+ case m := <-sc.bodyReadCh:
+ sc.noteBodyRead(m.st, m.n)
+ case <-settingsTimer.C:
+ sc.logf("timeout waiting for SETTINGS frames from %v", sc.conn.RemoteAddr())
+ return
+ case <-sc.shutdownTimerCh:
+ sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr())
+ return
+ case fn := <-sc.testHookCh:
+ fn(loopNum)
+ }
+ }
+}
+
+// readPreface reads the ClientPreface greeting from the peer
+// or returns an error on timeout or an invalid greeting.
+func (sc *serverConn) readPreface() error {
+ errc := make(chan error, 1)
+ go func() {
+ // Read the client preface
+ buf := make([]byte, len(ClientPreface))
+ if _, err := io.ReadFull(sc.conn, buf); err != nil {
+ errc <- err
+ } else if !bytes.Equal(buf, clientPreface) {
+ errc <- fmt.Errorf("bogus greeting %q", buf)
+ } else {
+ errc <- nil
+ }
+ }()
+ timer := time.NewTimer(prefaceTimeout) // TODO: configurable on *Server?
+ defer timer.Stop()
+ select {
+ case <-timer.C:
+ return errors.New("timeout waiting for client preface")
+ case err := <-errc:
+ if err == nil {
+ if VerboseLogs {
+ sc.vlogf("http2: server: client %v said hello", sc.conn.RemoteAddr())
+ }
+ }
+ return err
+ }
+}
+
+var errChanPool = sync.Pool{
+ New: func() interface{} { return make(chan error, 1) },
+}
+
+var writeDataPool = sync.Pool{
+ New: func() interface{} { return new(writeData) },
+}
+
+// writeDataFromHandler writes DATA response frames from a handler on
+// the given stream.
+func (sc *serverConn) writeDataFromHandler(stream *stream, data []byte, endStream bool) error {
+ ch := errChanPool.Get().(chan error)
+ writeArg := writeDataPool.Get().(*writeData)
+ *writeArg = writeData{stream.id, data, endStream}
+ err := sc.writeFrameFromHandler(frameWriteMsg{
+ write: writeArg,
+ stream: stream,
+ done: ch,
+ })
+ if err != nil {
+ return err
+ }
+ var frameWriteDone bool // the frame write is done (successfully or not)
+ select {
+ case err = <-ch:
+ frameWriteDone = true
+ case <-sc.doneServing:
+ return errClientDisconnected
+ case <-stream.cw:
+ // If both ch and stream.cw were ready (as might
+ // happen on the final Write after an http.Handler
+ // ends), prefer the write result. Otherwise this
+ // might just be us successfully closing the stream.
+ // The writeFrameAsync and serve goroutines guarantee
+ // that the ch send will happen before the stream.cw
+ // close.
+ select {
+ case err = <-ch:
+ frameWriteDone = true
+ default:
+ return errStreamClosed
+ }
+ }
+ errChanPool.Put(ch)
+ if frameWriteDone {
+ writeDataPool.Put(writeArg)
+ }
+ return err
+}
+
+// writeFrameFromHandler sends wm to sc.wantWriteFrameCh, but aborts
+// if the connection has gone away.
+//
+// This must not be run from the serve goroutine itself, else it might
+// deadlock writing to sc.wantWriteFrameCh (which is only mildly
+// buffered and is read by serve itself). If you're on the serve
+// goroutine, call writeFrame instead.
+func (sc *serverConn) writeFrameFromHandler(wm frameWriteMsg) error {
+ sc.serveG.checkNotOn() // NOT
+ select {
+ case sc.wantWriteFrameCh <- wm:
+ return nil
+ case <-sc.doneServing:
+ // Serve loop is gone.
+ // Client has closed their connection to the server.
+ return errClientDisconnected
+ }
+}
+
+// writeFrame schedules a frame to write and sends it if there's nothing
+// already being written.
+//
+// There is no pushback here (the serve goroutine never blocks). It's
+// the http.Handlers that block, waiting for their previous frames to
+// make it onto the wire
+//
+// If you're not on the serve goroutine, use writeFrameFromHandler instead.
+func (sc *serverConn) writeFrame(wm frameWriteMsg) {
+ sc.serveG.check()
+
+ var ignoreWrite bool
+
+ // Don't send a 100-continue response if we've already sent headers.
+ // See golang.org/issue/14030.
+ switch wm.write.(type) {
+ case *writeResHeaders:
+ wm.stream.wroteHeaders = true
+ case write100ContinueHeadersFrame:
+ if wm.stream.wroteHeaders {
+ ignoreWrite = true
+ }
+ }
+
+ if !ignoreWrite {
+ sc.writeSched.add(wm)
+ }
+ sc.scheduleFrameWrite()
+}
+
+// startFrameWrite starts a goroutine to write wm (in a separate
+// goroutine since that might block on the network), and updates the
+// serve goroutine's state about the world, updated from info in wm.
+func (sc *serverConn) startFrameWrite(wm frameWriteMsg) {
+ sc.serveG.check()
+ if sc.writingFrame {
+ panic("internal error: can only be writing one frame at a time")
+ }
+
+ st := wm.stream
+ if st != nil {
+ switch st.state {
+ case stateHalfClosedLocal:
+ panic("internal error: attempt to send frame on half-closed-local stream")
+ case stateClosed:
+ if st.sentReset || st.gotReset {
+ // Skip this frame.
+ sc.scheduleFrameWrite()
+ return
+ }
+ panic(fmt.Sprintf("internal error: attempt to send a write %v on a closed stream", wm))
+ }
+ }
+
+ sc.writingFrame = true
+ sc.needsFrameFlush = true
+ go sc.writeFrameAsync(wm)
+}
+
+// errHandlerPanicked is the error given to any callers blocked in a read from
+// Request.Body when the main goroutine panics. Since most handlers read in the
+// the main ServeHTTP goroutine, this will show up rarely.
+var errHandlerPanicked = errors.New("http2: handler panicked")
+
+// wroteFrame is called on the serve goroutine with the result of
+// whatever happened on writeFrameAsync.
+func (sc *serverConn) wroteFrame(res frameWriteResult) {
+ sc.serveG.check()
+ if !sc.writingFrame {
+ panic("internal error: expected to be already writing a frame")
+ }
+ sc.writingFrame = false
+
+ wm := res.wm
+ st := wm.stream
+
+ closeStream := endsStream(wm.write)
+
+ if _, ok := wm.write.(handlerPanicRST); ok {
+ sc.closeStream(st, errHandlerPanicked)
+ }
+
+ // Reply (if requested) to the blocked ServeHTTP goroutine.
+ if ch := wm.done; ch != nil {
+ select {
+ case ch <- res.err:
+ default:
+ panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wm.write))
+ }
+ }
+ wm.write = nil // prevent use (assume it's tainted after wm.done send)
+
+ if closeStream {
+ if st == nil {
+ panic("internal error: expecting non-nil stream")
+ }
+ switch st.state {
+ case stateOpen:
+ // Here we would go to stateHalfClosedLocal in
+ // theory, but since our handler is done and
+ // the net/http package provides no mechanism
+ // for finishing writing to a ResponseWriter
+ // while still reading data (see possible TODO
+ // at top of this file), we go into closed
+ // state here anyway, after telling the peer
+ // we're hanging up on them.
+ st.state = stateHalfClosedLocal // won't last long, but necessary for closeStream via resetStream
+ errCancel := streamError(st.id, ErrCodeCancel)
+ sc.resetStream(errCancel)
+ case stateHalfClosedRemote:
+ sc.closeStream(st, errHandlerComplete)
+ }
+ }
+
+ sc.scheduleFrameWrite()
+}
+
+// scheduleFrameWrite tickles the frame writing scheduler.
+//
+// If a frame is already being written, nothing happens. This will be called again
+// when the frame is done being written.
+//
+// If a frame isn't being written we need to send one, the best frame
+// to send is selected, preferring first things that aren't
+// stream-specific (e.g. ACKing settings), and then finding the
+// highest priority stream.
+//
+// If a frame isn't being written and there's nothing else to send, we
+// flush the write buffer.
+func (sc *serverConn) scheduleFrameWrite() {
+ sc.serveG.check()
+ if sc.writingFrame {
+ return
+ }
+ if sc.needToSendGoAway {
+ sc.needToSendGoAway = false
+ sc.startFrameWrite(frameWriteMsg{
+ write: &writeGoAway{
+ maxStreamID: sc.maxStreamID,
+ code: sc.goAwayCode,
+ },
+ })
+ return
+ }
+ if sc.needToSendSettingsAck {
+ sc.needToSendSettingsAck = false
+ sc.startFrameWrite(frameWriteMsg{write: writeSettingsAck{}})
+ return
+ }
+ if !sc.inGoAway {
+ if wm, ok := sc.writeSched.take(); ok {
+ sc.startFrameWrite(wm)
+ return
+ }
+ }
+ if sc.needsFrameFlush {
+ sc.startFrameWrite(frameWriteMsg{write: flushFrameWriter{}})
+ sc.needsFrameFlush = false // after startFrameWrite, since it sets this true
+ return
+ }
+}
+
+func (sc *serverConn) goAway(code ErrCode) {
+ sc.serveG.check()
+ if sc.inGoAway {
+ return
+ }
+ if code != ErrCodeNo {
+ sc.shutDownIn(250 * time.Millisecond)
+ } else {
+ // TODO: configurable
+ sc.shutDownIn(1 * time.Second)
+ }
+ sc.inGoAway = true
+ sc.needToSendGoAway = true
+ sc.goAwayCode = code
+ sc.scheduleFrameWrite()
+}
+
+func (sc *serverConn) shutDownIn(d time.Duration) {
+ sc.serveG.check()
+ sc.shutdownTimer = time.NewTimer(d)
+ sc.shutdownTimerCh = sc.shutdownTimer.C
+}
+
+func (sc *serverConn) resetStream(se StreamError) {
+ sc.serveG.check()
+ sc.writeFrame(frameWriteMsg{write: se})
+ if st, ok := sc.streams[se.StreamID]; ok {
+ st.sentReset = true
+ sc.closeStream(st, se)
+ }
+}
+
+// processFrameFromReader processes the serve loop's read from readFrameCh from the
+// frame-reading goroutine.
+// processFrameFromReader returns whether the connection should be kept open.
+func (sc *serverConn) processFrameFromReader(res readFrameResult) bool {
+ sc.serveG.check()
+ err := res.err
+ if err != nil {
+ if err == ErrFrameTooLarge {
+ sc.goAway(ErrCodeFrameSize)
+ return true // goAway will close the loop
+ }
+ clientGone := err == io.EOF || err == io.ErrUnexpectedEOF || isClosedConnError(err)
+ if clientGone {
+ // TODO: could we also get into this state if
+ // the peer does a half close
+ // (e.g. CloseWrite) because they're done
+ // sending frames but they're still wanting
+ // our open replies? Investigate.
+ // TODO: add CloseWrite to crypto/tls.Conn first
+ // so we have a way to test this? I suppose
+ // just for testing we could have a non-TLS mode.
+ return false
+ }
+ } else {
+ f := res.f
+ if VerboseLogs {
+ sc.vlogf("http2: server read frame %v", summarizeFrame(f))
+ }
+ err = sc.processFrame(f)
+ if err == nil {
+ return true
+ }
+ }
+
+ switch ev := err.(type) {
+ case StreamError:
+ sc.resetStream(ev)
+ return true
+ case goAwayFlowError:
+ sc.goAway(ErrCodeFlowControl)
+ return true
+ case ConnectionError:
+ sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev)
+ sc.goAway(ErrCode(ev))
+ return true // goAway will handle shutdown
+ default:
+ if res.err != nil {
+ sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
+ } else {
+ sc.logf("http2: server closing client connection: %v", err)
+ }
+ return false
+ }
+}
+
+func (sc *serverConn) processFrame(f Frame) error {
+ sc.serveG.check()
+
+ // First frame received must be SETTINGS.
+ if !sc.sawFirstSettings {
+ if _, ok := f.(*SettingsFrame); !ok {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ sc.sawFirstSettings = true
+ }
+
+ switch f := f.(type) {
+ case *SettingsFrame:
+ return sc.processSettings(f)
+ case *MetaHeadersFrame:
+ return sc.processHeaders(f)
+ case *WindowUpdateFrame:
+ return sc.processWindowUpdate(f)
+ case *PingFrame:
+ return sc.processPing(f)
+ case *DataFrame:
+ return sc.processData(f)
+ case *RSTStreamFrame:
+ return sc.processResetStream(f)
+ case *PriorityFrame:
+ return sc.processPriority(f)
+ case *PushPromiseFrame:
+ // A client cannot push. Thus, servers MUST treat the receipt of a PUSH_PROMISE
+ // frame as a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
+ return ConnectionError(ErrCodeProtocol)
+ default:
+ sc.vlogf("http2: server ignoring frame: %v", f.Header())
+ return nil
+ }
+}
+
+func (sc *serverConn) processPing(f *PingFrame) error {
+ sc.serveG.check()
+ if f.IsAck() {
+ // 6.7 PING: " An endpoint MUST NOT respond to PING frames
+ // containing this flag."
+ return nil
+ }
+ if f.StreamID != 0 {
+ // "PING frames are not associated with any individual
+ // stream. If a PING frame is received with a stream
+ // identifier field value other than 0x0, the recipient MUST
+ // respond with a connection error (Section 5.4.1) of type
+ // PROTOCOL_ERROR."
+ return ConnectionError(ErrCodeProtocol)
+ }
+ sc.writeFrame(frameWriteMsg{write: writePingAck{f}})
+ return nil
+}
+
+func (sc *serverConn) processWindowUpdate(f *WindowUpdateFrame) error {
+ sc.serveG.check()
+ switch {
+ case f.StreamID != 0: // stream-level flow control
+ st := sc.streams[f.StreamID]
+ if st == nil {
+ // "WINDOW_UPDATE can be sent by a peer that has sent a
+ // frame bearing the END_STREAM flag. This means that a
+ // receiver could receive a WINDOW_UPDATE frame on a "half
+ // closed (remote)" or "closed" stream. A receiver MUST
+ // NOT treat this as an error, see Section 5.1."
+ return nil
+ }
+ if !st.flow.add(int32(f.Increment)) {
+ return streamError(f.StreamID, ErrCodeFlowControl)
+ }
+ default: // connection-level flow control
+ if !sc.flow.add(int32(f.Increment)) {
+ return goAwayFlowError{}
+ }
+ }
+ sc.scheduleFrameWrite()
+ return nil
+}
+
+func (sc *serverConn) processResetStream(f *RSTStreamFrame) error {
+ sc.serveG.check()
+
+ state, st := sc.state(f.StreamID)
+ if state == stateIdle {
+ // 6.4 "RST_STREAM frames MUST NOT be sent for a
+ // stream in the "idle" state. If a RST_STREAM frame
+ // identifying an idle stream is received, the
+ // recipient MUST treat this as a connection error
+ // (Section 5.4.1) of type PROTOCOL_ERROR.
+ return ConnectionError(ErrCodeProtocol)
+ }
+ if st != nil {
+ st.gotReset = true
+ st.cancelCtx()
+ sc.closeStream(st, streamError(f.StreamID, f.ErrCode))
+ }
+ return nil
+}
+
+func (sc *serverConn) closeStream(st *stream, err error) {
+ sc.serveG.check()
+ if st.state == stateIdle || st.state == stateClosed {
+ panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
+ }
+ st.state = stateClosed
+ sc.curOpenStreams--
+ if sc.curOpenStreams == 0 {
+ sc.setConnState(http.StateIdle)
+ }
+ delete(sc.streams, st.id)
+ if p := st.body; p != nil {
+ // Return any buffered unread bytes worth of conn-level flow control.
+ // See golang.org/issue/16481
+ sc.sendWindowUpdate(nil, p.Len())
+
+ p.CloseWithError(err)
+ }
+ st.cw.Close() // signals Handler's CloseNotifier, unblocks writes, etc
+ sc.writeSched.forgetStream(st.id)
+ if st.reqBuf != nil {
+ // Stash this request body buffer (64k) away for reuse
+ // by a future POST/PUT/etc.
+ //
+ // TODO(bradfitz): share on the server? sync.Pool?
+ // Server requires locks and might hurt contention.
+ // sync.Pool might work, or might be worse, depending
+ // on goroutine CPU migrations. (get and put on
+ // separate CPUs). Maybe a mix of strategies. But
+ // this is an easy win for now.
+ sc.freeRequestBodyBuf = st.reqBuf
+ }
+}
+
+func (sc *serverConn) processSettings(f *SettingsFrame) error {
+ sc.serveG.check()
+ if f.IsAck() {
+ sc.unackedSettings--
+ if sc.unackedSettings < 0 {
+ // Why is the peer ACKing settings we never sent?
+ // The spec doesn't mention this case, but
+ // hang up on them anyway.
+ return ConnectionError(ErrCodeProtocol)
+ }
+ return nil
+ }
+ if err := f.ForeachSetting(sc.processSetting); err != nil {
+ return err
+ }
+ sc.needToSendSettingsAck = true
+ sc.scheduleFrameWrite()
+ return nil
+}
+
+func (sc *serverConn) processSetting(s Setting) error {
+ sc.serveG.check()
+ if err := s.Valid(); err != nil {
+ return err
+ }
+ if VerboseLogs {
+ sc.vlogf("http2: server processing setting %v", s)
+ }
+ switch s.ID {
+ case SettingHeaderTableSize:
+ sc.headerTableSize = s.Val
+ sc.hpackEncoder.SetMaxDynamicTableSize(s.Val)
+ case SettingEnablePush:
+ sc.pushEnabled = s.Val != 0
+ case SettingMaxConcurrentStreams:
+ sc.clientMaxStreams = s.Val
+ case SettingInitialWindowSize:
+ return sc.processSettingInitialWindowSize(s.Val)
+ case SettingMaxFrameSize:
+ sc.writeSched.maxFrameSize = s.Val
+ case SettingMaxHeaderListSize:
+ sc.peerMaxHeaderListSize = s.Val
+ default:
+ // Unknown setting: "An endpoint that receives a SETTINGS
+ // frame with any unknown or unsupported identifier MUST
+ // ignore that setting."
+ if VerboseLogs {
+ sc.vlogf("http2: server ignoring unknown setting %v", s)
+ }
+ }
+ return nil
+}
+
+func (sc *serverConn) processSettingInitialWindowSize(val uint32) error {
+ sc.serveG.check()
+ // Note: val already validated to be within range by
+ // processSetting's Valid call.
+
+ // "A SETTINGS frame can alter the initial flow control window
+ // size for all current streams. When the value of
+ // SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST
+ // adjust the size of all stream flow control windows that it
+ // maintains by the difference between the new value and the
+ // old value."
+ old := sc.initialWindowSize
+ sc.initialWindowSize = int32(val)
+ growth := sc.initialWindowSize - old // may be negative
+ for _, st := range sc.streams {
+ if !st.flow.add(growth) {
+ // 6.9.2 Initial Flow Control Window Size
+ // "An endpoint MUST treat a change to
+ // SETTINGS_INITIAL_WINDOW_SIZE that causes any flow
+ // control window to exceed the maximum size as a
+ // connection error (Section 5.4.1) of type
+ // FLOW_CONTROL_ERROR."
+ return ConnectionError(ErrCodeFlowControl)
+ }
+ }
+ return nil
+}
+
+func (sc *serverConn) processData(f *DataFrame) error {
+ sc.serveG.check()
+ data := f.Data()
+
+ // "If a DATA frame is received whose stream is not in "open"
+ // or "half closed (local)" state, the recipient MUST respond
+ // with a stream error (Section 5.4.2) of type STREAM_CLOSED."
+ id := f.Header().StreamID
+ st, ok := sc.streams[id]
+ if !ok || st.state != stateOpen || st.gotTrailerHeader {
+ // This includes sending a RST_STREAM if the stream is
+ // in stateHalfClosedLocal (which currently means that
+ // the http.Handler returned, so it's done reading &
+ // done writing). Try to stop the client from sending
+ // more DATA.
+
+ // But still enforce their connection-level flow control,
+ // and return any flow control bytes since we're not going
+ // to consume them.
+ if sc.inflow.available() < int32(f.Length) {
+ return streamError(id, ErrCodeFlowControl)
+ }
+ // Deduct the flow control from inflow, since we're
+ // going to immediately add it back in
+ // sendWindowUpdate, which also schedules sending the
+ // frames.
+ sc.inflow.take(int32(f.Length))
+ sc.sendWindowUpdate(nil, int(f.Length)) // conn-level
+
+ return streamError(id, ErrCodeStreamClosed)
+ }
+ if st.body == nil {
+ panic("internal error: should have a body in this state")
+ }
+
+ // Sender sending more than they'd declared?
+ if st.declBodyBytes != -1 && st.bodyBytes+int64(len(data)) > st.declBodyBytes {
+ st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
+ return streamError(id, ErrCodeStreamClosed)
+ }
+ if f.Length > 0 {
+ // Check whether the client has flow control quota.
+ if st.inflow.available() < int32(f.Length) {
+ return streamError(id, ErrCodeFlowControl)
+ }
+ st.inflow.take(int32(f.Length))
+
+ if len(data) > 0 {
+ wrote, err := st.body.Write(data)
+ if err != nil {
+ return streamError(id, ErrCodeStreamClosed)
+ }
+ if wrote != len(data) {
+ panic("internal error: bad Writer")
+ }
+ st.bodyBytes += int64(len(data))
+ }
+
+ // Return any padded flow control now, since we won't
+ // refund it later on body reads.
+ if pad := int32(f.Length) - int32(len(data)); pad > 0 {
+ sc.sendWindowUpdate32(nil, pad)
+ sc.sendWindowUpdate32(st, pad)
+ }
+ }
+ if f.StreamEnded() {
+ st.endStream()
+ }
+ return nil
+}
+
+// endStream closes a Request.Body's pipe. It is called when a DATA
+// frame says a request body is over (or after trailers).
+func (st *stream) endStream() {
+ sc := st.sc
+ sc.serveG.check()
+
+ if st.declBodyBytes != -1 && st.declBodyBytes != st.bodyBytes {
+ st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
+ st.declBodyBytes, st.bodyBytes))
+ } else {
+ st.body.closeWithErrorAndCode(io.EOF, st.copyTrailersToHandlerRequest)
+ st.body.CloseWithError(io.EOF)
+ }
+ st.state = stateHalfClosedRemote
+}
+
+// copyTrailersToHandlerRequest is run in the Handler's goroutine in
+// its Request.Body.Read just before it gets io.EOF.
+func (st *stream) copyTrailersToHandlerRequest() {
+ for k, vv := range st.trailer {
+ if _, ok := st.reqTrailer[k]; ok {
+ // Only copy it over it was pre-declared.
+ st.reqTrailer[k] = vv
+ }
+ }
+}
+
+func (sc *serverConn) processHeaders(f *MetaHeadersFrame) error {
+ sc.serveG.check()
+ id := f.Header().StreamID
+ if sc.inGoAway {
+ // Ignore.
+ return nil
+ }
+ // http://http2.github.io/http2-spec/#rfc.section.5.1.1
+ // Streams initiated by a client MUST use odd-numbered stream
+ // identifiers. [...] An endpoint that receives an unexpected
+ // stream identifier MUST respond with a connection error
+ // (Section 5.4.1) of type PROTOCOL_ERROR.
+ if id%2 != 1 {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ // A HEADERS frame can be used to create a new stream or
+ // send a trailer for an open one. If we already have a stream
+ // open, let it process its own HEADERS frame (trailers at this
+ // point, if it's valid).
+ st := sc.streams[f.Header().StreamID]
+ if st != nil {
+ return st.processTrailerHeaders(f)
+ }
+
+ // [...] The identifier of a newly established stream MUST be
+ // numerically greater than all streams that the initiating
+ // endpoint has opened or reserved. [...] An endpoint that
+ // receives an unexpected stream identifier MUST respond with
+ // a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
+ if id <= sc.maxStreamID {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ sc.maxStreamID = id
+
+ ctx, cancelCtx := contextWithCancel(sc.baseCtx)
+ st = &stream{
+ sc: sc,
+ id: id,
+ state: stateOpen,
+ ctx: ctx,
+ cancelCtx: cancelCtx,
+ }
+ if f.StreamEnded() {
+ st.state = stateHalfClosedRemote
+ }
+ st.cw.Init()
+
+ st.flow.conn = &sc.flow // link to conn-level counter
+ st.flow.add(sc.initialWindowSize)
+ st.inflow.conn = &sc.inflow // link to conn-level counter
+ st.inflow.add(initialWindowSize) // TODO: update this when we send a higher initial window size in the initial settings
+
+ sc.streams[id] = st
+ if f.HasPriority() {
+ adjustStreamPriority(sc.streams, st.id, f.Priority)
+ }
+ sc.curOpenStreams++
+ if sc.curOpenStreams == 1 {
+ sc.setConnState(http.StateActive)
+ }
+ if sc.curOpenStreams > sc.advMaxStreams {
+ // "Endpoints MUST NOT exceed the limit set by their
+ // peer. An endpoint that receives a HEADERS frame
+ // that causes their advertised concurrent stream
+ // limit to be exceeded MUST treat this as a stream
+ // error (Section 5.4.2) of type PROTOCOL_ERROR or
+ // REFUSED_STREAM."
+ if sc.unackedSettings == 0 {
+ // They should know better.
+ return streamError(st.id, ErrCodeProtocol)
+ }
+ // Assume it's a network race, where they just haven't
+ // received our last SETTINGS update. But actually
+ // this can't happen yet, because we don't yet provide
+ // a way for users to adjust server parameters at
+ // runtime.
+ return streamError(st.id, ErrCodeRefusedStream)
+ }
+
+ rw, req, err := sc.newWriterAndRequest(st, f)
+ if err != nil {
+ return err
+ }
+ st.reqTrailer = req.Trailer
+ if st.reqTrailer != nil {
+ st.trailer = make(http.Header)
+ }
+ st.body = req.Body.(*requestBody).pipe // may be nil
+ st.declBodyBytes = req.ContentLength
+
+ handler := sc.handler.ServeHTTP
+ if f.Truncated {
+ // Their header list was too long. Send a 431 error.
+ handler = handleHeaderListTooLong
+ } else if err := checkValidHTTP2Request(req); err != nil {
+ handler = new400Handler(err)
+ }
+
+ go sc.runHandler(rw, req, handler)
+ return nil
+}
+
+func (st *stream) processTrailerHeaders(f *MetaHeadersFrame) error {
+ sc := st.sc
+ sc.serveG.check()
+ if st.gotTrailerHeader {
+ return ConnectionError(ErrCodeProtocol)
+ }
+ st.gotTrailerHeader = true
+ if !f.StreamEnded() {
+ return streamError(st.id, ErrCodeProtocol)
+ }
+
+ if len(f.PseudoFields()) > 0 {
+ return streamError(st.id, ErrCodeProtocol)
+ }
+ if st.trailer != nil {
+ for _, hf := range f.RegularFields() {
+ key := sc.canonicalHeader(hf.Name)
+ if !ValidTrailerHeader(key) {
+ // TODO: send more details to the peer somehow. But http2 has
+ // no way to send debug data at a stream level. Discuss with
+ // HTTP folk.
+ return streamError(st.id, ErrCodeProtocol)
+ }
+ st.trailer[key] = append(st.trailer[key], hf.Value)
+ }
+ }
+ st.endStream()
+ return nil
+}
+
+func (sc *serverConn) processPriority(f *PriorityFrame) error {
+ adjustStreamPriority(sc.streams, f.StreamID, f.PriorityParam)
+ return nil
+}
+
+func adjustStreamPriority(streams map[uint32]*stream, streamID uint32, priority PriorityParam) {
+ st, ok := streams[streamID]
+ if !ok {
+ // TODO: not quite correct (this streamID might
+ // already exist in the dep tree, but be closed), but
+ // close enough for now.
+ return
+ }
+ st.weight = priority.Weight
+ parent := streams[priority.StreamDep] // might be nil
+ if parent == st {
+ // if client tries to set this stream to be the parent of itself
+ // ignore and keep going
+ return
+ }
+
+ // section 5.3.3: If a stream is made dependent on one of its
+ // own dependencies, the formerly dependent stream is first
+ // moved to be dependent on the reprioritized stream's previous
+ // parent. The moved dependency retains its weight.
+ for piter := parent; piter != nil; piter = piter.parent {
+ if piter == st {
+ parent.parent = st.parent
+ break
+ }
+ }
+ st.parent = parent
+ if priority.Exclusive && (st.parent != nil || priority.StreamDep == 0) {
+ for _, openStream := range streams {
+ if openStream != st && openStream.parent == st.parent {
+ openStream.parent = st
+ }
+ }
+ }
+}
+
+func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*responseWriter, *http.Request, error) {
+ sc.serveG.check()
+
+ method := f.PseudoValue("method")
+ path := f.PseudoValue("path")
+ scheme := f.PseudoValue("scheme")
+ authority := f.PseudoValue("authority")
+
+ isConnect := method == "CONNECT"
+ if isConnect {
+ if path != "" || scheme != "" || authority == "" {
+ return nil, nil, streamError(f.StreamID, ErrCodeProtocol)
+ }
+ } else if method == "" || path == "" ||
+ (scheme != "https" && scheme != "http") {
+ // See 8.1.2.6 Malformed Requests and Responses:
+ //
+ // Malformed requests or responses that are detected
+ // MUST be treated as a stream error (Section 5.4.2)
+ // of type PROTOCOL_ERROR."
+ //
+ // 8.1.2.3 Request Pseudo-Header Fields
+ // "All HTTP/2 requests MUST include exactly one valid
+ // value for the :method, :scheme, and :path
+ // pseudo-header fields"
+ return nil, nil, streamError(f.StreamID, ErrCodeProtocol)
+ }
+
+ bodyOpen := !f.StreamEnded()
+ if method == "HEAD" && bodyOpen {
+ // HEAD requests can't have bodies
+ return nil, nil, streamError(f.StreamID, ErrCodeProtocol)
+ }
+ var tlsState *tls.ConnectionState // nil if not scheme https
+
+ if scheme == "https" {
+ tlsState = sc.tlsState
+ }
+
+ header := make(http.Header)
+ for _, hf := range f.RegularFields() {
+ header.Add(sc.canonicalHeader(hf.Name), hf.Value)
+ }
+
+ if authority == "" {
+ authority = header.Get("Host")
+ }
+ needsContinue := header.Get("Expect") == "100-continue"
+ if needsContinue {
+ header.Del("Expect")
+ }
+ // Merge Cookie headers into one "; "-delimited value.
+ if cookies := header["Cookie"]; len(cookies) > 1 {
+ header.Set("Cookie", strings.Join(cookies, "; "))
+ }
+
+ // Setup Trailers
+ var trailer http.Header
+ for _, v := range header["Trailer"] {
+ for _, key := range strings.Split(v, ",") {
+ key = http.CanonicalHeaderKey(strings.TrimSpace(key))
+ switch key {
+ case "Transfer-Encoding", "Trailer", "Content-Length":
+ // Bogus. (copy of http1 rules)
+ // Ignore.
+ default:
+ if trailer == nil {
+ trailer = make(http.Header)
+ }
+ trailer[key] = nil
+ }
+ }
+ }
+ delete(header, "Trailer")
+
+ body := &requestBody{
+ conn: sc,
+ stream: st,
+ needsContinue: needsContinue,
+ }
+ var url_ *url.URL
+ var requestURI string
+ if isConnect {
+ url_ = &url.URL{Host: authority}
+ requestURI = authority // mimic HTTP/1 server behavior
+ } else {
+ var err error
+ url_, err = url.ParseRequestURI(path)
+ if err != nil {
+ return nil, nil, streamError(f.StreamID, ErrCodeProtocol)
+ }
+ requestURI = path
+ }
+ req := &http.Request{
+ Method: method,
+ URL: url_,
+ RemoteAddr: sc.remoteAddrStr,
+ Header: header,
+ RequestURI: requestURI,
+ Proto: "HTTP/2.0",
+ ProtoMajor: 2,
+ ProtoMinor: 0,
+ TLS: tlsState,
+ Host: authority,
+ Body: body,
+ Trailer: trailer,
+ }
+ req = requestWithContext(req, st.ctx)
+ if bodyOpen {
+ // Disabled, per golang.org/issue/14960:
+ // st.reqBuf = sc.getRequestBodyBuf()
+ // TODO: remove this 64k of garbage per request (again, but without a data race):
+ buf := make([]byte, initialWindowSize)
+
+ body.pipe = &pipe{
+ b: &fixedBuffer{buf: buf},
+ }
+
+ if vv, ok := header["Content-Length"]; ok {
+ req.ContentLength, _ = strconv.ParseInt(vv[0], 10, 64)
+ } else {
+ req.ContentLength = -1
+ }
+ }
+
+ rws := responseWriterStatePool.Get().(*responseWriterState)
+ bwSave := rws.bw
+ *rws = responseWriterState{} // zero all the fields
+ rws.conn = sc
+ rws.bw = bwSave
+ rws.bw.Reset(chunkWriter{rws})
+ rws.stream = st
+ rws.req = req
+ rws.body = body
+
+ rw := &responseWriter{rws: rws}
+ return rw, req, nil
+}
+
+func (sc *serverConn) getRequestBodyBuf() []byte {
+ sc.serveG.check()
+ if buf := sc.freeRequestBodyBuf; buf != nil {
+ sc.freeRequestBodyBuf = nil
+ return buf
+ }
+ return make([]byte, initialWindowSize)
+}
+
+// Run on its own goroutine.
+func (sc *serverConn) runHandler(rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) {
+ didPanic := true
+ defer func() {
+ rw.rws.stream.cancelCtx()
+ if didPanic {
+ e := recover()
+ // Same as net/http:
+ const size = 64 << 10
+ buf := make([]byte, size)
+ buf = buf[:runtime.Stack(buf, false)]
+ sc.writeFrameFromHandler(frameWriteMsg{
+ write: handlerPanicRST{rw.rws.stream.id},
+ stream: rw.rws.stream,
+ })
+ sc.logf("http2: panic serving %v: %v\n%s", sc.conn.RemoteAddr(), e, buf)
+ return
+ }
+ rw.handlerDone()
+ }()
+ handler(rw, req)
+ didPanic = false
+}
+
+func handleHeaderListTooLong(w http.ResponseWriter, r *http.Request) {
+ // 10.5.1 Limits on Header Block Size:
+ // .. "A server that receives a larger header block than it is
+ // willing to handle can send an HTTP 431 (Request Header Fields Too
+ // Large) status code"
+ const statusRequestHeaderFieldsTooLarge = 431 // only in Go 1.6+
+ w.WriteHeader(statusRequestHeaderFieldsTooLarge)
+ io.WriteString(w, "<h1>HTTP Error 431</h1><p>Request Header Field(s) Too Large</p>")
+}
+
+// called from handler goroutines.
+// h may be nil.
+func (sc *serverConn) writeHeaders(st *stream, headerData *writeResHeaders) error {
+ sc.serveG.checkNotOn() // NOT on
+ var errc chan error
+ if headerData.h != nil {
+ // If there's a header map (which we don't own), so we have to block on
+ // waiting for this frame to be written, so an http.Flush mid-handler
+ // writes out the correct value of keys, before a handler later potentially
+ // mutates it.
+ errc = errChanPool.Get().(chan error)
+ }
+ if err := sc.writeFrameFromHandler(frameWriteMsg{
+ write: headerData,
+ stream: st,
+ done: errc,
+ }); err != nil {
+ return err
+ }
+ if errc != nil {
+ select {
+ case err := <-errc:
+ errChanPool.Put(errc)
+ return err
+ case <-sc.doneServing:
+ return errClientDisconnected
+ case <-st.cw:
+ return errStreamClosed
+ }
+ }
+ return nil
+}
+
+// called from handler goroutines.
+func (sc *serverConn) write100ContinueHeaders(st *stream) {
+ sc.writeFrameFromHandler(frameWriteMsg{
+ write: write100ContinueHeadersFrame{st.id},
+ stream: st,
+ })
+}
+
+// A bodyReadMsg tells the server loop that the http.Handler read n
+// bytes of the DATA from the client on the given stream.
+type bodyReadMsg struct {
+ st *stream
+ n int
+}
+
+// called from handler goroutines.
+// Notes that the handler for the given stream ID read n bytes of its body
+// and schedules flow control tokens to be sent.
+func (sc *serverConn) noteBodyReadFromHandler(st *stream, n int) {
+ sc.serveG.checkNotOn() // NOT on
+ select {
+ case sc.bodyReadCh <- bodyReadMsg{st, n}:
+ case <-sc.doneServing:
+ }
+}
+
+func (sc *serverConn) noteBodyRead(st *stream, n int) {
+ sc.serveG.check()
+ sc.sendWindowUpdate(nil, n) // conn-level
+ if st.state != stateHalfClosedRemote && st.state != stateClosed {
+ // Don't send this WINDOW_UPDATE if the stream is closed
+ // remotely.
+ sc.sendWindowUpdate(st, n)
+ }
+}
+
+// st may be nil for conn-level
+func (sc *serverConn) sendWindowUpdate(st *stream, n int) {
+ sc.serveG.check()
+ // "The legal range for the increment to the flow control
+ // window is 1 to 2^31-1 (2,147,483,647) octets."
+ // A Go Read call on 64-bit machines could in theory read
+ // a larger Read than this. Very unlikely, but we handle it here
+ // rather than elsewhere for now.
+ const maxUint31 = 1<<31 - 1
+ for n >= maxUint31 {
+ sc.sendWindowUpdate32(st, maxUint31)
+ n -= maxUint31
+ }
+ sc.sendWindowUpdate32(st, int32(n))
+}
+
+// st may be nil for conn-level
+func (sc *serverConn) sendWindowUpdate32(st *stream, n int32) {
+ sc.serveG.check()
+ if n == 0 {
+ return
+ }
+ if n < 0 {
+ panic("negative update")
+ }
+ var streamID uint32
+ if st != nil {
+ streamID = st.id
+ }
+ sc.writeFrame(frameWriteMsg{
+ write: writeWindowUpdate{streamID: streamID, n: uint32(n)},
+ stream: st,
+ })
+ var ok bool
+ if st == nil {
+ ok = sc.inflow.add(n)
+ } else {
+ ok = st.inflow.add(n)
+ }
+ if !ok {
+ panic("internal error; sent too many window updates without decrements?")
+ }
+}
+
+type requestBody struct {
+ stream *stream
+ conn *serverConn
+ closed bool
+ pipe *pipe // non-nil if we have a HTTP entity message body
+ needsContinue bool // need to send a 100-continue
+}
+
+func (b *requestBody) Close() error {
+ if b.pipe != nil {
+ b.pipe.BreakWithError(errClosedBody)
+ }
+ b.closed = true
+ return nil
+}
+
+func (b *requestBody) Read(p []byte) (n int, err error) {
+ if b.needsContinue {
+ b.needsContinue = false
+ b.conn.write100ContinueHeaders(b.stream)
+ }
+ if b.pipe == nil {
+ return 0, io.EOF
+ }
+ n, err = b.pipe.Read(p)
+ if n > 0 {
+ b.conn.noteBodyReadFromHandler(b.stream, n)
+ }
+ return
+}
+
+// responseWriter is the http.ResponseWriter implementation. It's
+// intentionally small (1 pointer wide) to minimize garbage. The
+// responseWriterState pointer inside is zeroed at the end of a
+// request (in handlerDone) and calls on the responseWriter thereafter
+// simply crash (caller's mistake), but the much larger responseWriterState
+// and buffers are reused between multiple requests.
+type responseWriter struct {
+ rws *responseWriterState
+}
+
+// Optional http.ResponseWriter interfaces implemented.
+var (
+ _ http.CloseNotifier = (*responseWriter)(nil)
+ _ http.Flusher = (*responseWriter)(nil)
+ _ stringWriter = (*responseWriter)(nil)
+)
+
+type responseWriterState struct {
+ // immutable within a request:
+ stream *stream
+ req *http.Request
+ body *requestBody // to close at end of request, if DATA frames didn't
+ conn *serverConn
+
+ // TODO: adjust buffer writing sizes based on server config, frame size updates from peer, etc
+ bw *bufio.Writer // writing to a chunkWriter{this *responseWriterState}
+
+ // mutated by http.Handler goroutine:
+ handlerHeader http.Header // nil until called
+ snapHeader http.Header // snapshot of handlerHeader at WriteHeader time
+ trailers []string // set in writeChunk
+ status int // status code passed to WriteHeader
+ wroteHeader bool // WriteHeader called (explicitly or implicitly). Not necessarily sent to user yet.
+ sentHeader bool // have we sent the header frame?
+ handlerDone bool // handler has finished
+
+ sentContentLen int64 // non-zero if handler set a Content-Length header
+ wroteBytes int64
+
+ closeNotifierMu sync.Mutex // guards closeNotifierCh
+ closeNotifierCh chan bool // nil until first used
+}
+
+type chunkWriter struct{ rws *responseWriterState }
+
+func (cw chunkWriter) Write(p []byte) (n int, err error) { return cw.rws.writeChunk(p) }
+
+func (rws *responseWriterState) hasTrailers() bool { return len(rws.trailers) != 0 }
+
+// declareTrailer is called for each Trailer header when the
+// response header is written. It notes that a header will need to be
+// written in the trailers at the end of the response.
+func (rws *responseWriterState) declareTrailer(k string) {
+ k = http.CanonicalHeaderKey(k)
+ if !ValidTrailerHeader(k) {
+ // Forbidden by RFC 2616 14.40.
+ rws.conn.logf("ignoring invalid trailer %q", k)
+ return
+ }
+ if !strSliceContains(rws.trailers, k) {
+ rws.trailers = append(rws.trailers, k)
+ }
+}
+
+// writeChunk writes chunks from the bufio.Writer. But because
+// bufio.Writer may bypass its chunking, sometimes p may be
+// arbitrarily large.
+//
+// writeChunk is also responsible (on the first chunk) for sending the
+// HEADER response.
+func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) {
+ if !rws.wroteHeader {
+ rws.writeHeader(200)
+ }
+
+ isHeadResp := rws.req.Method == "HEAD"
+ if !rws.sentHeader {
+ rws.sentHeader = true
+ var ctype, clen string
+ if clen = rws.snapHeader.Get("Content-Length"); clen != "" {
+ rws.snapHeader.Del("Content-Length")
+ clen64, err := strconv.ParseInt(clen, 10, 64)
+ if err == nil && clen64 >= 0 {
+ rws.sentContentLen = clen64
+ } else {
+ clen = ""
+ }
+ }
+ if clen == "" && rws.handlerDone && bodyAllowedForStatus(rws.status) && (len(p) > 0 || !isHeadResp) {
+ clen = strconv.Itoa(len(p))
+ }
+ _, hasContentType := rws.snapHeader["Content-Type"]
+ if !hasContentType && bodyAllowedForStatus(rws.status) {
+ ctype = http.DetectContentType(p)
+ }
+ var date string
+ if _, ok := rws.snapHeader["Date"]; !ok {
+ // TODO(bradfitz): be faster here, like net/http? measure.
+ date = time.Now().UTC().Format(http.TimeFormat)
+ }
+
+ for _, v := range rws.snapHeader["Trailer"] {
+ foreachHeaderElement(v, rws.declareTrailer)
+ }
+
+ endStream := (rws.handlerDone && !rws.hasTrailers() && len(p) == 0) || isHeadResp
+ err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{
+ streamID: rws.stream.id,
+ httpResCode: rws.status,
+ h: rws.snapHeader,
+ endStream: endStream,
+ contentType: ctype,
+ contentLength: clen,
+ date: date,
+ })
+ if err != nil {
+ return 0, err
+ }
+ if endStream {
+ return 0, nil
+ }
+ }
+ if isHeadResp {
+ return len(p), nil
+ }
+ if len(p) == 0 && !rws.handlerDone {
+ return 0, nil
+ }
+
+ if rws.handlerDone {
+ rws.promoteUndeclaredTrailers()
+ }
+
+ endStream := rws.handlerDone && !rws.hasTrailers()
+ if len(p) > 0 || endStream {
+ // only send a 0 byte DATA frame if we're ending the stream.
+ if err := rws.conn.writeDataFromHandler(rws.stream, p, endStream); err != nil {
+ return 0, err
+ }
+ }
+
+ if rws.handlerDone && rws.hasTrailers() {
+ err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{
+ streamID: rws.stream.id,
+ h: rws.handlerHeader,
+ trailers: rws.trailers,
+ endStream: true,
+ })
+ return len(p), err
+ }
+ return len(p), nil
+}
+
+// TrailerPrefix is a magic prefix for ResponseWriter.Header map keys
+// that, if present, signals that the map entry is actually for
+// the response trailers, and not the response headers. The prefix
+// is stripped after the ServeHTTP call finishes and the values are
+// sent in the trailers.
+//
+// This mechanism is intended only for trailers that are not known
+// prior to the headers being written. If the set of trailers is fixed
+// or known before the header is written, the normal Go trailers mechanism
+// is preferred:
+// https://golang.org/pkg/net/http/#ResponseWriter
+// https://golang.org/pkg/net/http/#example_ResponseWriter_trailers
+const TrailerPrefix = "Trailer:"
+
+// promoteUndeclaredTrailers permits http.Handlers to set trailers
+// after the header has already been flushed. Because the Go
+// ResponseWriter interface has no way to set Trailers (only the
+// Header), and because we didn't want to expand the ResponseWriter
+// interface, and because nobody used trailers, and because RFC 2616
+// says you SHOULD (but not must) predeclare any trailers in the
+// header, the official ResponseWriter rules said trailers in Go must
+// be predeclared, and then we reuse the same ResponseWriter.Header()
+// map to mean both Headers and Trailers. When it's time to write the
+// Trailers, we pick out the fields of Headers that were declared as
+// trailers. That worked for a while, until we found the first major
+// user of Trailers in the wild: gRPC (using them only over http2),
+// and gRPC libraries permit setting trailers mid-stream without
+// predeclarnig them. So: change of plans. We still permit the old
+// way, but we also permit this hack: if a Header() key begins with
+// "Trailer:", the suffix of that key is a Trailer. Because ':' is an
+// invalid token byte anyway, there is no ambiguity. (And it's already
+// filtered out) It's mildly hacky, but not terrible.
+//
+// This method runs after the Handler is done and promotes any Header
+// fields to be trailers.
+func (rws *responseWriterState) promoteUndeclaredTrailers() {
+ for k, vv := range rws.handlerHeader {
+ if !strings.HasPrefix(k, TrailerPrefix) {
+ continue
+ }
+ trailerKey := strings.TrimPrefix(k, TrailerPrefix)
+ rws.declareTrailer(trailerKey)
+ rws.handlerHeader[http.CanonicalHeaderKey(trailerKey)] = vv
+ }
+
+ if len(rws.trailers) > 1 {
+ sorter := sorterPool.Get().(*sorter)
+ sorter.SortStrings(rws.trailers)
+ sorterPool.Put(sorter)
+ }
+}
+
+func (w *responseWriter) Flush() {
+ rws := w.rws
+ if rws == nil {
+ panic("Header called after Handler finished")
+ }
+ if rws.bw.Buffered() > 0 {
+ if err := rws.bw.Flush(); err != nil {
+ // Ignore the error. The frame writer already knows.
+ return
+ }
+ } else {
+ // The bufio.Writer won't call chunkWriter.Write
+ // (writeChunk with zero bytes, so we have to do it
+ // ourselves to force the HTTP response header and/or
+ // final DATA frame (with END_STREAM) to be sent.
+ rws.writeChunk(nil)
+ }
+}
+
+func (w *responseWriter) CloseNotify() <-chan bool {
+ rws := w.rws
+ if rws == nil {
+ panic("CloseNotify called after Handler finished")
+ }
+ rws.closeNotifierMu.Lock()
+ ch := rws.closeNotifierCh
+ if ch == nil {
+ ch = make(chan bool, 1)
+ rws.closeNotifierCh = ch
+ go func() {
+ rws.stream.cw.Wait() // wait for close
+ ch <- true
+ }()
+ }
+ rws.closeNotifierMu.Unlock()
+ return ch
+}
+
+func (w *responseWriter) Header() http.Header {
+ rws := w.rws
+ if rws == nil {
+ panic("Header called after Handler finished")
+ }
+ if rws.handlerHeader == nil {
+ rws.handlerHeader = make(http.Header)
+ }
+ return rws.handlerHeader
+}
+
+func (w *responseWriter) WriteHeader(code int) {
+ rws := w.rws
+ if rws == nil {
+ panic("WriteHeader called after Handler finished")
+ }
+ rws.writeHeader(code)
+}
+
+func (rws *responseWriterState) writeHeader(code int) {
+ if !rws.wroteHeader {
+ rws.wroteHeader = true
+ rws.status = code
+ if len(rws.handlerHeader) > 0 {
+ rws.snapHeader = cloneHeader(rws.handlerHeader)
+ }
+ }
+}
+
+func cloneHeader(h http.Header) http.Header {
+ h2 := make(http.Header, len(h))
+ for k, vv := range h {
+ vv2 := make([]string, len(vv))
+ copy(vv2, vv)
+ h2[k] = vv2
+ }
+ return h2
+}
+
+// The Life Of A Write is like this:
+//
+// * Handler calls w.Write or w.WriteString ->
+// * -> rws.bw (*bufio.Writer) ->
+// * (Handler migth call Flush)
+// * -> chunkWriter{rws}
+// * -> responseWriterState.writeChunk(p []byte)
+// * -> responseWriterState.writeChunk (most of the magic; see comment there)
+func (w *responseWriter) Write(p []byte) (n int, err error) {
+ return w.write(len(p), p, "")
+}
+
+func (w *responseWriter) WriteString(s string) (n int, err error) {
+ return w.write(len(s), nil, s)
+}
+
+// either dataB or dataS is non-zero.
+func (w *responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) {
+ rws := w.rws
+ if rws == nil {
+ panic("Write called after Handler finished")
+ }
+ if !rws.wroteHeader {
+ w.WriteHeader(200)
+ }
+ if !bodyAllowedForStatus(rws.status) {
+ return 0, http.ErrBodyNotAllowed
+ }
+ rws.wroteBytes += int64(len(dataB)) + int64(len(dataS)) // only one can be set
+ if rws.sentContentLen != 0 && rws.wroteBytes > rws.sentContentLen {
+ // TODO: send a RST_STREAM
+ return 0, errors.New("http2: handler wrote more than declared Content-Length")
+ }
+
+ if dataB != nil {
+ return rws.bw.Write(dataB)
+ } else {
+ return rws.bw.WriteString(dataS)
+ }
+}
+
+func (w *responseWriter) handlerDone() {
+ rws := w.rws
+ rws.handlerDone = true
+ w.Flush()
+ w.rws = nil
+ responseWriterStatePool.Put(rws)
+}
+
+// foreachHeaderElement splits v according to the "#rule" construction
+// in RFC 2616 section 2.1 and calls fn for each non-empty element.
+func foreachHeaderElement(v string, fn func(string)) {
+ v = textproto.TrimString(v)
+ if v == "" {
+ return
+ }
+ if !strings.Contains(v, ",") {
+ fn(v)
+ return
+ }
+ for _, f := range strings.Split(v, ",") {
+ if f = textproto.TrimString(f); f != "" {
+ fn(f)
+ }
+ }
+}
+
+// From http://httpwg.org/specs/rfc7540.html#rfc.section.8.1.2.2
+var connHeaders = []string{
+ "Connection",
+ "Keep-Alive",
+ "Proxy-Connection",
+ "Transfer-Encoding",
+ "Upgrade",
+}
+
+// checkValidHTTP2Request checks whether req is a valid HTTP/2 request,
+// per RFC 7540 Section 8.1.2.2.
+// The returned error is reported to users.
+func checkValidHTTP2Request(req *http.Request) error {
+ for _, h := range connHeaders {
+ if _, ok := req.Header[h]; ok {
+ return fmt.Errorf("request header %q is not valid in HTTP/2", h)
+ }
+ }
+ te := req.Header["Te"]
+ if len(te) > 0 && (len(te) > 1 || (te[0] != "trailers" && te[0] != "")) {
+ return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
+ }
+ return nil
+}
+
+func new400Handler(err error) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ }
+}
+
+// ValidTrailerHeader reports whether name is a valid header field name to appear
+// in trailers.
+// See: http://tools.ietf.org/html/rfc7230#section-4.1.2
+func ValidTrailerHeader(name string) bool {
+ name = http.CanonicalHeaderKey(name)
+ if strings.HasPrefix(name, "If-") || badTrailer[name] {
+ return false
+ }
+ return true
+}
+
+var badTrailer = map[string]bool{
+ "Authorization": true,
+ "Cache-Control": true,
+ "Connection": true,
+ "Content-Encoding": true,
+ "Content-Length": true,
+ "Content-Range": true,
+ "Content-Type": true,
+ "Expect": true,
+ "Host": true,
+ "Keep-Alive": true,
+ "Max-Forwards": true,
+ "Pragma": true,
+ "Proxy-Authenticate": true,
+ "Proxy-Authorization": true,
+ "Proxy-Connection": true,
+ "Range": true,
+ "Realm": true,
+ "Te": true,
+ "Trailer": true,
+ "Transfer-Encoding": true,
+ "Www-Authenticate": true,
+}
diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go
new file mode 100644
index 0000000000000000000000000000000000000000..3cefc22a6bccb0dc53b94aed2cb6954cd612ad50
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/transport.go
@@ -0,0 +1,1967 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Transport code.
+
+package http2
+
+import (
+ "bufio"
+ "bytes"
+ "compress/gzip"
+ "crypto/tls"
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "math"
+ "net"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/http2/hpack"
+ "golang.org/x/net/lex/httplex"
+)
+
+const (
+ // transportDefaultConnFlow is how many connection-level flow control
+ // tokens we give the server at start-up, past the default 64k.
+ transportDefaultConnFlow = 1 << 30
+
+ // transportDefaultStreamFlow is how many stream-level flow
+ // control tokens we announce to the peer, and how many bytes
+ // we buffer per stream.
+ transportDefaultStreamFlow = 4 << 20
+
+ // transportDefaultStreamMinRefresh is the minimum number of bytes we'll send
+ // a stream-level WINDOW_UPDATE for at a time.
+ transportDefaultStreamMinRefresh = 4 << 10
+
+ defaultUserAgent = "Go-http-client/2.0"
+)
+
+// Transport is an HTTP/2 Transport.
+//
+// A Transport internally caches connections to servers. It is safe
+// for concurrent use by multiple goroutines.
+type Transport struct {
+ // DialTLS specifies an optional dial function for creating
+ // TLS connections for requests.
+ //
+ // If DialTLS is nil, tls.Dial is used.
+ //
+ // If the returned net.Conn has a ConnectionState method like tls.Conn,
+ // it will be used to set http.Response.TLS.
+ DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error)
+
+ // TLSClientConfig specifies the TLS configuration to use with
+ // tls.Client. If nil, the default configuration is used.
+ TLSClientConfig *tls.Config
+
+ // ConnPool optionally specifies an alternate connection pool to use.
+ // If nil, the default is used.
+ ConnPool ClientConnPool
+
+ // DisableCompression, if true, prevents the Transport from
+ // requesting compression with an "Accept-Encoding: gzip"
+ // request header when the Request contains no existing
+ // Accept-Encoding value. If the Transport requests gzip on
+ // its own and gets a gzipped response, it's transparently
+ // decoded in the Response.Body. However, if the user
+ // explicitly requested gzip it is not automatically
+ // uncompressed.
+ DisableCompression bool
+
+ // AllowHTTP, if true, permits HTTP/2 requests using the insecure,
+ // plain-text "http" scheme. Note that this does not enable h2c support.
+ AllowHTTP bool
+
+ // MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
+ // send in the initial settings frame. It is how many bytes
+ // of response headers are allow. Unlike the http2 spec, zero here
+ // means to use a default limit (currently 10MB). If you actually
+ // want to advertise an ulimited value to the peer, Transport
+ // interprets the highest possible value here (0xffffffff or 1<<32-1)
+ // to mean no limit.
+ MaxHeaderListSize uint32
+
+ // t1, if non-nil, is the standard library Transport using
+ // this transport. Its settings are used (but not its
+ // RoundTrip method, etc).
+ t1 *http.Transport
+
+ connPoolOnce sync.Once
+ connPoolOrDef ClientConnPool // non-nil version of ConnPool
+}
+
+func (t *Transport) maxHeaderListSize() uint32 {
+ if t.MaxHeaderListSize == 0 {
+ return 10 << 20
+ }
+ if t.MaxHeaderListSize == 0xffffffff {
+ return 0
+ }
+ return t.MaxHeaderListSize
+}
+
+func (t *Transport) disableCompression() bool {
+ return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
+}
+
+var errTransportVersion = errors.New("http2: ConfigureTransport is only supported starting at Go 1.6")
+
+// ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2.
+// It requires Go 1.6 or later and returns an error if the net/http package is too old
+// or if t1 has already been HTTP/2-enabled.
+func ConfigureTransport(t1 *http.Transport) error {
+ _, err := configureTransport(t1) // in configure_transport.go (go1.6) or not_go16.go
+ return err
+}
+
+func (t *Transport) connPool() ClientConnPool {
+ t.connPoolOnce.Do(t.initConnPool)
+ return t.connPoolOrDef
+}
+
+func (t *Transport) initConnPool() {
+ if t.ConnPool != nil {
+ t.connPoolOrDef = t.ConnPool
+ } else {
+ t.connPoolOrDef = &clientConnPool{t: t}
+ }
+}
+
+// ClientConn is the state of a single HTTP/2 client connection to an
+// HTTP/2 server.
+type ClientConn struct {
+ t *Transport
+ tconn net.Conn // usually *tls.Conn, except specialized impls
+ tlsState *tls.ConnectionState // nil only for specialized impls
+ singleUse bool // whether being used for a single http.Request
+
+ // readLoop goroutine fields:
+ readerDone chan struct{} // closed on error
+ readerErr error // set before readerDone is closed
+
+ mu sync.Mutex // guards following
+ cond *sync.Cond // hold mu; broadcast on flow/closed changes
+ flow flow // our conn-level flow control quota (cs.flow is per stream)
+ inflow flow // peer's conn-level flow control
+ closed bool
+ wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back
+ goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received
+ goAwayDebug string // goAway frame's debug data, retained as a string
+ streams map[uint32]*clientStream // client-initiated
+ nextStreamID uint32
+ bw *bufio.Writer
+ br *bufio.Reader
+ fr *Framer
+ lastActive time.Time
+ // Settings from peer: (also guarded by mu)
+ maxFrameSize uint32
+ maxConcurrentStreams uint32
+ initialWindowSize uint32
+
+ hbuf bytes.Buffer // HPACK encoder writes into this
+ henc *hpack.Encoder
+ freeBuf [][]byte
+
+ wmu sync.Mutex // held while writing; acquire AFTER mu if holding both
+ werr error // first write error that has occurred
+}
+
+// clientStream is the state for a single HTTP/2 stream. One of these
+// is created for each Transport.RoundTrip call.
+type clientStream struct {
+ cc *ClientConn
+ req *http.Request
+ trace *clientTrace // or nil
+ ID uint32
+ resc chan resAndError
+ bufPipe pipe // buffered pipe with the flow-controlled response payload
+ requestedGzip bool
+ on100 func() // optional code to run if get a 100 continue response
+
+ flow flow // guarded by cc.mu
+ inflow flow // guarded by cc.mu
+ bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read
+ readErr error // sticky read error; owned by transportResponseBody.Read
+ stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu
+
+ peerReset chan struct{} // closed on peer reset
+ resetErr error // populated before peerReset is closed
+
+ done chan struct{} // closed when stream remove from cc.streams map; close calls guarded by cc.mu
+
+ // owned by clientConnReadLoop:
+ firstByte bool // got the first response byte
+ pastHeaders bool // got first MetaHeadersFrame (actual headers)
+ pastTrailers bool // got optional second MetaHeadersFrame (trailers)
+
+ trailer http.Header // accumulated trailers
+ resTrailer *http.Header // client's Response.Trailer
+}
+
+// awaitRequestCancel runs in its own goroutine and waits for the user
+// to cancel a RoundTrip request, its context to expire, or for the
+// request to be done (any way it might be removed from the cc.streams
+// map: peer reset, successful completion, TCP connection breakage,
+// etc)
+func (cs *clientStream) awaitRequestCancel(req *http.Request) {
+ ctx := reqContext(req)
+ if req.Cancel == nil && ctx.Done() == nil {
+ return
+ }
+ select {
+ case <-req.Cancel:
+ cs.bufPipe.CloseWithError(errRequestCanceled)
+ cs.cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ case <-ctx.Done():
+ cs.bufPipe.CloseWithError(ctx.Err())
+ cs.cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ case <-cs.done:
+ }
+}
+
+// checkResetOrDone reports any error sent in a RST_STREAM frame by the
+// server, or errStreamClosed if the stream is complete.
+func (cs *clientStream) checkResetOrDone() error {
+ select {
+ case <-cs.peerReset:
+ return cs.resetErr
+ case <-cs.done:
+ return errStreamClosed
+ default:
+ return nil
+ }
+}
+
+func (cs *clientStream) abortRequestBodyWrite(err error) {
+ if err == nil {
+ panic("nil error")
+ }
+ cc := cs.cc
+ cc.mu.Lock()
+ cs.stopReqBody = err
+ cc.cond.Broadcast()
+ cc.mu.Unlock()
+}
+
+type stickyErrWriter struct {
+ w io.Writer
+ err *error
+}
+
+func (sew stickyErrWriter) Write(p []byte) (n int, err error) {
+ if *sew.err != nil {
+ return 0, *sew.err
+ }
+ n, err = sew.w.Write(p)
+ *sew.err = err
+ return
+}
+
+var ErrNoCachedConn = errors.New("http2: no cached connection was available")
+
+// RoundTripOpt are options for the Transport.RoundTripOpt method.
+type RoundTripOpt struct {
+ // OnlyCachedConn controls whether RoundTripOpt may
+ // create a new TCP connection. If set true and
+ // no cached connection is available, RoundTripOpt
+ // will return ErrNoCachedConn.
+ OnlyCachedConn bool
+}
+
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+ return t.RoundTripOpt(req, RoundTripOpt{})
+}
+
+// authorityAddr returns a given authority (a host/IP, or host:port / ip:port)
+// and returns a host:port. The port 443 is added if needed.
+func authorityAddr(scheme string, authority string) (addr string) {
+ if _, _, err := net.SplitHostPort(authority); err == nil {
+ return authority
+ }
+ port := "443"
+ if scheme == "http" {
+ port = "80"
+ }
+ return net.JoinHostPort(authority, port)
+}
+
+// RoundTripOpt is like RoundTrip, but takes options.
+func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
+ if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) {
+ return nil, errors.New("http2: unsupported scheme")
+ }
+
+ addr := authorityAddr(req.URL.Scheme, req.URL.Host)
+ for {
+ cc, err := t.connPool().GetClientConn(req, addr)
+ if err != nil {
+ t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
+ return nil, err
+ }
+ traceGotConn(req, cc)
+ res, err := cc.RoundTrip(req)
+ if shouldRetryRequest(req, err) {
+ continue
+ }
+ if err != nil {
+ t.vlogf("RoundTrip failure: %v", err)
+ return nil, err
+ }
+ return res, nil
+ }
+}
+
+// CloseIdleConnections closes any connections which were previously
+// connected from previous requests but are now sitting idle.
+// It does not interrupt any connections currently in use.
+func (t *Transport) CloseIdleConnections() {
+ if cp, ok := t.connPool().(clientConnPoolIdleCloser); ok {
+ cp.closeIdleConnections()
+ }
+}
+
+var (
+ errClientConnClosed = errors.New("http2: client conn is closed")
+ errClientConnUnusable = errors.New("http2: client conn not usable")
+)
+
+func shouldRetryRequest(req *http.Request, err error) bool {
+ // TODO: retry GET requests (no bodies) more aggressively, if shutdown
+ // before response.
+ return err == errClientConnUnusable
+}
+
+func (t *Transport) dialClientConn(addr string, singleUse bool) (*ClientConn, error) {
+ host, _, err := net.SplitHostPort(addr)
+ if err != nil {
+ return nil, err
+ }
+ tconn, err := t.dialTLS()("tcp", addr, t.newTLSConfig(host))
+ if err != nil {
+ return nil, err
+ }
+ return t.newClientConn(tconn, singleUse)
+}
+
+func (t *Transport) newTLSConfig(host string) *tls.Config {
+ cfg := new(tls.Config)
+ if t.TLSClientConfig != nil {
+ *cfg = *t.TLSClientConfig
+ }
+ if !strSliceContains(cfg.NextProtos, NextProtoTLS) {
+ cfg.NextProtos = append([]string{NextProtoTLS}, cfg.NextProtos...)
+ }
+ if cfg.ServerName == "" {
+ cfg.ServerName = host
+ }
+ return cfg
+}
+
+func (t *Transport) dialTLS() func(string, string, *tls.Config) (net.Conn, error) {
+ if t.DialTLS != nil {
+ return t.DialTLS
+ }
+ return t.dialTLSDefault
+}
+
+func (t *Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) {
+ cn, err := tls.Dial(network, addr, cfg)
+ if err != nil {
+ return nil, err
+ }
+ if err := cn.Handshake(); err != nil {
+ return nil, err
+ }
+ if !cfg.InsecureSkipVerify {
+ if err := cn.VerifyHostname(cfg.ServerName); err != nil {
+ return nil, err
+ }
+ }
+ state := cn.ConnectionState()
+ if p := state.NegotiatedProtocol; p != NextProtoTLS {
+ return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
+ }
+ if !state.NegotiatedProtocolIsMutual {
+ return nil, errors.New("http2: could not negotiate protocol mutually")
+ }
+ return cn, nil
+}
+
+// disableKeepAlives reports whether connections should be closed as
+// soon as possible after handling the first request.
+func (t *Transport) disableKeepAlives() bool {
+ return t.t1 != nil && t.t1.DisableKeepAlives
+}
+
+func (t *Transport) expectContinueTimeout() time.Duration {
+ if t.t1 == nil {
+ return 0
+ }
+ return transportExpectContinueTimeout(t.t1)
+}
+
+func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) {
+ return t.newClientConn(c, false)
+}
+
+func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) {
+ cc := &ClientConn{
+ t: t,
+ tconn: c,
+ readerDone: make(chan struct{}),
+ nextStreamID: 1,
+ maxFrameSize: 16 << 10, // spec default
+ initialWindowSize: 65535, // spec default
+ maxConcurrentStreams: 1000, // "infinite", per spec. 1000 seems good enough.
+ streams: make(map[uint32]*clientStream),
+ singleUse: singleUse,
+ wantSettingsAck: true,
+ }
+ if VerboseLogs {
+ t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr())
+ }
+
+ cc.cond = sync.NewCond(&cc.mu)
+ cc.flow.add(int32(initialWindowSize))
+
+ // TODO: adjust this writer size to account for frame size +
+ // MTU + crypto/tls record padding.
+ cc.bw = bufio.NewWriter(stickyErrWriter{c, &cc.werr})
+ cc.br = bufio.NewReader(c)
+ cc.fr = NewFramer(cc.bw, cc.br)
+ cc.fr.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil)
+ cc.fr.MaxHeaderListSize = t.maxHeaderListSize()
+
+ // TODO: SetMaxDynamicTableSize, SetMaxDynamicTableSizeLimit on
+ // henc in response to SETTINGS frames?
+ cc.henc = hpack.NewEncoder(&cc.hbuf)
+
+ if cs, ok := c.(connectionStater); ok {
+ state := cs.ConnectionState()
+ cc.tlsState = &state
+ }
+
+ initialSettings := []Setting{
+ {ID: SettingEnablePush, Val: 0},
+ {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow},
+ }
+ if max := t.maxHeaderListSize(); max != 0 {
+ initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max})
+ }
+
+ cc.bw.Write(clientPreface)
+ cc.fr.WriteSettings(initialSettings...)
+ cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow)
+ cc.inflow.add(transportDefaultConnFlow + initialWindowSize)
+ cc.bw.Flush()
+ if cc.werr != nil {
+ return nil, cc.werr
+ }
+
+ go cc.readLoop()
+ return cc, nil
+}
+
+func (cc *ClientConn) setGoAway(f *GoAwayFrame) {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+
+ old := cc.goAway
+ cc.goAway = f
+
+ // Merge the previous and current GoAway error frames.
+ if cc.goAwayDebug == "" {
+ cc.goAwayDebug = string(f.DebugData())
+ }
+ if old != nil && old.ErrCode != ErrCodeNo {
+ cc.goAway.ErrCode = old.ErrCode
+ }
+}
+
+func (cc *ClientConn) CanTakeNewRequest() bool {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+ return cc.canTakeNewRequestLocked()
+}
+
+func (cc *ClientConn) canTakeNewRequestLocked() bool {
+ if cc.singleUse && cc.nextStreamID > 1 {
+ return false
+ }
+ return cc.goAway == nil && !cc.closed &&
+ int64(len(cc.streams)+1) < int64(cc.maxConcurrentStreams) &&
+ cc.nextStreamID < math.MaxInt32
+}
+
+func (cc *ClientConn) closeIfIdle() {
+ cc.mu.Lock()
+ if len(cc.streams) > 0 {
+ cc.mu.Unlock()
+ return
+ }
+ cc.closed = true
+ nextID := cc.nextStreamID
+ // TODO: do clients send GOAWAY too? maybe? Just Close:
+ cc.mu.Unlock()
+
+ if VerboseLogs {
+ cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2)
+ }
+ cc.tconn.Close()
+}
+
+const maxAllocFrameSize = 512 << 10
+
+// frameBuffer returns a scratch buffer suitable for writing DATA frames.
+// They're capped at the min of the peer's max frame size or 512KB
+// (kinda arbitrarily), but definitely capped so we don't allocate 4GB
+// bufers.
+func (cc *ClientConn) frameScratchBuffer() []byte {
+ cc.mu.Lock()
+ size := cc.maxFrameSize
+ if size > maxAllocFrameSize {
+ size = maxAllocFrameSize
+ }
+ for i, buf := range cc.freeBuf {
+ if len(buf) >= int(size) {
+ cc.freeBuf[i] = nil
+ cc.mu.Unlock()
+ return buf[:size]
+ }
+ }
+ cc.mu.Unlock()
+ return make([]byte, size)
+}
+
+func (cc *ClientConn) putFrameScratchBuffer(buf []byte) {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+ const maxBufs = 4 // arbitrary; 4 concurrent requests per conn? investigate.
+ if len(cc.freeBuf) < maxBufs {
+ cc.freeBuf = append(cc.freeBuf, buf)
+ return
+ }
+ for i, old := range cc.freeBuf {
+ if old == nil {
+ cc.freeBuf[i] = buf
+ return
+ }
+ }
+ // forget about it.
+}
+
+// errRequestCanceled is a copy of net/http's errRequestCanceled because it's not
+// exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests.
+var errRequestCanceled = errors.New("net/http: request canceled")
+
+func commaSeparatedTrailers(req *http.Request) (string, error) {
+ keys := make([]string, 0, len(req.Trailer))
+ for k := range req.Trailer {
+ k = http.CanonicalHeaderKey(k)
+ switch k {
+ case "Transfer-Encoding", "Trailer", "Content-Length":
+ return "", &badStringError{"invalid Trailer key", k}
+ }
+ keys = append(keys, k)
+ }
+ if len(keys) > 0 {
+ sort.Strings(keys)
+ // TODO: could do better allocation-wise here, but trailers are rare,
+ // so being lazy for now.
+ return strings.Join(keys, ","), nil
+ }
+ return "", nil
+}
+
+func (cc *ClientConn) responseHeaderTimeout() time.Duration {
+ if cc.t.t1 != nil {
+ return cc.t.t1.ResponseHeaderTimeout
+ }
+ // No way to do this (yet?) with just an http2.Transport. Probably
+ // no need. Request.Cancel this is the new way. We only need to support
+ // this for compatibility with the old http.Transport fields when
+ // we're doing transparent http2.
+ return 0
+}
+
+// checkConnHeaders checks whether req has any invalid connection-level headers.
+// per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields.
+// Certain headers are special-cased as okay but not transmitted later.
+func checkConnHeaders(req *http.Request) error {
+ if v := req.Header.Get("Upgrade"); v != "" {
+ return errors.New("http2: invalid Upgrade request header")
+ }
+ if v := req.Header.Get("Transfer-Encoding"); (v != "" && v != "chunked") || len(req.Header["Transfer-Encoding"]) > 1 {
+ return errors.New("http2: invalid Transfer-Encoding request header")
+ }
+ if v := req.Header.Get("Connection"); (v != "" && v != "close" && v != "keep-alive") || len(req.Header["Connection"]) > 1 {
+ return errors.New("http2: invalid Connection request header")
+ }
+ return nil
+}
+
+func bodyAndLength(req *http.Request) (body io.Reader, contentLen int64) {
+ body = req.Body
+ if body == nil {
+ return nil, 0
+ }
+ if req.ContentLength != 0 {
+ return req.Body, req.ContentLength
+ }
+
+ // We have a body but a zero content length. Test to see if
+ // it's actually zero or just unset.
+ var buf [1]byte
+ n, rerr := io.ReadFull(body, buf[:])
+ if rerr != nil && rerr != io.EOF {
+ return errorReader{rerr}, -1
+ }
+ if n == 1 {
+ // Oh, guess there is data in this Body Reader after all.
+ // The ContentLength field just wasn't set.
+ // Stich the Body back together again, re-attaching our
+ // consumed byte.
+ return io.MultiReader(bytes.NewReader(buf[:]), body), -1
+ }
+ // Body is actually zero bytes.
+ return nil, 0
+}
+
+func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) {
+ if err := checkConnHeaders(req); err != nil {
+ return nil, err
+ }
+
+ trailers, err := commaSeparatedTrailers(req)
+ if err != nil {
+ return nil, err
+ }
+ hasTrailers := trailers != ""
+
+ body, contentLen := bodyAndLength(req)
+ hasBody := body != nil
+
+ cc.mu.Lock()
+ cc.lastActive = time.Now()
+ if cc.closed || !cc.canTakeNewRequestLocked() {
+ cc.mu.Unlock()
+ return nil, errClientConnUnusable
+ }
+
+ // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
+ var requestedGzip bool
+ if !cc.t.disableCompression() &&
+ req.Header.Get("Accept-Encoding") == "" &&
+ req.Header.Get("Range") == "" &&
+ req.Method != "HEAD" {
+ // Request gzip only, not deflate. Deflate is ambiguous and
+ // not as universally supported anyway.
+ // See: http://www.gzip.org/zlib/zlib_faq.html#faq38
+ //
+ // Note that we don't request this for HEAD requests,
+ // due to a bug in nginx:
+ // http://trac.nginx.org/nginx/ticket/358
+ // https://golang.org/issue/5522
+ //
+ // We don't request gzip if the request is for a range, since
+ // auto-decoding a portion of a gzipped document will just fail
+ // anyway. See https://golang.org/issue/8923
+ requestedGzip = true
+ }
+
+ // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is
+ // sent by writeRequestBody below, along with any Trailers,
+ // again in form HEADERS{1}, CONTINUATION{0,})
+ hdrs, err := cc.encodeHeaders(req, requestedGzip, trailers, contentLen)
+ if err != nil {
+ cc.mu.Unlock()
+ return nil, err
+ }
+
+ cs := cc.newStream()
+ cs.req = req
+ cs.trace = requestTrace(req)
+ cs.requestedGzip = requestedGzip
+ bodyWriter := cc.t.getBodyWriterState(cs, body)
+ cs.on100 = bodyWriter.on100
+
+ cc.wmu.Lock()
+ endStream := !hasBody && !hasTrailers
+ werr := cc.writeHeaders(cs.ID, endStream, hdrs)
+ cc.wmu.Unlock()
+ traceWroteHeaders(cs.trace)
+ cc.mu.Unlock()
+
+ if werr != nil {
+ if hasBody {
+ req.Body.Close() // per RoundTripper contract
+ bodyWriter.cancel()
+ }
+ cc.forgetStreamID(cs.ID)
+ // Don't bother sending a RST_STREAM (our write already failed;
+ // no need to keep writing)
+ traceWroteRequest(cs.trace, werr)
+ return nil, werr
+ }
+
+ var respHeaderTimer <-chan time.Time
+ if hasBody {
+ bodyWriter.scheduleBodyWrite()
+ } else {
+ traceWroteRequest(cs.trace, nil)
+ if d := cc.responseHeaderTimeout(); d != 0 {
+ timer := time.NewTimer(d)
+ defer timer.Stop()
+ respHeaderTimer = timer.C
+ }
+ }
+
+ readLoopResCh := cs.resc
+ bodyWritten := false
+ ctx := reqContext(req)
+
+ handleReadLoopResponse := func(re resAndError) (*http.Response, error) {
+ res := re.res
+ if re.err != nil || res.StatusCode > 299 {
+ // On error or status code 3xx, 4xx, 5xx, etc abort any
+ // ongoing write, assuming that the server doesn't care
+ // about our request body. If the server replied with 1xx or
+ // 2xx, however, then assume the server DOES potentially
+ // want our body (e.g. full-duplex streaming:
+ // golang.org/issue/13444). If it turns out the server
+ // doesn't, they'll RST_STREAM us soon enough. This is a
+ // heuristic to avoid adding knobs to Transport. Hopefully
+ // we can keep it.
+ bodyWriter.cancel()
+ cs.abortRequestBodyWrite(errStopReqBodyWrite)
+ }
+ if re.err != nil {
+ cc.forgetStreamID(cs.ID)
+ return nil, re.err
+ }
+ res.Request = req
+ res.TLS = cc.tlsState
+ return res, nil
+ }
+
+ for {
+ select {
+ case re := <-readLoopResCh:
+ return handleReadLoopResponse(re)
+ case <-respHeaderTimer:
+ cc.forgetStreamID(cs.ID)
+ if !hasBody || bodyWritten {
+ cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ } else {
+ bodyWriter.cancel()
+ cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel)
+ }
+ return nil, errTimeout
+ case <-ctx.Done():
+ cc.forgetStreamID(cs.ID)
+ if !hasBody || bodyWritten {
+ cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ } else {
+ bodyWriter.cancel()
+ cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel)
+ }
+ return nil, ctx.Err()
+ case <-req.Cancel:
+ cc.forgetStreamID(cs.ID)
+ if !hasBody || bodyWritten {
+ cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ } else {
+ bodyWriter.cancel()
+ cs.abortRequestBodyWrite(errStopReqBodyWriteAndCancel)
+ }
+ return nil, errRequestCanceled
+ case <-cs.peerReset:
+ // processResetStream already removed the
+ // stream from the streams map; no need for
+ // forgetStreamID.
+ return nil, cs.resetErr
+ case err := <-bodyWriter.resc:
+ // Prefer the read loop's response, if available. Issue 16102.
+ select {
+ case re := <-readLoopResCh:
+ return handleReadLoopResponse(re)
+ default:
+ }
+ if err != nil {
+ return nil, err
+ }
+ bodyWritten = true
+ if d := cc.responseHeaderTimeout(); d != 0 {
+ timer := time.NewTimer(d)
+ defer timer.Stop()
+ respHeaderTimer = timer.C
+ }
+ }
+ }
+}
+
+// requires cc.wmu be held
+func (cc *ClientConn) writeHeaders(streamID uint32, endStream bool, hdrs []byte) error {
+ first := true // first frame written (HEADERS is first, then CONTINUATION)
+ frameSize := int(cc.maxFrameSize)
+ for len(hdrs) > 0 && cc.werr == nil {
+ chunk := hdrs
+ if len(chunk) > frameSize {
+ chunk = chunk[:frameSize]
+ }
+ hdrs = hdrs[len(chunk):]
+ endHeaders := len(hdrs) == 0
+ if first {
+ cc.fr.WriteHeaders(HeadersFrameParam{
+ StreamID: streamID,
+ BlockFragment: chunk,
+ EndStream: endStream,
+ EndHeaders: endHeaders,
+ })
+ first = false
+ } else {
+ cc.fr.WriteContinuation(streamID, endHeaders, chunk)
+ }
+ }
+ // TODO(bradfitz): this Flush could potentially block (as
+ // could the WriteHeaders call(s) above), which means they
+ // wouldn't respond to Request.Cancel being readable. That's
+ // rare, but this should probably be in a goroutine.
+ cc.bw.Flush()
+ return cc.werr
+}
+
+// internal error values; they don't escape to callers
+var (
+ // abort request body write; don't send cancel
+ errStopReqBodyWrite = errors.New("http2: aborting request body write")
+
+ // abort request body write, but send stream reset of cancel.
+ errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
+)
+
+func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
+ cc := cs.cc
+ sentEnd := false // whether we sent the final DATA frame w/ END_STREAM
+ buf := cc.frameScratchBuffer()
+ defer cc.putFrameScratchBuffer(buf)
+
+ defer func() {
+ traceWroteRequest(cs.trace, err)
+ // TODO: write h12Compare test showing whether
+ // Request.Body is closed by the Transport,
+ // and in multiple cases: server replies <=299 and >299
+ // while still writing request body
+ cerr := bodyCloser.Close()
+ if err == nil {
+ err = cerr
+ }
+ }()
+
+ req := cs.req
+ hasTrailers := req.Trailer != nil
+
+ var sawEOF bool
+ for !sawEOF {
+ n, err := body.Read(buf)
+ if err == io.EOF {
+ sawEOF = true
+ err = nil
+ } else if err != nil {
+ return err
+ }
+
+ remain := buf[:n]
+ for len(remain) > 0 && err == nil {
+ var allowed int32
+ allowed, err = cs.awaitFlowControl(len(remain))
+ switch {
+ case err == errStopReqBodyWrite:
+ return err
+ case err == errStopReqBodyWriteAndCancel:
+ cc.writeStreamReset(cs.ID, ErrCodeCancel, nil)
+ return err
+ case err != nil:
+ return err
+ }
+ cc.wmu.Lock()
+ data := remain[:allowed]
+ remain = remain[allowed:]
+ sentEnd = sawEOF && len(remain) == 0 && !hasTrailers
+ err = cc.fr.WriteData(cs.ID, sentEnd, data)
+ if err == nil {
+ // TODO(bradfitz): this flush is for latency, not bandwidth.
+ // Most requests won't need this. Make this opt-in or opt-out?
+ // Use some heuristic on the body type? Nagel-like timers?
+ // Based on 'n'? Only last chunk of this for loop, unless flow control
+ // tokens are low? For now, always:
+ err = cc.bw.Flush()
+ }
+ cc.wmu.Unlock()
+ }
+ if err != nil {
+ return err
+ }
+ }
+
+ var trls []byte
+ if !sentEnd && hasTrailers {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+ trls = cc.encodeTrailers(req)
+ }
+
+ cc.wmu.Lock()
+ defer cc.wmu.Unlock()
+
+ // Avoid forgetting to send an END_STREAM if the encoded
+ // trailers are 0 bytes. Both results produce and END_STREAM.
+ if len(trls) > 0 {
+ err = cc.writeHeaders(cs.ID, true, trls)
+ } else {
+ err = cc.fr.WriteData(cs.ID, true, nil)
+ }
+ if ferr := cc.bw.Flush(); ferr != nil && err == nil {
+ err = ferr
+ }
+ return err
+}
+
+// awaitFlowControl waits for [1, min(maxBytes, cc.cs.maxFrameSize)] flow
+// control tokens from the server.
+// It returns either the non-zero number of tokens taken or an error
+// if the stream is dead.
+func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) {
+ cc := cs.cc
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+ for {
+ if cc.closed {
+ return 0, errClientConnClosed
+ }
+ if cs.stopReqBody != nil {
+ return 0, cs.stopReqBody
+ }
+ if err := cs.checkResetOrDone(); err != nil {
+ return 0, err
+ }
+ if a := cs.flow.available(); a > 0 {
+ take := a
+ if int(take) > maxBytes {
+
+ take = int32(maxBytes) // can't truncate int; take is int32
+ }
+ if take > int32(cc.maxFrameSize) {
+ take = int32(cc.maxFrameSize)
+ }
+ cs.flow.take(take)
+ return take, nil
+ }
+ cc.cond.Wait()
+ }
+}
+
+type badStringError struct {
+ what string
+ str string
+}
+
+func (e *badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) }
+
+// requires cc.mu be held.
+func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) {
+ cc.hbuf.Reset()
+
+ host := req.Host
+ if host == "" {
+ host = req.URL.Host
+ }
+
+ // Check for any invalid headers and return an error before we
+ // potentially pollute our hpack state. (We want to be able to
+ // continue to reuse the hpack encoder for future requests)
+ for k, vv := range req.Header {
+ if !httplex.ValidHeaderFieldName(k) {
+ return nil, fmt.Errorf("invalid HTTP header name %q", k)
+ }
+ for _, v := range vv {
+ if !httplex.ValidHeaderFieldValue(v) {
+ return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
+ }
+ }
+ }
+
+ // 8.1.2.3 Request Pseudo-Header Fields
+ // The :path pseudo-header field includes the path and query parts of the
+ // target URI (the path-absolute production and optionally a '?' character
+ // followed by the query production (see Sections 3.3 and 3.4 of
+ // [RFC3986]).
+ cc.writeHeader(":authority", host)
+ cc.writeHeader(":method", req.Method)
+ if req.Method != "CONNECT" {
+ cc.writeHeader(":path", req.URL.RequestURI())
+ cc.writeHeader(":scheme", "https")
+ }
+ if trailers != "" {
+ cc.writeHeader("trailer", trailers)
+ }
+
+ var didUA bool
+ for k, vv := range req.Header {
+ lowKey := strings.ToLower(k)
+ switch lowKey {
+ case "host", "content-length":
+ // Host is :authority, already sent.
+ // Content-Length is automatic, set below.
+ continue
+ case "connection", "proxy-connection", "transfer-encoding", "upgrade", "keep-alive":
+ // Per 8.1.2.2 Connection-Specific Header
+ // Fields, don't send connection-specific
+ // fields. We have already checked if any
+ // are error-worthy so just ignore the rest.
+ continue
+ case "user-agent":
+ // Match Go's http1 behavior: at most one
+ // User-Agent. If set to nil or empty string,
+ // then omit it. Otherwise if not mentioned,
+ // include the default (below).
+ didUA = true
+ if len(vv) < 1 {
+ continue
+ }
+ vv = vv[:1]
+ if vv[0] == "" {
+ continue
+ }
+ }
+ for _, v := range vv {
+ cc.writeHeader(lowKey, v)
+ }
+ }
+ if shouldSendReqContentLength(req.Method, contentLength) {
+ cc.writeHeader("content-length", strconv.FormatInt(contentLength, 10))
+ }
+ if addGzipHeader {
+ cc.writeHeader("accept-encoding", "gzip")
+ }
+ if !didUA {
+ cc.writeHeader("user-agent", defaultUserAgent)
+ }
+ return cc.hbuf.Bytes(), nil
+}
+
+// shouldSendReqContentLength reports whether the http2.Transport should send
+// a "content-length" request header. This logic is basically a copy of the net/http
+// transferWriter.shouldSendContentLength.
+// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
+// -1 means unknown.
+func shouldSendReqContentLength(method string, contentLength int64) bool {
+ if contentLength > 0 {
+ return true
+ }
+ if contentLength < 0 {
+ return false
+ }
+ // For zero bodies, whether we send a content-length depends on the method.
+ // It also kinda doesn't matter for http2 either way, with END_STREAM.
+ switch method {
+ case "POST", "PUT", "PATCH":
+ return true
+ default:
+ return false
+ }
+}
+
+// requires cc.mu be held.
+func (cc *ClientConn) encodeTrailers(req *http.Request) []byte {
+ cc.hbuf.Reset()
+ for k, vv := range req.Trailer {
+ // Transfer-Encoding, etc.. have already been filter at the
+ // start of RoundTrip
+ lowKey := strings.ToLower(k)
+ for _, v := range vv {
+ cc.writeHeader(lowKey, v)
+ }
+ }
+ return cc.hbuf.Bytes()
+}
+
+func (cc *ClientConn) writeHeader(name, value string) {
+ if VerboseLogs {
+ log.Printf("http2: Transport encoding header %q = %q", name, value)
+ }
+ cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
+}
+
+type resAndError struct {
+ res *http.Response
+ err error
+}
+
+// requires cc.mu be held.
+func (cc *ClientConn) newStream() *clientStream {
+ cs := &clientStream{
+ cc: cc,
+ ID: cc.nextStreamID,
+ resc: make(chan resAndError, 1),
+ peerReset: make(chan struct{}),
+ done: make(chan struct{}),
+ }
+ cs.flow.add(int32(cc.initialWindowSize))
+ cs.flow.setConnFlow(&cc.flow)
+ cs.inflow.add(transportDefaultStreamFlow)
+ cs.inflow.setConnFlow(&cc.inflow)
+ cc.nextStreamID += 2
+ cc.streams[cs.ID] = cs
+ return cs
+}
+
+func (cc *ClientConn) forgetStreamID(id uint32) {
+ cc.streamByID(id, true)
+}
+
+func (cc *ClientConn) streamByID(id uint32, andRemove bool) *clientStream {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+ cs := cc.streams[id]
+ if andRemove && cs != nil && !cc.closed {
+ cc.lastActive = time.Now()
+ delete(cc.streams, id)
+ close(cs.done)
+ cc.cond.Broadcast() // wake up checkResetOrDone via clientStream.awaitFlowControl
+ }
+ return cs
+}
+
+// clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop.
+type clientConnReadLoop struct {
+ cc *ClientConn
+ activeRes map[uint32]*clientStream // keyed by streamID
+ closeWhenIdle bool
+}
+
+// readLoop runs in its own goroutine and reads and dispatches frames.
+func (cc *ClientConn) readLoop() {
+ rl := &clientConnReadLoop{
+ cc: cc,
+ activeRes: make(map[uint32]*clientStream),
+ }
+
+ defer rl.cleanup()
+ cc.readerErr = rl.run()
+ if ce, ok := cc.readerErr.(ConnectionError); ok {
+ cc.wmu.Lock()
+ cc.fr.WriteGoAway(0, ErrCode(ce), nil)
+ cc.wmu.Unlock()
+ }
+}
+
+// GoAwayError is returned by the Transport when the server closes the
+// TCP connection after sending a GOAWAY frame.
+type GoAwayError struct {
+ LastStreamID uint32
+ ErrCode ErrCode
+ DebugData string
+}
+
+func (e GoAwayError) Error() string {
+ return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
+ e.LastStreamID, e.ErrCode, e.DebugData)
+}
+
+func isEOFOrNetReadError(err error) bool {
+ if err == io.EOF {
+ return true
+ }
+ ne, ok := err.(*net.OpError)
+ return ok && ne.Op == "read"
+}
+
+func (rl *clientConnReadLoop) cleanup() {
+ cc := rl.cc
+ defer cc.tconn.Close()
+ defer cc.t.connPool().MarkDead(cc)
+ defer close(cc.readerDone)
+
+ // Close any response bodies if the server closes prematurely.
+ // TODO: also do this if we've written the headers but not
+ // gotten a response yet.
+ err := cc.readerErr
+ cc.mu.Lock()
+ if cc.goAway != nil && isEOFOrNetReadError(err) {
+ err = GoAwayError{
+ LastStreamID: cc.goAway.LastStreamID,
+ ErrCode: cc.goAway.ErrCode,
+ DebugData: cc.goAwayDebug,
+ }
+ } else if err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ }
+ for _, cs := range rl.activeRes {
+ cs.bufPipe.CloseWithError(err)
+ }
+ for _, cs := range cc.streams {
+ select {
+ case cs.resc <- resAndError{err: err}:
+ default:
+ }
+ close(cs.done)
+ }
+ cc.closed = true
+ cc.cond.Broadcast()
+ cc.mu.Unlock()
+}
+
+func (rl *clientConnReadLoop) run() error {
+ cc := rl.cc
+ rl.closeWhenIdle = cc.t.disableKeepAlives() || cc.singleUse
+ gotReply := false // ever saw a HEADERS reply
+ gotSettings := false
+ for {
+ f, err := cc.fr.ReadFrame()
+ if err != nil {
+ cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err)
+ }
+ if se, ok := err.(StreamError); ok {
+ if cs := cc.streamByID(se.StreamID, true /*ended; remove it*/); cs != nil {
+ cs.cc.writeStreamReset(cs.ID, se.Code, err)
+ if se.Cause == nil {
+ se.Cause = cc.fr.errDetail
+ }
+ rl.endStreamError(cs, se)
+ }
+ continue
+ } else if err != nil {
+ return err
+ }
+ if VerboseLogs {
+ cc.vlogf("http2: Transport received %s", summarizeFrame(f))
+ }
+ if !gotSettings {
+ if _, ok := f.(*SettingsFrame); !ok {
+ cc.logf("protocol error: received %T before a SETTINGS frame", f)
+ return ConnectionError(ErrCodeProtocol)
+ }
+ gotSettings = true
+ }
+ maybeIdle := false // whether frame might transition us to idle
+
+ switch f := f.(type) {
+ case *MetaHeadersFrame:
+ err = rl.processHeaders(f)
+ maybeIdle = true
+ gotReply = true
+ case *DataFrame:
+ err = rl.processData(f)
+ maybeIdle = true
+ case *GoAwayFrame:
+ err = rl.processGoAway(f)
+ maybeIdle = true
+ case *RSTStreamFrame:
+ err = rl.processResetStream(f)
+ maybeIdle = true
+ case *SettingsFrame:
+ err = rl.processSettings(f)
+ case *PushPromiseFrame:
+ err = rl.processPushPromise(f)
+ case *WindowUpdateFrame:
+ err = rl.processWindowUpdate(f)
+ case *PingFrame:
+ err = rl.processPing(f)
+ default:
+ cc.logf("Transport: unhandled response frame type %T", f)
+ }
+ if err != nil {
+ if VerboseLogs {
+ cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err)
+ }
+ return err
+ }
+ if rl.closeWhenIdle && gotReply && maybeIdle && len(rl.activeRes) == 0 {
+ cc.closeIfIdle()
+ }
+ }
+}
+
+func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error {
+ cc := rl.cc
+ cs := cc.streamByID(f.StreamID, f.StreamEnded())
+ if cs == nil {
+ // We'd get here if we canceled a request while the
+ // server had its response still in flight. So if this
+ // was just something we canceled, ignore it.
+ return nil
+ }
+ if !cs.firstByte {
+ if cs.trace != nil {
+ // TODO(bradfitz): move first response byte earlier,
+ // when we first read the 9 byte header, not waiting
+ // until all the HEADERS+CONTINUATION frames have been
+ // merged. This works for now.
+ traceFirstResponseByte(cs.trace)
+ }
+ cs.firstByte = true
+ }
+ if !cs.pastHeaders {
+ cs.pastHeaders = true
+ } else {
+ return rl.processTrailers(cs, f)
+ }
+
+ res, err := rl.handleResponse(cs, f)
+ if err != nil {
+ if _, ok := err.(ConnectionError); ok {
+ return err
+ }
+ // Any other error type is a stream error.
+ cs.cc.writeStreamReset(f.StreamID, ErrCodeProtocol, err)
+ cs.resc <- resAndError{err: err}
+ return nil // return nil from process* funcs to keep conn alive
+ }
+ if res == nil {
+ // (nil, nil) special case. See handleResponse docs.
+ return nil
+ }
+ if res.Body != noBody {
+ rl.activeRes[cs.ID] = cs
+ }
+ cs.resTrailer = &res.Trailer
+ cs.resc <- resAndError{res: res}
+ return nil
+}
+
+// may return error types nil, or ConnectionError. Any other error value
+// is a StreamError of type ErrCodeProtocol. The returned error in that case
+// is the detail.
+//
+// As a special case, handleResponse may return (nil, nil) to skip the
+// frame (currently only used for 100 expect continue). This special
+// case is going away after Issue 13851 is fixed.
+func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFrame) (*http.Response, error) {
+ if f.Truncated {
+ return nil, errResponseHeaderListSize
+ }
+
+ status := f.PseudoValue("status")
+ if status == "" {
+ return nil, errors.New("missing status pseudo header")
+ }
+ statusCode, err := strconv.Atoi(status)
+ if err != nil {
+ return nil, errors.New("malformed non-numeric status pseudo header")
+ }
+
+ if statusCode == 100 {
+ traceGot100Continue(cs.trace)
+ if cs.on100 != nil {
+ cs.on100() // forces any write delay timer to fire
+ }
+ cs.pastHeaders = false // do it all again
+ return nil, nil
+ }
+
+ header := make(http.Header)
+ res := &http.Response{
+ Proto: "HTTP/2.0",
+ ProtoMajor: 2,
+ Header: header,
+ StatusCode: statusCode,
+ Status: status + " " + http.StatusText(statusCode),
+ }
+ for _, hf := range f.RegularFields() {
+ key := http.CanonicalHeaderKey(hf.Name)
+ if key == "Trailer" {
+ t := res.Trailer
+ if t == nil {
+ t = make(http.Header)
+ res.Trailer = t
+ }
+ foreachHeaderElement(hf.Value, func(v string) {
+ t[http.CanonicalHeaderKey(v)] = nil
+ })
+ } else {
+ header[key] = append(header[key], hf.Value)
+ }
+ }
+
+ streamEnded := f.StreamEnded()
+ isHead := cs.req.Method == "HEAD"
+ if !streamEnded || isHead {
+ res.ContentLength = -1
+ if clens := res.Header["Content-Length"]; len(clens) == 1 {
+ if clen64, err := strconv.ParseInt(clens[0], 10, 64); err == nil {
+ res.ContentLength = clen64
+ } else {
+ // TODO: care? unlike http/1, it won't mess up our framing, so it's
+ // more safe smuggling-wise to ignore.
+ }
+ } else if len(clens) > 1 {
+ // TODO: care? unlike http/1, it won't mess up our framing, so it's
+ // more safe smuggling-wise to ignore.
+ }
+ }
+
+ if streamEnded || isHead {
+ res.Body = noBody
+ return res, nil
+ }
+
+ buf := new(bytes.Buffer) // TODO(bradfitz): recycle this garbage
+ cs.bufPipe = pipe{b: buf}
+ cs.bytesRemain = res.ContentLength
+ res.Body = transportResponseBody{cs}
+ go cs.awaitRequestCancel(cs.req)
+
+ if cs.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" {
+ res.Header.Del("Content-Encoding")
+ res.Header.Del("Content-Length")
+ res.ContentLength = -1
+ res.Body = &gzipReader{body: res.Body}
+ setResponseUncompressed(res)
+ }
+ return res, nil
+}
+
+func (rl *clientConnReadLoop) processTrailers(cs *clientStream, f *MetaHeadersFrame) error {
+ if cs.pastTrailers {
+ // Too many HEADERS frames for this stream.
+ return ConnectionError(ErrCodeProtocol)
+ }
+ cs.pastTrailers = true
+ if !f.StreamEnded() {
+ // We expect that any headers for trailers also
+ // has END_STREAM.
+ return ConnectionError(ErrCodeProtocol)
+ }
+ if len(f.PseudoFields()) > 0 {
+ // No pseudo header fields are defined for trailers.
+ // TODO: ConnectionError might be overly harsh? Check.
+ return ConnectionError(ErrCodeProtocol)
+ }
+
+ trailer := make(http.Header)
+ for _, hf := range f.RegularFields() {
+ key := http.CanonicalHeaderKey(hf.Name)
+ trailer[key] = append(trailer[key], hf.Value)
+ }
+ cs.trailer = trailer
+
+ rl.endStream(cs)
+ return nil
+}
+
+// transportResponseBody is the concrete type of Transport.RoundTrip's
+// Response.Body. It is an io.ReadCloser. On Read, it reads from cs.body.
+// On Close it sends RST_STREAM if EOF wasn't already seen.
+type transportResponseBody struct {
+ cs *clientStream
+}
+
+func (b transportResponseBody) Read(p []byte) (n int, err error) {
+ cs := b.cs
+ cc := cs.cc
+
+ if cs.readErr != nil {
+ return 0, cs.readErr
+ }
+ n, err = b.cs.bufPipe.Read(p)
+ if cs.bytesRemain != -1 {
+ if int64(n) > cs.bytesRemain {
+ n = int(cs.bytesRemain)
+ if err == nil {
+ err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
+ cc.writeStreamReset(cs.ID, ErrCodeProtocol, err)
+ }
+ cs.readErr = err
+ return int(cs.bytesRemain), err
+ }
+ cs.bytesRemain -= int64(n)
+ if err == io.EOF && cs.bytesRemain > 0 {
+ err = io.ErrUnexpectedEOF
+ cs.readErr = err
+ return n, err
+ }
+ }
+ if n == 0 {
+ // No flow control tokens to send back.
+ return
+ }
+
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+
+ var connAdd, streamAdd int32
+ // Check the conn-level first, before the stream-level.
+ if v := cc.inflow.available(); v < transportDefaultConnFlow/2 {
+ connAdd = transportDefaultConnFlow - v
+ cc.inflow.add(connAdd)
+ }
+ if err == nil { // No need to refresh if the stream is over or failed.
+ // Consider any buffered body data (read from the conn but not
+ // consumed by the client) when computing flow control for this
+ // stream.
+ v := int(cs.inflow.available()) + cs.bufPipe.Len()
+ if v < transportDefaultStreamFlow-transportDefaultStreamMinRefresh {
+ streamAdd = int32(transportDefaultStreamFlow - v)
+ cs.inflow.add(streamAdd)
+ }
+ }
+ if connAdd != 0 || streamAdd != 0 {
+ cc.wmu.Lock()
+ defer cc.wmu.Unlock()
+ if connAdd != 0 {
+ cc.fr.WriteWindowUpdate(0, mustUint31(connAdd))
+ }
+ if streamAdd != 0 {
+ cc.fr.WriteWindowUpdate(cs.ID, mustUint31(streamAdd))
+ }
+ cc.bw.Flush()
+ }
+ return
+}
+
+var errClosedResponseBody = errors.New("http2: response body closed")
+
+func (b transportResponseBody) Close() error {
+ cs := b.cs
+ cc := cs.cc
+
+ serverSentStreamEnd := cs.bufPipe.Err() == io.EOF
+ unread := cs.bufPipe.Len()
+
+ if unread > 0 || !serverSentStreamEnd {
+ cc.mu.Lock()
+ cc.wmu.Lock()
+ if !serverSentStreamEnd {
+ cc.fr.WriteRSTStream(cs.ID, ErrCodeCancel)
+ }
+ // Return connection-level flow control.
+ if unread > 0 {
+ cc.inflow.add(int32(unread))
+ cc.fr.WriteWindowUpdate(0, uint32(unread))
+ }
+ cc.bw.Flush()
+ cc.wmu.Unlock()
+ cc.mu.Unlock()
+ }
+
+ cs.bufPipe.BreakWithError(errClosedResponseBody)
+ return nil
+}
+
+func (rl *clientConnReadLoop) processData(f *DataFrame) error {
+ cc := rl.cc
+ cs := cc.streamByID(f.StreamID, f.StreamEnded())
+ data := f.Data()
+ if cs == nil {
+ cc.mu.Lock()
+ neverSent := cc.nextStreamID
+ cc.mu.Unlock()
+ if f.StreamID >= neverSent {
+ // We never asked for this.
+ cc.logf("http2: Transport received unsolicited DATA frame; closing connection")
+ return ConnectionError(ErrCodeProtocol)
+ }
+ // We probably did ask for this, but canceled. Just ignore it.
+ // TODO: be stricter here? only silently ignore things which
+ // we canceled, but not things which were closed normally
+ // by the peer? Tough without accumulating too much state.
+
+ // But at least return their flow control:
+ if f.Length > 0 {
+ cc.mu.Lock()
+ cc.inflow.add(int32(f.Length))
+ cc.mu.Unlock()
+
+ cc.wmu.Lock()
+ cc.fr.WriteWindowUpdate(0, uint32(f.Length))
+ cc.bw.Flush()
+ cc.wmu.Unlock()
+ }
+ return nil
+ }
+ if f.Length > 0 {
+ if len(data) > 0 && cs.bufPipe.b == nil {
+ // Data frame after it's already closed?
+ cc.logf("http2: Transport received DATA frame for closed stream; closing connection")
+ return ConnectionError(ErrCodeProtocol)
+ }
+
+ // Check connection-level flow control.
+ cc.mu.Lock()
+ if cs.inflow.available() >= int32(f.Length) {
+ cs.inflow.take(int32(f.Length))
+ } else {
+ cc.mu.Unlock()
+ return ConnectionError(ErrCodeFlowControl)
+ }
+ // Return any padded flow control now, since we won't
+ // refund it later on body reads.
+ if pad := int32(f.Length) - int32(len(data)); pad > 0 {
+ cs.inflow.add(pad)
+ cc.inflow.add(pad)
+ cc.wmu.Lock()
+ cc.fr.WriteWindowUpdate(0, uint32(pad))
+ cc.fr.WriteWindowUpdate(cs.ID, uint32(pad))
+ cc.bw.Flush()
+ cc.wmu.Unlock()
+ }
+ cc.mu.Unlock()
+
+ if len(data) > 0 {
+ if _, err := cs.bufPipe.Write(data); err != nil {
+ rl.endStreamError(cs, err)
+ return err
+ }
+ }
+ }
+
+ if f.StreamEnded() {
+ rl.endStream(cs)
+ }
+ return nil
+}
+
+var errInvalidTrailers = errors.New("http2: invalid trailers")
+
+func (rl *clientConnReadLoop) endStream(cs *clientStream) {
+ // TODO: check that any declared content-length matches, like
+ // server.go's (*stream).endStream method.
+ rl.endStreamError(cs, nil)
+}
+
+func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) {
+ var code func()
+ if err == nil {
+ err = io.EOF
+ code = cs.copyTrailers
+ }
+ cs.bufPipe.closeWithErrorAndCode(err, code)
+ delete(rl.activeRes, cs.ID)
+ if isConnectionCloseRequest(cs.req) {
+ rl.closeWhenIdle = true
+ }
+
+ select {
+ case cs.resc <- resAndError{err: err}:
+ default:
+ }
+}
+
+func (cs *clientStream) copyTrailers() {
+ for k, vv := range cs.trailer {
+ t := cs.resTrailer
+ if *t == nil {
+ *t = make(http.Header)
+ }
+ (*t)[k] = vv
+ }
+}
+
+func (rl *clientConnReadLoop) processGoAway(f *GoAwayFrame) error {
+ cc := rl.cc
+ cc.t.connPool().MarkDead(cc)
+ if f.ErrCode != 0 {
+ // TODO: deal with GOAWAY more. particularly the error code
+ cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode)
+ }
+ cc.setGoAway(f)
+ return nil
+}
+
+func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error {
+ cc := rl.cc
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+
+ if f.IsAck() {
+ if cc.wantSettingsAck {
+ cc.wantSettingsAck = false
+ return nil
+ }
+ return ConnectionError(ErrCodeProtocol)
+ }
+
+ err := f.ForeachSetting(func(s Setting) error {
+ switch s.ID {
+ case SettingMaxFrameSize:
+ cc.maxFrameSize = s.Val
+ case SettingMaxConcurrentStreams:
+ cc.maxConcurrentStreams = s.Val
+ case SettingInitialWindowSize:
+ // Values above the maximum flow-control
+ // window size of 2^31-1 MUST be treated as a
+ // connection error (Section 5.4.1) of type
+ // FLOW_CONTROL_ERROR.
+ if s.Val > math.MaxInt32 {
+ return ConnectionError(ErrCodeFlowControl)
+ }
+
+ // Adjust flow control of currently-open
+ // frames by the difference of the old initial
+ // window size and this one.
+ delta := int32(s.Val) - int32(cc.initialWindowSize)
+ for _, cs := range cc.streams {
+ cs.flow.add(delta)
+ }
+ cc.cond.Broadcast()
+
+ cc.initialWindowSize = s.Val
+ default:
+ // TODO(bradfitz): handle more settings? SETTINGS_HEADER_TABLE_SIZE probably.
+ cc.vlogf("Unhandled Setting: %v", s)
+ }
+ return nil
+ })
+ if err != nil {
+ return err
+ }
+
+ cc.wmu.Lock()
+ defer cc.wmu.Unlock()
+
+ cc.fr.WriteSettingsAck()
+ cc.bw.Flush()
+ return cc.werr
+}
+
+func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error {
+ cc := rl.cc
+ cs := cc.streamByID(f.StreamID, false)
+ if f.StreamID != 0 && cs == nil {
+ return nil
+ }
+
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
+
+ fl := &cc.flow
+ if cs != nil {
+ fl = &cs.flow
+ }
+ if !fl.add(int32(f.Increment)) {
+ return ConnectionError(ErrCodeFlowControl)
+ }
+ cc.cond.Broadcast()
+ return nil
+}
+
+func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error {
+ cs := rl.cc.streamByID(f.StreamID, true)
+ if cs == nil {
+ // TODO: return error if server tries to RST_STEAM an idle stream
+ return nil
+ }
+ select {
+ case <-cs.peerReset:
+ // Already reset.
+ // This is the only goroutine
+ // which closes this, so there
+ // isn't a race.
+ default:
+ err := streamError(cs.ID, f.ErrCode)
+ cs.resetErr = err
+ close(cs.peerReset)
+ cs.bufPipe.CloseWithError(err)
+ cs.cc.cond.Broadcast() // wake up checkResetOrDone via clientStream.awaitFlowControl
+ }
+ delete(rl.activeRes, cs.ID)
+ return nil
+}
+
+func (rl *clientConnReadLoop) processPing(f *PingFrame) error {
+ if f.IsAck() {
+ // 6.7 PING: " An endpoint MUST NOT respond to PING frames
+ // containing this flag."
+ return nil
+ }
+ cc := rl.cc
+ cc.wmu.Lock()
+ defer cc.wmu.Unlock()
+ if err := cc.fr.WritePing(true, f.Data); err != nil {
+ return err
+ }
+ return cc.bw.Flush()
+}
+
+func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error {
+ // We told the peer we don't want them.
+ // Spec says:
+ // "PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH
+ // setting of the peer endpoint is set to 0. An endpoint that
+ // has set this setting and has received acknowledgement MUST
+ // treat the receipt of a PUSH_PROMISE frame as a connection
+ // error (Section 5.4.1) of type PROTOCOL_ERROR."
+ return ConnectionError(ErrCodeProtocol)
+}
+
+func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) {
+ // TODO: map err to more interesting error codes, once the
+ // HTTP community comes up with some. But currently for
+ // RST_STREAM there's no equivalent to GOAWAY frame's debug
+ // data, and the error codes are all pretty vague ("cancel").
+ cc.wmu.Lock()
+ cc.fr.WriteRSTStream(streamID, code)
+ cc.bw.Flush()
+ cc.wmu.Unlock()
+}
+
+var (
+ errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
+ errPseudoTrailers = errors.New("http2: invalid pseudo header in trailers")
+)
+
+func (cc *ClientConn) logf(format string, args ...interface{}) {
+ cc.t.logf(format, args...)
+}
+
+func (cc *ClientConn) vlogf(format string, args ...interface{}) {
+ cc.t.vlogf(format, args...)
+}
+
+func (t *Transport) vlogf(format string, args ...interface{}) {
+ if VerboseLogs {
+ t.logf(format, args...)
+ }
+}
+
+func (t *Transport) logf(format string, args ...interface{}) {
+ log.Printf(format, args...)
+}
+
+var noBody io.ReadCloser = ioutil.NopCloser(bytes.NewReader(nil))
+
+func strSliceContains(ss []string, s string) bool {
+ for _, v := range ss {
+ if v == s {
+ return true
+ }
+ }
+ return false
+}
+
+type erringRoundTripper struct{ err error }
+
+func (rt erringRoundTripper) RoundTrip(*http.Request) (*http.Response, error) { return nil, rt.err }
+
+// gzipReader wraps a response body so it can lazily
+// call gzip.NewReader on the first call to Read
+type gzipReader struct {
+ body io.ReadCloser // underlying Response.Body
+ zr *gzip.Reader // lazily-initialized gzip reader
+ zerr error // sticky error
+}
+
+func (gz *gzipReader) Read(p []byte) (n int, err error) {
+ if gz.zerr != nil {
+ return 0, gz.zerr
+ }
+ if gz.zr == nil {
+ gz.zr, err = gzip.NewReader(gz.body)
+ if err != nil {
+ gz.zerr = err
+ return 0, err
+ }
+ }
+ return gz.zr.Read(p)
+}
+
+func (gz *gzipReader) Close() error {
+ return gz.body.Close()
+}
+
+type errorReader struct{ err error }
+
+func (r errorReader) Read(p []byte) (int, error) { return 0, r.err }
+
+// bodyWriterState encapsulates various state around the Transport's writing
+// of the request body, particularly regarding doing delayed writes of the body
+// when the request contains "Expect: 100-continue".
+type bodyWriterState struct {
+ cs *clientStream
+ timer *time.Timer // if non-nil, we're doing a delayed write
+ fnonce *sync.Once // to call fn with
+ fn func() // the code to run in the goroutine, writing the body
+ resc chan error // result of fn's execution
+ delay time.Duration // how long we should delay a delayed write for
+}
+
+func (t *Transport) getBodyWriterState(cs *clientStream, body io.Reader) (s bodyWriterState) {
+ s.cs = cs
+ if body == nil {
+ return
+ }
+ resc := make(chan error, 1)
+ s.resc = resc
+ s.fn = func() {
+ resc <- cs.writeRequestBody(body, cs.req.Body)
+ }
+ s.delay = t.expectContinueTimeout()
+ if s.delay == 0 ||
+ !httplex.HeaderValuesContainsToken(
+ cs.req.Header["Expect"],
+ "100-continue") {
+ return
+ }
+ s.fnonce = new(sync.Once)
+
+ // Arm the timer with a very large duration, which we'll
+ // intentionally lower later. It has to be large now because
+ // we need a handle to it before writing the headers, but the
+ // s.delay value is defined to not start until after the
+ // request headers were written.
+ const hugeDuration = 365 * 24 * time.Hour
+ s.timer = time.AfterFunc(hugeDuration, func() {
+ s.fnonce.Do(s.fn)
+ })
+ return
+}
+
+func (s bodyWriterState) cancel() {
+ if s.timer != nil {
+ s.timer.Stop()
+ }
+}
+
+func (s bodyWriterState) on100() {
+ if s.timer == nil {
+ // If we didn't do a delayed write, ignore the server's
+ // bogus 100 continue response.
+ return
+ }
+ s.timer.Stop()
+ go func() { s.fnonce.Do(s.fn) }()
+}
+
+// scheduleBodyWrite starts writing the body, either immediately (in
+// the common case) or after the delay timeout. It should not be
+// called until after the headers have been written.
+func (s bodyWriterState) scheduleBodyWrite() {
+ if s.timer == nil {
+ // We're not doing a delayed write (see
+ // getBodyWriterState), so just start the writing
+ // goroutine immediately.
+ go s.fn()
+ return
+ }
+ traceWait100Continue(s.cs.trace)
+ if s.timer.Stop() {
+ s.timer.Reset(s.delay)
+ }
+}
+
+// isConnectionCloseRequest reports whether req should use its own
+// connection for a single request and then close the connection.
+func isConnectionCloseRequest(req *http.Request) bool {
+ return req.Close || httplex.HeaderValuesContainsToken(req.Header["Connection"], "close")
+}
diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go
new file mode 100644
index 0000000000000000000000000000000000000000..27ef0dd4d728c06702ea342bef37d65aba2d6a1a
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/write.go
@@ -0,0 +1,264 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "net/http"
+ "time"
+
+ "golang.org/x/net/http2/hpack"
+ "golang.org/x/net/lex/httplex"
+)
+
+// writeFramer is implemented by any type that is used to write frames.
+type writeFramer interface {
+ writeFrame(writeContext) error
+}
+
+// writeContext is the interface needed by the various frame writer
+// types below. All the writeFrame methods below are scheduled via the
+// frame writing scheduler (see writeScheduler in writesched.go).
+//
+// This interface is implemented by *serverConn.
+//
+// TODO: decide whether to a) use this in the client code (which didn't
+// end up using this yet, because it has a simpler design, not
+// currently implementing priorities), or b) delete this and
+// make the server code a bit more concrete.
+type writeContext interface {
+ Framer() *Framer
+ Flush() error
+ CloseConn() error
+ // HeaderEncoder returns an HPACK encoder that writes to the
+ // returned buffer.
+ HeaderEncoder() (*hpack.Encoder, *bytes.Buffer)
+}
+
+// endsStream reports whether the given frame writer w will locally
+// close the stream.
+func endsStream(w writeFramer) bool {
+ switch v := w.(type) {
+ case *writeData:
+ return v.endStream
+ case *writeResHeaders:
+ return v.endStream
+ case nil:
+ // This can only happen if the caller reuses w after it's
+ // been intentionally nil'ed out to prevent use. Keep this
+ // here to catch future refactoring breaking it.
+ panic("endsStream called on nil writeFramer")
+ }
+ return false
+}
+
+type flushFrameWriter struct{}
+
+func (flushFrameWriter) writeFrame(ctx writeContext) error {
+ return ctx.Flush()
+}
+
+type writeSettings []Setting
+
+func (s writeSettings) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteSettings([]Setting(s)...)
+}
+
+type writeGoAway struct {
+ maxStreamID uint32
+ code ErrCode
+}
+
+func (p *writeGoAway) writeFrame(ctx writeContext) error {
+ err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil)
+ if p.code != 0 {
+ ctx.Flush() // ignore error: we're hanging up on them anyway
+ time.Sleep(50 * time.Millisecond)
+ ctx.CloseConn()
+ }
+ return err
+}
+
+type writeData struct {
+ streamID uint32
+ p []byte
+ endStream bool
+}
+
+func (w *writeData) String() string {
+ return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
+}
+
+func (w *writeData) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteData(w.streamID, w.endStream, w.p)
+}
+
+// handlerPanicRST is the message sent from handler goroutines when
+// the handler panics.
+type handlerPanicRST struct {
+ StreamID uint32
+}
+
+func (hp handlerPanicRST) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal)
+}
+
+func (se StreamError) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteRSTStream(se.StreamID, se.Code)
+}
+
+type writePingAck struct{ pf *PingFrame }
+
+func (w writePingAck) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WritePing(true, w.pf.Data)
+}
+
+type writeSettingsAck struct{}
+
+func (writeSettingsAck) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteSettingsAck()
+}
+
+// writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames
+// for HTTP response headers or trailers from a server handler.
+type writeResHeaders struct {
+ streamID uint32
+ httpResCode int // 0 means no ":status" line
+ h http.Header // may be nil
+ trailers []string // if non-nil, which keys of h to write. nil means all.
+ endStream bool
+
+ date string
+ contentType string
+ contentLength string
+}
+
+func encKV(enc *hpack.Encoder, k, v string) {
+ if VerboseLogs {
+ log.Printf("http2: server encoding header %q = %q", k, v)
+ }
+ enc.WriteField(hpack.HeaderField{Name: k, Value: v})
+}
+
+func (w *writeResHeaders) writeFrame(ctx writeContext) error {
+ enc, buf := ctx.HeaderEncoder()
+ buf.Reset()
+
+ if w.httpResCode != 0 {
+ encKV(enc, ":status", httpCodeString(w.httpResCode))
+ }
+
+ encodeHeaders(enc, w.h, w.trailers)
+
+ if w.contentType != "" {
+ encKV(enc, "content-type", w.contentType)
+ }
+ if w.contentLength != "" {
+ encKV(enc, "content-length", w.contentLength)
+ }
+ if w.date != "" {
+ encKV(enc, "date", w.date)
+ }
+
+ headerBlock := buf.Bytes()
+ if len(headerBlock) == 0 && w.trailers == nil {
+ panic("unexpected empty hpack")
+ }
+
+ // For now we're lazy and just pick the minimum MAX_FRAME_SIZE
+ // that all peers must support (16KB). Later we could care
+ // more and send larger frames if the peer advertised it, but
+ // there's little point. Most headers are small anyway (so we
+ // generally won't have CONTINUATION frames), and extra frames
+ // only waste 9 bytes anyway.
+ const maxFrameSize = 16384
+
+ first := true
+ for len(headerBlock) > 0 {
+ frag := headerBlock
+ if len(frag) > maxFrameSize {
+ frag = frag[:maxFrameSize]
+ }
+ headerBlock = headerBlock[len(frag):]
+ endHeaders := len(headerBlock) == 0
+ var err error
+ if first {
+ first = false
+ err = ctx.Framer().WriteHeaders(HeadersFrameParam{
+ StreamID: w.streamID,
+ BlockFragment: frag,
+ EndStream: w.endStream,
+ EndHeaders: endHeaders,
+ })
+ } else {
+ err = ctx.Framer().WriteContinuation(w.streamID, endHeaders, frag)
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+type write100ContinueHeadersFrame struct {
+ streamID uint32
+}
+
+func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error {
+ enc, buf := ctx.HeaderEncoder()
+ buf.Reset()
+ encKV(enc, ":status", "100")
+ return ctx.Framer().WriteHeaders(HeadersFrameParam{
+ StreamID: w.streamID,
+ BlockFragment: buf.Bytes(),
+ EndStream: false,
+ EndHeaders: true,
+ })
+}
+
+type writeWindowUpdate struct {
+ streamID uint32 // or 0 for conn-level
+ n uint32
+}
+
+func (wu writeWindowUpdate) writeFrame(ctx writeContext) error {
+ return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n)
+}
+
+func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) {
+ if keys == nil {
+ sorter := sorterPool.Get().(*sorter)
+ // Using defer here, since the returned keys from the
+ // sorter.Keys method is only valid until the sorter
+ // is returned:
+ defer sorterPool.Put(sorter)
+ keys = sorter.Keys(h)
+ }
+ for _, k := range keys {
+ vv := h[k]
+ k = lowerHeader(k)
+ if !validWireHeaderFieldName(k) {
+ // Skip it as backup paranoia. Per
+ // golang.org/issue/14048, these should
+ // already be rejected at a higher level.
+ continue
+ }
+ isTE := k == "transfer-encoding"
+ for _, v := range vv {
+ if !httplex.ValidHeaderFieldValue(v) {
+ // TODO: return an error? golang.org/issue/14048
+ // For now just omit it.
+ continue
+ }
+ // TODO: more of "8.1.2.2 Connection-Specific Header Fields"
+ if isTE && v != "trailers" {
+ continue
+ }
+ encKV(enc, k, v)
+ }
+ }
+}
diff --git a/vendor/golang.org/x/net/http2/writesched.go b/vendor/golang.org/x/net/http2/writesched.go
new file mode 100644
index 0000000000000000000000000000000000000000..c24316ce7b2fd0cdec3d3c183b3780ac77b68ece
--- /dev/null
+++ b/vendor/golang.org/x/net/http2/writesched.go
@@ -0,0 +1,283 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import "fmt"
+
+// frameWriteMsg is a request to write a frame.
+type frameWriteMsg struct {
+ // write is the interface value that does the writing, once the
+ // writeScheduler (below) has decided to select this frame
+ // to write. The write functions are all defined in write.go.
+ write writeFramer
+
+ stream *stream // used for prioritization. nil for non-stream frames.
+
+ // done, if non-nil, must be a buffered channel with space for
+ // 1 message and is sent the return value from write (or an
+ // earlier error) when the frame has been written.
+ done chan error
+}
+
+// for debugging only:
+func (wm frameWriteMsg) String() string {
+ var streamID uint32
+ if wm.stream != nil {
+ streamID = wm.stream.id
+ }
+ var des string
+ if s, ok := wm.write.(fmt.Stringer); ok {
+ des = s.String()
+ } else {
+ des = fmt.Sprintf("%T", wm.write)
+ }
+ return fmt.Sprintf("[frameWriteMsg stream=%d, ch=%v, type: %v]", streamID, wm.done != nil, des)
+}
+
+// writeScheduler tracks pending frames to write, priorities, and decides
+// the next one to use. It is not thread-safe.
+type writeScheduler struct {
+ // zero are frames not associated with a specific stream.
+ // They're sent before any stream-specific freams.
+ zero writeQueue
+
+ // maxFrameSize is the maximum size of a DATA frame
+ // we'll write. Must be non-zero and between 16K-16M.
+ maxFrameSize uint32
+
+ // sq contains the stream-specific queues, keyed by stream ID.
+ // when a stream is idle, it's deleted from the map.
+ sq map[uint32]*writeQueue
+
+ // canSend is a slice of memory that's reused between frame
+ // scheduling decisions to hold the list of writeQueues (from sq)
+ // which have enough flow control data to send. After canSend is
+ // built, the best is selected.
+ canSend []*writeQueue
+
+ // pool of empty queues for reuse.
+ queuePool []*writeQueue
+}
+
+func (ws *writeScheduler) putEmptyQueue(q *writeQueue) {
+ if len(q.s) != 0 {
+ panic("queue must be empty")
+ }
+ ws.queuePool = append(ws.queuePool, q)
+}
+
+func (ws *writeScheduler) getEmptyQueue() *writeQueue {
+ ln := len(ws.queuePool)
+ if ln == 0 {
+ return new(writeQueue)
+ }
+ q := ws.queuePool[ln-1]
+ ws.queuePool = ws.queuePool[:ln-1]
+ return q
+}
+
+func (ws *writeScheduler) empty() bool { return ws.zero.empty() && len(ws.sq) == 0 }
+
+func (ws *writeScheduler) add(wm frameWriteMsg) {
+ st := wm.stream
+ if st == nil {
+ ws.zero.push(wm)
+ } else {
+ ws.streamQueue(st.id).push(wm)
+ }
+}
+
+func (ws *writeScheduler) streamQueue(streamID uint32) *writeQueue {
+ if q, ok := ws.sq[streamID]; ok {
+ return q
+ }
+ if ws.sq == nil {
+ ws.sq = make(map[uint32]*writeQueue)
+ }
+ q := ws.getEmptyQueue()
+ ws.sq[streamID] = q
+ return q
+}
+
+// take returns the most important frame to write and removes it from the scheduler.
+// It is illegal to call this if the scheduler is empty or if there are no connection-level
+// flow control bytes available.
+func (ws *writeScheduler) take() (wm frameWriteMsg, ok bool) {
+ if ws.maxFrameSize == 0 {
+ panic("internal error: ws.maxFrameSize not initialized or invalid")
+ }
+
+ // If there any frames not associated with streams, prefer those first.
+ // These are usually SETTINGS, etc.
+ if !ws.zero.empty() {
+ return ws.zero.shift(), true
+ }
+ if len(ws.sq) == 0 {
+ return
+ }
+
+ // Next, prioritize frames on streams that aren't DATA frames (no cost).
+ for id, q := range ws.sq {
+ if q.firstIsNoCost() {
+ return ws.takeFrom(id, q)
+ }
+ }
+
+ // Now, all that remains are DATA frames with non-zero bytes to
+ // send. So pick the best one.
+ if len(ws.canSend) != 0 {
+ panic("should be empty")
+ }
+ for _, q := range ws.sq {
+ if n := ws.streamWritableBytes(q); n > 0 {
+ ws.canSend = append(ws.canSend, q)
+ }
+ }
+ if len(ws.canSend) == 0 {
+ return
+ }
+ defer ws.zeroCanSend()
+
+ // TODO: find the best queue
+ q := ws.canSend[0]
+
+ return ws.takeFrom(q.streamID(), q)
+}
+
+// zeroCanSend is defered from take.
+func (ws *writeScheduler) zeroCanSend() {
+ for i := range ws.canSend {
+ ws.canSend[i] = nil
+ }
+ ws.canSend = ws.canSend[:0]
+}
+
+// streamWritableBytes returns the number of DATA bytes we could write
+// from the given queue's stream, if this stream/queue were
+// selected. It is an error to call this if q's head isn't a
+// *writeData.
+func (ws *writeScheduler) streamWritableBytes(q *writeQueue) int32 {
+ wm := q.head()
+ ret := wm.stream.flow.available() // max we can write
+ if ret == 0 {
+ return 0
+ }
+ if int32(ws.maxFrameSize) < ret {
+ ret = int32(ws.maxFrameSize)
+ }
+ if ret == 0 {
+ panic("internal error: ws.maxFrameSize not initialized or invalid")
+ }
+ wd := wm.write.(*writeData)
+ if len(wd.p) < int(ret) {
+ ret = int32(len(wd.p))
+ }
+ return ret
+}
+
+func (ws *writeScheduler) takeFrom(id uint32, q *writeQueue) (wm frameWriteMsg, ok bool) {
+ wm = q.head()
+ // If the first item in this queue costs flow control tokens
+ // and we don't have enough, write as much as we can.
+ if wd, ok := wm.write.(*writeData); ok && len(wd.p) > 0 {
+ allowed := wm.stream.flow.available() // max we can write
+ if allowed == 0 {
+ // No quota available. Caller can try the next stream.
+ return frameWriteMsg{}, false
+ }
+ if int32(ws.maxFrameSize) < allowed {
+ allowed = int32(ws.maxFrameSize)
+ }
+ // TODO: further restrict the allowed size, because even if
+ // the peer says it's okay to write 16MB data frames, we might
+ // want to write smaller ones to properly weight competing
+ // streams' priorities.
+
+ if len(wd.p) > int(allowed) {
+ wm.stream.flow.take(allowed)
+ chunk := wd.p[:allowed]
+ wd.p = wd.p[allowed:]
+ // Make up a new write message of a valid size, rather
+ // than shifting one off the queue.
+ return frameWriteMsg{
+ stream: wm.stream,
+ write: &writeData{
+ streamID: wd.streamID,
+ p: chunk,
+ // even if the original had endStream set, there
+ // arebytes remaining because len(wd.p) > allowed,
+ // so we know endStream is false:
+ endStream: false,
+ },
+ // our caller is blocking on the final DATA frame, not
+ // these intermediates, so no need to wait:
+ done: nil,
+ }, true
+ }
+ wm.stream.flow.take(int32(len(wd.p)))
+ }
+
+ q.shift()
+ if q.empty() {
+ ws.putEmptyQueue(q)
+ delete(ws.sq, id)
+ }
+ return wm, true
+}
+
+func (ws *writeScheduler) forgetStream(id uint32) {
+ q, ok := ws.sq[id]
+ if !ok {
+ return
+ }
+ delete(ws.sq, id)
+
+ // But keep it for others later.
+ for i := range q.s {
+ q.s[i] = frameWriteMsg{}
+ }
+ q.s = q.s[:0]
+ ws.putEmptyQueue(q)
+}
+
+type writeQueue struct {
+ s []frameWriteMsg
+}
+
+// streamID returns the stream ID for a non-empty stream-specific queue.
+func (q *writeQueue) streamID() uint32 { return q.s[0].stream.id }
+
+func (q *writeQueue) empty() bool { return len(q.s) == 0 }
+
+func (q *writeQueue) push(wm frameWriteMsg) {
+ q.s = append(q.s, wm)
+}
+
+// head returns the next item that would be removed by shift.
+func (q *writeQueue) head() frameWriteMsg {
+ if len(q.s) == 0 {
+ panic("invalid use of queue")
+ }
+ return q.s[0]
+}
+
+func (q *writeQueue) shift() frameWriteMsg {
+ if len(q.s) == 0 {
+ panic("invalid use of queue")
+ }
+ wm := q.s[0]
+ // TODO: less copy-happy queue.
+ copy(q.s, q.s[1:])
+ q.s[len(q.s)-1] = frameWriteMsg{}
+ q.s = q.s[:len(q.s)-1]
+ return wm
+}
+
+func (q *writeQueue) firstIsNoCost() bool {
+ if df, ok := q.s[0].write.(*writeData); ok {
+ return len(df.p) == 0
+ }
+ return true
+}
diff --git a/vendor/golang.org/x/net/websocket/client.go b/vendor/golang.org/x/net/websocket/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..20d1e1e38eb226f84e3b4890d87c0db22eb8ef4b
--- /dev/null
+++ b/vendor/golang.org/x/net/websocket/client.go
@@ -0,0 +1,113 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "crypto/tls"
+ "io"
+ "net"
+ "net/http"
+ "net/url"
+)
+
+// DialError is an error that occurs while dialling a websocket server.
+type DialError struct {
+ *Config
+ Err error
+}
+
+func (e *DialError) Error() string {
+ return "websocket.Dial " + e.Config.Location.String() + ": " + e.Err.Error()
+}
+
+// NewConfig creates a new WebSocket config for client connection.
+func NewConfig(server, origin string) (config *Config, err error) {
+ config = new(Config)
+ config.Version = ProtocolVersionHybi13
+ config.Location, err = url.ParseRequestURI(server)
+ if err != nil {
+ return
+ }
+ config.Origin, err = url.ParseRequestURI(origin)
+ if err != nil {
+ return
+ }
+ config.Header = http.Header(make(map[string][]string))
+ return
+}
+
+// NewClient creates a new WebSocket client connection over rwc.
+func NewClient(config *Config, rwc io.ReadWriteCloser) (ws *Conn, err error) {
+ br := bufio.NewReader(rwc)
+ bw := bufio.NewWriter(rwc)
+ err = hybiClientHandshake(config, br, bw)
+ if err != nil {
+ return
+ }
+ buf := bufio.NewReadWriter(br, bw)
+ ws = newHybiClientConn(config, buf, rwc)
+ return
+}
+
+// Dial opens a new client connection to a WebSocket.
+func Dial(url_, protocol, origin string) (ws *Conn, err error) {
+ config, err := NewConfig(url_, origin)
+ if err != nil {
+ return nil, err
+ }
+ if protocol != "" {
+ config.Protocol = []string{protocol}
+ }
+ return DialConfig(config)
+}
+
+var portMap = map[string]string{
+ "ws": "80",
+ "wss": "443",
+}
+
+func parseAuthority(location *url.URL) string {
+ if _, ok := portMap[location.Scheme]; ok {
+ if _, _, err := net.SplitHostPort(location.Host); err != nil {
+ return net.JoinHostPort(location.Host, portMap[location.Scheme])
+ }
+ }
+ return location.Host
+}
+
+// DialConfig opens a new client connection to a WebSocket with a config.
+func DialConfig(config *Config) (ws *Conn, err error) {
+ var client net.Conn
+ if config.Location == nil {
+ return nil, &DialError{config, ErrBadWebSocketLocation}
+ }
+ if config.Origin == nil {
+ return nil, &DialError{config, ErrBadWebSocketOrigin}
+ }
+ switch config.Location.Scheme {
+ case "ws":
+ client, err = net.Dial("tcp", parseAuthority(config.Location))
+
+ case "wss":
+ client, err = tls.Dial("tcp", parseAuthority(config.Location), config.TlsConfig)
+
+ default:
+ err = ErrBadScheme
+ }
+ if err != nil {
+ goto Error
+ }
+
+ ws, err = NewClient(config, client)
+ if err != nil {
+ client.Close()
+ goto Error
+ }
+ return
+
+Error:
+ return nil, &DialError{config, err}
+}
diff --git a/vendor/golang.org/x/net/websocket/hybi.go b/vendor/golang.org/x/net/websocket/hybi.go
new file mode 100644
index 0000000000000000000000000000000000000000..8cffdd16c91da4627b5e3116fc292495b113543e
--- /dev/null
+++ b/vendor/golang.org/x/net/websocket/hybi.go
@@ -0,0 +1,583 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+// This file implements a protocol of hybi draft.
+// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+import (
+ "bufio"
+ "bytes"
+ "crypto/rand"
+ "crypto/sha1"
+ "encoding/base64"
+ "encoding/binary"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+const (
+ websocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+ closeStatusNormal = 1000
+ closeStatusGoingAway = 1001
+ closeStatusProtocolError = 1002
+ closeStatusUnsupportedData = 1003
+ closeStatusFrameTooLarge = 1004
+ closeStatusNoStatusRcvd = 1005
+ closeStatusAbnormalClosure = 1006
+ closeStatusBadMessageData = 1007
+ closeStatusPolicyViolation = 1008
+ closeStatusTooBigData = 1009
+ closeStatusExtensionMismatch = 1010
+
+ maxControlFramePayloadLength = 125
+)
+
+var (
+ ErrBadMaskingKey = &ProtocolError{"bad masking key"}
+ ErrBadPongMessage = &ProtocolError{"bad pong message"}
+ ErrBadClosingStatus = &ProtocolError{"bad closing status"}
+ ErrUnsupportedExtensions = &ProtocolError{"unsupported extensions"}
+ ErrNotImplemented = &ProtocolError{"not implemented"}
+
+ handshakeHeader = map[string]bool{
+ "Host": true,
+ "Upgrade": true,
+ "Connection": true,
+ "Sec-Websocket-Key": true,
+ "Sec-Websocket-Origin": true,
+ "Sec-Websocket-Version": true,
+ "Sec-Websocket-Protocol": true,
+ "Sec-Websocket-Accept": true,
+ }
+)
+
+// A hybiFrameHeader is a frame header as defined in hybi draft.
+type hybiFrameHeader struct {
+ Fin bool
+ Rsv [3]bool
+ OpCode byte
+ Length int64
+ MaskingKey []byte
+
+ data *bytes.Buffer
+}
+
+// A hybiFrameReader is a reader for hybi frame.
+type hybiFrameReader struct {
+ reader io.Reader
+
+ header hybiFrameHeader
+ pos int64
+ length int
+}
+
+func (frame *hybiFrameReader) Read(msg []byte) (n int, err error) {
+ n, err = frame.reader.Read(msg)
+ if frame.header.MaskingKey != nil {
+ for i := 0; i < n; i++ {
+ msg[i] = msg[i] ^ frame.header.MaskingKey[frame.pos%4]
+ frame.pos++
+ }
+ }
+ return n, err
+}
+
+func (frame *hybiFrameReader) PayloadType() byte { return frame.header.OpCode }
+
+func (frame *hybiFrameReader) HeaderReader() io.Reader {
+ if frame.header.data == nil {
+ return nil
+ }
+ if frame.header.data.Len() == 0 {
+ return nil
+ }
+ return frame.header.data
+}
+
+func (frame *hybiFrameReader) TrailerReader() io.Reader { return nil }
+
+func (frame *hybiFrameReader) Len() (n int) { return frame.length }
+
+// A hybiFrameReaderFactory creates new frame reader based on its frame type.
+type hybiFrameReaderFactory struct {
+ *bufio.Reader
+}
+
+// NewFrameReader reads a frame header from the connection, and creates new reader for the frame.
+// See Section 5.2 Base Framing protocol for detail.
+// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17#section-5.2
+func (buf hybiFrameReaderFactory) NewFrameReader() (frame frameReader, err error) {
+ hybiFrame := new(hybiFrameReader)
+ frame = hybiFrame
+ var header []byte
+ var b byte
+ // First byte. FIN/RSV1/RSV2/RSV3/OpCode(4bits)
+ b, err = buf.ReadByte()
+ if err != nil {
+ return
+ }
+ header = append(header, b)
+ hybiFrame.header.Fin = ((header[0] >> 7) & 1) != 0
+ for i := 0; i < 3; i++ {
+ j := uint(6 - i)
+ hybiFrame.header.Rsv[i] = ((header[0] >> j) & 1) != 0
+ }
+ hybiFrame.header.OpCode = header[0] & 0x0f
+
+ // Second byte. Mask/Payload len(7bits)
+ b, err = buf.ReadByte()
+ if err != nil {
+ return
+ }
+ header = append(header, b)
+ mask := (b & 0x80) != 0
+ b &= 0x7f
+ lengthFields := 0
+ switch {
+ case b <= 125: // Payload length 7bits.
+ hybiFrame.header.Length = int64(b)
+ case b == 126: // Payload length 7+16bits
+ lengthFields = 2
+ case b == 127: // Payload length 7+64bits
+ lengthFields = 8
+ }
+ for i := 0; i < lengthFields; i++ {
+ b, err = buf.ReadByte()
+ if err != nil {
+ return
+ }
+ if lengthFields == 8 && i == 0 { // MSB must be zero when 7+64 bits
+ b &= 0x7f
+ }
+ header = append(header, b)
+ hybiFrame.header.Length = hybiFrame.header.Length*256 + int64(b)
+ }
+ if mask {
+ // Masking key. 4 bytes.
+ for i := 0; i < 4; i++ {
+ b, err = buf.ReadByte()
+ if err != nil {
+ return
+ }
+ header = append(header, b)
+ hybiFrame.header.MaskingKey = append(hybiFrame.header.MaskingKey, b)
+ }
+ }
+ hybiFrame.reader = io.LimitReader(buf.Reader, hybiFrame.header.Length)
+ hybiFrame.header.data = bytes.NewBuffer(header)
+ hybiFrame.length = len(header) + int(hybiFrame.header.Length)
+ return
+}
+
+// A HybiFrameWriter is a writer for hybi frame.
+type hybiFrameWriter struct {
+ writer *bufio.Writer
+
+ header *hybiFrameHeader
+}
+
+func (frame *hybiFrameWriter) Write(msg []byte) (n int, err error) {
+ var header []byte
+ var b byte
+ if frame.header.Fin {
+ b |= 0x80
+ }
+ for i := 0; i < 3; i++ {
+ if frame.header.Rsv[i] {
+ j := uint(6 - i)
+ b |= 1 << j
+ }
+ }
+ b |= frame.header.OpCode
+ header = append(header, b)
+ if frame.header.MaskingKey != nil {
+ b = 0x80
+ } else {
+ b = 0
+ }
+ lengthFields := 0
+ length := len(msg)
+ switch {
+ case length <= 125:
+ b |= byte(length)
+ case length < 65536:
+ b |= 126
+ lengthFields = 2
+ default:
+ b |= 127
+ lengthFields = 8
+ }
+ header = append(header, b)
+ for i := 0; i < lengthFields; i++ {
+ j := uint((lengthFields - i - 1) * 8)
+ b = byte((length >> j) & 0xff)
+ header = append(header, b)
+ }
+ if frame.header.MaskingKey != nil {
+ if len(frame.header.MaskingKey) != 4 {
+ return 0, ErrBadMaskingKey
+ }
+ header = append(header, frame.header.MaskingKey...)
+ frame.writer.Write(header)
+ data := make([]byte, length)
+ for i := range data {
+ data[i] = msg[i] ^ frame.header.MaskingKey[i%4]
+ }
+ frame.writer.Write(data)
+ err = frame.writer.Flush()
+ return length, err
+ }
+ frame.writer.Write(header)
+ frame.writer.Write(msg)
+ err = frame.writer.Flush()
+ return length, err
+}
+
+func (frame *hybiFrameWriter) Close() error { return nil }
+
+type hybiFrameWriterFactory struct {
+ *bufio.Writer
+ needMaskingKey bool
+}
+
+func (buf hybiFrameWriterFactory) NewFrameWriter(payloadType byte) (frame frameWriter, err error) {
+ frameHeader := &hybiFrameHeader{Fin: true, OpCode: payloadType}
+ if buf.needMaskingKey {
+ frameHeader.MaskingKey, err = generateMaskingKey()
+ if err != nil {
+ return nil, err
+ }
+ }
+ return &hybiFrameWriter{writer: buf.Writer, header: frameHeader}, nil
+}
+
+type hybiFrameHandler struct {
+ conn *Conn
+ payloadType byte
+}
+
+func (handler *hybiFrameHandler) HandleFrame(frame frameReader) (frameReader, error) {
+ if handler.conn.IsServerConn() {
+ // The client MUST mask all frames sent to the server.
+ if frame.(*hybiFrameReader).header.MaskingKey == nil {
+ handler.WriteClose(closeStatusProtocolError)
+ return nil, io.EOF
+ }
+ } else {
+ // The server MUST NOT mask all frames.
+ if frame.(*hybiFrameReader).header.MaskingKey != nil {
+ handler.WriteClose(closeStatusProtocolError)
+ return nil, io.EOF
+ }
+ }
+ if header := frame.HeaderReader(); header != nil {
+ io.Copy(ioutil.Discard, header)
+ }
+ switch frame.PayloadType() {
+ case ContinuationFrame:
+ frame.(*hybiFrameReader).header.OpCode = handler.payloadType
+ case TextFrame, BinaryFrame:
+ handler.payloadType = frame.PayloadType()
+ case CloseFrame:
+ return nil, io.EOF
+ case PingFrame, PongFrame:
+ b := make([]byte, maxControlFramePayloadLength)
+ n, err := io.ReadFull(frame, b)
+ if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
+ return nil, err
+ }
+ io.Copy(ioutil.Discard, frame)
+ if frame.PayloadType() == PingFrame {
+ if _, err := handler.WritePong(b[:n]); err != nil {
+ return nil, err
+ }
+ }
+ return nil, nil
+ }
+ return frame, nil
+}
+
+func (handler *hybiFrameHandler) WriteClose(status int) (err error) {
+ handler.conn.wio.Lock()
+ defer handler.conn.wio.Unlock()
+ w, err := handler.conn.frameWriterFactory.NewFrameWriter(CloseFrame)
+ if err != nil {
+ return err
+ }
+ msg := make([]byte, 2)
+ binary.BigEndian.PutUint16(msg, uint16(status))
+ _, err = w.Write(msg)
+ w.Close()
+ return err
+}
+
+func (handler *hybiFrameHandler) WritePong(msg []byte) (n int, err error) {
+ handler.conn.wio.Lock()
+ defer handler.conn.wio.Unlock()
+ w, err := handler.conn.frameWriterFactory.NewFrameWriter(PongFrame)
+ if err != nil {
+ return 0, err
+ }
+ n, err = w.Write(msg)
+ w.Close()
+ return n, err
+}
+
+// newHybiConn creates a new WebSocket connection speaking hybi draft protocol.
+func newHybiConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
+ if buf == nil {
+ br := bufio.NewReader(rwc)
+ bw := bufio.NewWriter(rwc)
+ buf = bufio.NewReadWriter(br, bw)
+ }
+ ws := &Conn{config: config, request: request, buf: buf, rwc: rwc,
+ frameReaderFactory: hybiFrameReaderFactory{buf.Reader},
+ frameWriterFactory: hybiFrameWriterFactory{
+ buf.Writer, request == nil},
+ PayloadType: TextFrame,
+ defaultCloseStatus: closeStatusNormal}
+ ws.frameHandler = &hybiFrameHandler{conn: ws}
+ return ws
+}
+
+// generateMaskingKey generates a masking key for a frame.
+func generateMaskingKey() (maskingKey []byte, err error) {
+ maskingKey = make([]byte, 4)
+ if _, err = io.ReadFull(rand.Reader, maskingKey); err != nil {
+ return
+ }
+ return
+}
+
+// generateNonce generates a nonce consisting of a randomly selected 16-byte
+// value that has been base64-encoded.
+func generateNonce() (nonce []byte) {
+ key := make([]byte, 16)
+ if _, err := io.ReadFull(rand.Reader, key); err != nil {
+ panic(err)
+ }
+ nonce = make([]byte, 24)
+ base64.StdEncoding.Encode(nonce, key)
+ return
+}
+
+// removeZone removes IPv6 zone identifer from host.
+// E.g., "[fe80::1%en0]:8080" to "[fe80::1]:8080"
+func removeZone(host string) string {
+ if !strings.HasPrefix(host, "[") {
+ return host
+ }
+ i := strings.LastIndex(host, "]")
+ if i < 0 {
+ return host
+ }
+ j := strings.LastIndex(host[:i], "%")
+ if j < 0 {
+ return host
+ }
+ return host[:j] + host[i:]
+}
+
+// getNonceAccept computes the base64-encoded SHA-1 of the concatenation of
+// the nonce ("Sec-WebSocket-Key" value) with the websocket GUID string.
+func getNonceAccept(nonce []byte) (expected []byte, err error) {
+ h := sha1.New()
+ if _, err = h.Write(nonce); err != nil {
+ return
+ }
+ if _, err = h.Write([]byte(websocketGUID)); err != nil {
+ return
+ }
+ expected = make([]byte, 28)
+ base64.StdEncoding.Encode(expected, h.Sum(nil))
+ return
+}
+
+// Client handshake described in draft-ietf-hybi-thewebsocket-protocol-17
+func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
+ bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
+
+ // According to RFC 6874, an HTTP client, proxy, or other
+ // intermediary must remove any IPv6 zone identifier attached
+ // to an outgoing URI.
+ bw.WriteString("Host: " + removeZone(config.Location.Host) + "\r\n")
+ bw.WriteString("Upgrade: websocket\r\n")
+ bw.WriteString("Connection: Upgrade\r\n")
+ nonce := generateNonce()
+ if config.handshakeData != nil {
+ nonce = []byte(config.handshakeData["key"])
+ }
+ bw.WriteString("Sec-WebSocket-Key: " + string(nonce) + "\r\n")
+ bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")
+
+ if config.Version != ProtocolVersionHybi13 {
+ return ErrBadProtocolVersion
+ }
+
+ bw.WriteString("Sec-WebSocket-Version: " + fmt.Sprintf("%d", config.Version) + "\r\n")
+ if len(config.Protocol) > 0 {
+ bw.WriteString("Sec-WebSocket-Protocol: " + strings.Join(config.Protocol, ", ") + "\r\n")
+ }
+ // TODO(ukai): send Sec-WebSocket-Extensions.
+ err = config.Header.WriteSubset(bw, handshakeHeader)
+ if err != nil {
+ return err
+ }
+
+ bw.WriteString("\r\n")
+ if err = bw.Flush(); err != nil {
+ return err
+ }
+
+ resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
+ if err != nil {
+ return err
+ }
+ if resp.StatusCode != 101 {
+ return ErrBadStatus
+ }
+ if strings.ToLower(resp.Header.Get("Upgrade")) != "websocket" ||
+ strings.ToLower(resp.Header.Get("Connection")) != "upgrade" {
+ return ErrBadUpgrade
+ }
+ expectedAccept, err := getNonceAccept(nonce)
+ if err != nil {
+ return err
+ }
+ if resp.Header.Get("Sec-WebSocket-Accept") != string(expectedAccept) {
+ return ErrChallengeResponse
+ }
+ if resp.Header.Get("Sec-WebSocket-Extensions") != "" {
+ return ErrUnsupportedExtensions
+ }
+ offeredProtocol := resp.Header.Get("Sec-WebSocket-Protocol")
+ if offeredProtocol != "" {
+ protocolMatched := false
+ for i := 0; i < len(config.Protocol); i++ {
+ if config.Protocol[i] == offeredProtocol {
+ protocolMatched = true
+ break
+ }
+ }
+ if !protocolMatched {
+ return ErrBadWebSocketProtocol
+ }
+ config.Protocol = []string{offeredProtocol}
+ }
+
+ return nil
+}
+
+// newHybiClientConn creates a client WebSocket connection after handshake.
+func newHybiClientConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser) *Conn {
+ return newHybiConn(config, buf, rwc, nil)
+}
+
+// A HybiServerHandshaker performs a server handshake using hybi draft protocol.
+type hybiServerHandshaker struct {
+ *Config
+ accept []byte
+}
+
+func (c *hybiServerHandshaker) ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error) {
+ c.Version = ProtocolVersionHybi13
+ if req.Method != "GET" {
+ return http.StatusMethodNotAllowed, ErrBadRequestMethod
+ }
+ // HTTP version can be safely ignored.
+
+ if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
+ !strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
+ return http.StatusBadRequest, ErrNotWebSocket
+ }
+
+ key := req.Header.Get("Sec-Websocket-Key")
+ if key == "" {
+ return http.StatusBadRequest, ErrChallengeResponse
+ }
+ version := req.Header.Get("Sec-Websocket-Version")
+ switch version {
+ case "13":
+ c.Version = ProtocolVersionHybi13
+ default:
+ return http.StatusBadRequest, ErrBadWebSocketVersion
+ }
+ var scheme string
+ if req.TLS != nil {
+ scheme = "wss"
+ } else {
+ scheme = "ws"
+ }
+ c.Location, err = url.ParseRequestURI(scheme + "://" + req.Host + req.URL.RequestURI())
+ if err != nil {
+ return http.StatusBadRequest, err
+ }
+ protocol := strings.TrimSpace(req.Header.Get("Sec-Websocket-Protocol"))
+ if protocol != "" {
+ protocols := strings.Split(protocol, ",")
+ for i := 0; i < len(protocols); i++ {
+ c.Protocol = append(c.Protocol, strings.TrimSpace(protocols[i]))
+ }
+ }
+ c.accept, err = getNonceAccept([]byte(key))
+ if err != nil {
+ return http.StatusInternalServerError, err
+ }
+ return http.StatusSwitchingProtocols, nil
+}
+
+// Origin parses the Origin header in req.
+// If the Origin header is not set, it returns nil and nil.
+func Origin(config *Config, req *http.Request) (*url.URL, error) {
+ var origin string
+ switch config.Version {
+ case ProtocolVersionHybi13:
+ origin = req.Header.Get("Origin")
+ }
+ if origin == "" {
+ return nil, nil
+ }
+ return url.ParseRequestURI(origin)
+}
+
+func (c *hybiServerHandshaker) AcceptHandshake(buf *bufio.Writer) (err error) {
+ if len(c.Protocol) > 0 {
+ if len(c.Protocol) != 1 {
+ // You need choose a Protocol in Handshake func in Server.
+ return ErrBadWebSocketProtocol
+ }
+ }
+ buf.WriteString("HTTP/1.1 101 Switching Protocols\r\n")
+ buf.WriteString("Upgrade: websocket\r\n")
+ buf.WriteString("Connection: Upgrade\r\n")
+ buf.WriteString("Sec-WebSocket-Accept: " + string(c.accept) + "\r\n")
+ if len(c.Protocol) > 0 {
+ buf.WriteString("Sec-WebSocket-Protocol: " + c.Protocol[0] + "\r\n")
+ }
+ // TODO(ukai): send Sec-WebSocket-Extensions.
+ if c.Header != nil {
+ err := c.Header.WriteSubset(buf, handshakeHeader)
+ if err != nil {
+ return err
+ }
+ }
+ buf.WriteString("\r\n")
+ return buf.Flush()
+}
+
+func (c *hybiServerHandshaker) NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
+ return newHybiServerConn(c.Config, buf, rwc, request)
+}
+
+// newHybiServerConn returns a new WebSocket connection speaking hybi draft protocol.
+func newHybiServerConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
+ return newHybiConn(config, buf, rwc, request)
+}
diff --git a/vendor/golang.org/x/net/websocket/server.go b/vendor/golang.org/x/net/websocket/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..0895dea1905aa32a529ab0487f1aa4895c35c08d
--- /dev/null
+++ b/vendor/golang.org/x/net/websocket/server.go
@@ -0,0 +1,113 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "fmt"
+ "io"
+ "net/http"
+)
+
+func newServerConn(rwc io.ReadWriteCloser, buf *bufio.ReadWriter, req *http.Request, config *Config, handshake func(*Config, *http.Request) error) (conn *Conn, err error) {
+ var hs serverHandshaker = &hybiServerHandshaker{Config: config}
+ code, err := hs.ReadHandshake(buf.Reader, req)
+ if err == ErrBadWebSocketVersion {
+ fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
+ fmt.Fprintf(buf, "Sec-WebSocket-Version: %s\r\n", SupportedProtocolVersion)
+ buf.WriteString("\r\n")
+ buf.WriteString(err.Error())
+ buf.Flush()
+ return
+ }
+ if err != nil {
+ fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
+ buf.WriteString("\r\n")
+ buf.WriteString(err.Error())
+ buf.Flush()
+ return
+ }
+ if handshake != nil {
+ err = handshake(config, req)
+ if err != nil {
+ code = http.StatusForbidden
+ fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
+ buf.WriteString("\r\n")
+ buf.Flush()
+ return
+ }
+ }
+ err = hs.AcceptHandshake(buf.Writer)
+ if err != nil {
+ code = http.StatusBadRequest
+ fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
+ buf.WriteString("\r\n")
+ buf.Flush()
+ return
+ }
+ conn = hs.NewServerConn(buf, rwc, req)
+ return
+}
+
+// Server represents a server of a WebSocket.
+type Server struct {
+ // Config is a WebSocket configuration for new WebSocket connection.
+ Config
+
+ // Handshake is an optional function in WebSocket handshake.
+ // For example, you can check, or don't check Origin header.
+ // Another example, you can select config.Protocol.
+ Handshake func(*Config, *http.Request) error
+
+ // Handler handles a WebSocket connection.
+ Handler
+}
+
+// ServeHTTP implements the http.Handler interface for a WebSocket
+func (s Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ s.serveWebSocket(w, req)
+}
+
+func (s Server) serveWebSocket(w http.ResponseWriter, req *http.Request) {
+ rwc, buf, err := w.(http.Hijacker).Hijack()
+ if err != nil {
+ panic("Hijack failed: " + err.Error())
+ }
+ // The server should abort the WebSocket connection if it finds
+ // the client did not send a handshake that matches with protocol
+ // specification.
+ defer rwc.Close()
+ conn, err := newServerConn(rwc, buf, req, &s.Config, s.Handshake)
+ if err != nil {
+ return
+ }
+ if conn == nil {
+ panic("unexpected nil conn")
+ }
+ s.Handler(conn)
+}
+
+// Handler is a simple interface to a WebSocket browser client.
+// It checks if Origin header is valid URL by default.
+// You might want to verify websocket.Conn.Config().Origin in the func.
+// If you use Server instead of Handler, you could call websocket.Origin and
+// check the origin in your Handshake func. So, if you want to accept
+// non-browser clients, which do not send an Origin header, set a
+// Server.Handshake that does not check the origin.
+type Handler func(*Conn)
+
+func checkOrigin(config *Config, req *http.Request) (err error) {
+ config.Origin, err = Origin(config, req)
+ if err == nil && config.Origin == nil {
+ return fmt.Errorf("null origin")
+ }
+ return err
+}
+
+// ServeHTTP implements the http.Handler interface for a WebSocket
+func (h Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ s := Server{Handler: h, Handshake: checkOrigin}
+ s.serveWebSocket(w, req)
+}
diff --git a/vendor/golang.org/x/net/websocket/websocket.go b/vendor/golang.org/x/net/websocket/websocket.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f9b9a52dafb115f00a60cca719f0348b441dfdd
--- /dev/null
+++ b/vendor/golang.org/x/net/websocket/websocket.go
@@ -0,0 +1,411 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package websocket implements a client and server for the WebSocket protocol
+// as specified in RFC 6455.
+package websocket
+
+import (
+ "bufio"
+ "crypto/tls"
+ "encoding/json"
+ "errors"
+ "io"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/url"
+ "sync"
+ "time"
+)
+
+const (
+ ProtocolVersionHybi13 = 13
+ ProtocolVersionHybi = ProtocolVersionHybi13
+ SupportedProtocolVersion = "13"
+
+ ContinuationFrame = 0
+ TextFrame = 1
+ BinaryFrame = 2
+ CloseFrame = 8
+ PingFrame = 9
+ PongFrame = 10
+ UnknownFrame = 255
+)
+
+// ProtocolError represents WebSocket protocol errors.
+type ProtocolError struct {
+ ErrorString string
+}
+
+func (err *ProtocolError) Error() string { return err.ErrorString }
+
+var (
+ ErrBadProtocolVersion = &ProtocolError{"bad protocol version"}
+ ErrBadScheme = &ProtocolError{"bad scheme"}
+ ErrBadStatus = &ProtocolError{"bad status"}
+ ErrBadUpgrade = &ProtocolError{"missing or bad upgrade"}
+ ErrBadWebSocketOrigin = &ProtocolError{"missing or bad WebSocket-Origin"}
+ ErrBadWebSocketLocation = &ProtocolError{"missing or bad WebSocket-Location"}
+ ErrBadWebSocketProtocol = &ProtocolError{"missing or bad WebSocket-Protocol"}
+ ErrBadWebSocketVersion = &ProtocolError{"missing or bad WebSocket Version"}
+ ErrChallengeResponse = &ProtocolError{"mismatch challenge/response"}
+ ErrBadFrame = &ProtocolError{"bad frame"}
+ ErrBadFrameBoundary = &ProtocolError{"not on frame boundary"}
+ ErrNotWebSocket = &ProtocolError{"not websocket protocol"}
+ ErrBadRequestMethod = &ProtocolError{"bad method"}
+ ErrNotSupported = &ProtocolError{"not supported"}
+)
+
+// Addr is an implementation of net.Addr for WebSocket.
+type Addr struct {
+ *url.URL
+}
+
+// Network returns the network type for a WebSocket, "websocket".
+func (addr *Addr) Network() string { return "websocket" }
+
+// Config is a WebSocket configuration
+type Config struct {
+ // A WebSocket server address.
+ Location *url.URL
+
+ // A Websocket client origin.
+ Origin *url.URL
+
+ // WebSocket subprotocols.
+ Protocol []string
+
+ // WebSocket protocol version.
+ Version int
+
+ // TLS config for secure WebSocket (wss).
+ TlsConfig *tls.Config
+
+ // Additional header fields to be sent in WebSocket opening handshake.
+ Header http.Header
+
+ handshakeData map[string]string
+}
+
+// serverHandshaker is an interface to handle WebSocket server side handshake.
+type serverHandshaker interface {
+ // ReadHandshake reads handshake request message from client.
+ // Returns http response code and error if any.
+ ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error)
+
+ // AcceptHandshake accepts the client handshake request and sends
+ // handshake response back to client.
+ AcceptHandshake(buf *bufio.Writer) (err error)
+
+ // NewServerConn creates a new WebSocket connection.
+ NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) (conn *Conn)
+}
+
+// frameReader is an interface to read a WebSocket frame.
+type frameReader interface {
+ // Reader is to read payload of the frame.
+ io.Reader
+
+ // PayloadType returns payload type.
+ PayloadType() byte
+
+ // HeaderReader returns a reader to read header of the frame.
+ HeaderReader() io.Reader
+
+ // TrailerReader returns a reader to read trailer of the frame.
+ // If it returns nil, there is no trailer in the frame.
+ TrailerReader() io.Reader
+
+ // Len returns total length of the frame, including header and trailer.
+ Len() int
+}
+
+// frameReaderFactory is an interface to creates new frame reader.
+type frameReaderFactory interface {
+ NewFrameReader() (r frameReader, err error)
+}
+
+// frameWriter is an interface to write a WebSocket frame.
+type frameWriter interface {
+ // Writer is to write payload of the frame.
+ io.WriteCloser
+}
+
+// frameWriterFactory is an interface to create new frame writer.
+type frameWriterFactory interface {
+ NewFrameWriter(payloadType byte) (w frameWriter, err error)
+}
+
+type frameHandler interface {
+ HandleFrame(frame frameReader) (r frameReader, err error)
+ WriteClose(status int) (err error)
+}
+
+// Conn represents a WebSocket connection.
+//
+// Multiple goroutines may invoke methods on a Conn simultaneously.
+type Conn struct {
+ config *Config
+ request *http.Request
+
+ buf *bufio.ReadWriter
+ rwc io.ReadWriteCloser
+
+ rio sync.Mutex
+ frameReaderFactory
+ frameReader
+
+ wio sync.Mutex
+ frameWriterFactory
+
+ frameHandler
+ PayloadType byte
+ defaultCloseStatus int
+}
+
+// Read implements the io.Reader interface:
+// it reads data of a frame from the WebSocket connection.
+// if msg is not large enough for the frame data, it fills the msg and next Read
+// will read the rest of the frame data.
+// it reads Text frame or Binary frame.
+func (ws *Conn) Read(msg []byte) (n int, err error) {
+ ws.rio.Lock()
+ defer ws.rio.Unlock()
+again:
+ if ws.frameReader == nil {
+ frame, err := ws.frameReaderFactory.NewFrameReader()
+ if err != nil {
+ return 0, err
+ }
+ ws.frameReader, err = ws.frameHandler.HandleFrame(frame)
+ if err != nil {
+ return 0, err
+ }
+ if ws.frameReader == nil {
+ goto again
+ }
+ }
+ n, err = ws.frameReader.Read(msg)
+ if err == io.EOF {
+ if trailer := ws.frameReader.TrailerReader(); trailer != nil {
+ io.Copy(ioutil.Discard, trailer)
+ }
+ ws.frameReader = nil
+ goto again
+ }
+ return n, err
+}
+
+// Write implements the io.Writer interface:
+// it writes data as a frame to the WebSocket connection.
+func (ws *Conn) Write(msg []byte) (n int, err error) {
+ ws.wio.Lock()
+ defer ws.wio.Unlock()
+ w, err := ws.frameWriterFactory.NewFrameWriter(ws.PayloadType)
+ if err != nil {
+ return 0, err
+ }
+ n, err = w.Write(msg)
+ w.Close()
+ return n, err
+}
+
+// Close implements the io.Closer interface.
+func (ws *Conn) Close() error {
+ err := ws.frameHandler.WriteClose(ws.defaultCloseStatus)
+ err1 := ws.rwc.Close()
+ if err != nil {
+ return err
+ }
+ return err1
+}
+
+func (ws *Conn) IsClientConn() bool { return ws.request == nil }
+func (ws *Conn) IsServerConn() bool { return ws.request != nil }
+
+// LocalAddr returns the WebSocket Origin for the connection for client, or
+// the WebSocket location for server.
+func (ws *Conn) LocalAddr() net.Addr {
+ if ws.IsClientConn() {
+ return &Addr{ws.config.Origin}
+ }
+ return &Addr{ws.config.Location}
+}
+
+// RemoteAddr returns the WebSocket location for the connection for client, or
+// the Websocket Origin for server.
+func (ws *Conn) RemoteAddr() net.Addr {
+ if ws.IsClientConn() {
+ return &Addr{ws.config.Location}
+ }
+ return &Addr{ws.config.Origin}
+}
+
+var errSetDeadline = errors.New("websocket: cannot set deadline: not using a net.Conn")
+
+// SetDeadline sets the connection's network read & write deadlines.
+func (ws *Conn) SetDeadline(t time.Time) error {
+ if conn, ok := ws.rwc.(net.Conn); ok {
+ return conn.SetDeadline(t)
+ }
+ return errSetDeadline
+}
+
+// SetReadDeadline sets the connection's network read deadline.
+func (ws *Conn) SetReadDeadline(t time.Time) error {
+ if conn, ok := ws.rwc.(net.Conn); ok {
+ return conn.SetReadDeadline(t)
+ }
+ return errSetDeadline
+}
+
+// SetWriteDeadline sets the connection's network write deadline.
+func (ws *Conn) SetWriteDeadline(t time.Time) error {
+ if conn, ok := ws.rwc.(net.Conn); ok {
+ return conn.SetWriteDeadline(t)
+ }
+ return errSetDeadline
+}
+
+// Config returns the WebSocket config.
+func (ws *Conn) Config() *Config { return ws.config }
+
+// Request returns the http request upgraded to the WebSocket.
+// It is nil for client side.
+func (ws *Conn) Request() *http.Request { return ws.request }
+
+// Codec represents a symmetric pair of functions that implement a codec.
+type Codec struct {
+ Marshal func(v interface{}) (data []byte, payloadType byte, err error)
+ Unmarshal func(data []byte, payloadType byte, v interface{}) (err error)
+}
+
+// Send sends v marshaled by cd.Marshal as single frame to ws.
+func (cd Codec) Send(ws *Conn, v interface{}) (err error) {
+ data, payloadType, err := cd.Marshal(v)
+ if err != nil {
+ return err
+ }
+ ws.wio.Lock()
+ defer ws.wio.Unlock()
+ w, err := ws.frameWriterFactory.NewFrameWriter(payloadType)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data)
+ w.Close()
+ return err
+}
+
+// Receive receives single frame from ws, unmarshaled by cd.Unmarshal and stores in v.
+func (cd Codec) Receive(ws *Conn, v interface{}) (err error) {
+ ws.rio.Lock()
+ defer ws.rio.Unlock()
+ if ws.frameReader != nil {
+ _, err = io.Copy(ioutil.Discard, ws.frameReader)
+ if err != nil {
+ return err
+ }
+ ws.frameReader = nil
+ }
+again:
+ frame, err := ws.frameReaderFactory.NewFrameReader()
+ if err != nil {
+ return err
+ }
+ frame, err = ws.frameHandler.HandleFrame(frame)
+ if err != nil {
+ return err
+ }
+ if frame == nil {
+ goto again
+ }
+ payloadType := frame.PayloadType()
+ data, err := ioutil.ReadAll(frame)
+ if err != nil {
+ return err
+ }
+ return cd.Unmarshal(data, payloadType, v)
+}
+
+func marshal(v interface{}) (msg []byte, payloadType byte, err error) {
+ switch data := v.(type) {
+ case string:
+ return []byte(data), TextFrame, nil
+ case []byte:
+ return data, BinaryFrame, nil
+ }
+ return nil, UnknownFrame, ErrNotSupported
+}
+
+func unmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
+ switch data := v.(type) {
+ case *string:
+ *data = string(msg)
+ return nil
+ case *[]byte:
+ *data = msg
+ return nil
+ }
+ return ErrNotSupported
+}
+
+/*
+Message is a codec to send/receive text/binary data in a frame on WebSocket connection.
+To send/receive text frame, use string type.
+To send/receive binary frame, use []byte type.
+
+Trivial usage:
+
+ import "websocket"
+
+ // receive text frame
+ var message string
+ websocket.Message.Receive(ws, &message)
+
+ // send text frame
+ message = "hello"
+ websocket.Message.Send(ws, message)
+
+ // receive binary frame
+ var data []byte
+ websocket.Message.Receive(ws, &data)
+
+ // send binary frame
+ data = []byte{0, 1, 2}
+ websocket.Message.Send(ws, data)
+
+*/
+var Message = Codec{marshal, unmarshal}
+
+func jsonMarshal(v interface{}) (msg []byte, payloadType byte, err error) {
+ msg, err = json.Marshal(v)
+ return msg, TextFrame, err
+}
+
+func jsonUnmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
+ return json.Unmarshal(msg, v)
+}
+
+/*
+JSON is a codec to send/receive JSON data in a frame from a WebSocket connection.
+
+Trivial usage:
+
+ import "websocket"
+
+ type T struct {
+ Msg string
+ Count int
+ }
+
+ // receive JSON type T
+ var data T
+ websocket.JSON.Receive(ws, &data)
+
+ // send JSON type T
+ websocket.JSON.Send(ws, data)
+*/
+var JSON = Codec{jsonMarshal, jsonUnmarshal}
diff --git a/vendor/golang.org/x/oauth2/.travis.yml b/vendor/golang.org/x/oauth2/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fa139db225190948bfffb552fbe2d3e13659ec2a
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/.travis.yml
@@ -0,0 +1,13 @@
+language: go
+
+go:
+ - tip
+
+install:
+ - export GOPATH="$HOME/gopath"
+ - mkdir -p "$GOPATH/src/golang.org/x"
+ - mv "$TRAVIS_BUILD_DIR" "$GOPATH/src/golang.org/x/oauth2"
+ - go get -v -t -d golang.org/x/oauth2/...
+
+script:
+ - go test -v golang.org/x/oauth2/...
diff --git a/vendor/golang.org/x/oauth2/AUTHORS b/vendor/golang.org/x/oauth2/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..15167cd746c560e5b3d3b233a169aa64d3e9101e
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/vendor/golang.org/x/oauth2/CONTRIBUTING.md b/vendor/golang.org/x/oauth2/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..46aa2b12dda8b7d4087f1ce12cfd72d9451aa20a
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to Go
+
+Go is an open source project.
+
+It is the work of hundreds of contributors. We appreciate your help!
+
+
+## Filing issues
+
+When [filing an issue](https://github.com/golang/oauth2/issues), make sure to answer these five questions:
+
+1. What version of Go are you using (`go version`)?
+2. What operating system and processor architecture are you using?
+3. What did you do?
+4. What did you expect to see?
+5. What did you see instead?
+
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.
+
+## Contributing code
+
+Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
+before sending patches.
+
+**We do not accept GitHub pull requests**
+(we use [Gerrit](https://code.google.com/p/gerrit/) instead for code review).
+
+Unless otherwise noted, the Go source files are distributed under
+the BSD-style license found in the LICENSE file.
+
diff --git a/vendor/golang.org/x/oauth2/CONTRIBUTORS b/vendor/golang.org/x/oauth2/CONTRIBUTORS
new file mode 100644
index 0000000000000000000000000000000000000000..1c4577e9680611383f46044d17fa343a96997c3c
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/golang.org/x/oauth2/LICENSE b/vendor/golang.org/x/oauth2/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d02f24fd5288303238e195e2520ff64a1f3ea597
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The oauth2 Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/oauth2/README.md b/vendor/golang.org/x/oauth2/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0d5141733f57591c7f0620b6873e82582e794658
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/README.md
@@ -0,0 +1,64 @@
+# OAuth2 for Go
+
+[](https://travis-ci.org/golang/oauth2)
+
+oauth2 package contains a client implementation for OAuth 2.0 spec.
+
+## Installation
+
+~~~~
+go get golang.org/x/oauth2
+~~~~
+
+See godoc for further documentation and examples.
+
+* [godoc.org/golang.org/x/oauth2](http://godoc.org/golang.org/x/oauth2)
+* [godoc.org/golang.org/x/oauth2/google](http://godoc.org/golang.org/x/oauth2/google)
+
+
+## App Engine
+
+In change 96e89be (March 2015) we removed the `oauth2.Context2` type in favor
+of the [`context.Context`](https://golang.org/x/net/context#Context) type from
+the `golang.org/x/net/context` package
+
+This means its no longer possible to use the "Classic App Engine"
+`appengine.Context` type with the `oauth2` package. (You're using
+Classic App Engine if you import the package `"appengine"`.)
+
+To work around this, you may use the new `"google.golang.org/appengine"`
+package. This package has almost the same API as the `"appengine"` package,
+but it can be fetched with `go get` and used on "Managed VMs" and well as
+Classic App Engine.
+
+See the [new `appengine` package's readme](https://github.com/golang/appengine#updating-a-go-app-engine-app)
+for information on updating your app.
+
+If you don't want to update your entire app to use the new App Engine packages,
+you may use both sets of packages in parallel, using only the new packages
+with the `oauth2` package.
+
+ import (
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/google"
+ newappengine "google.golang.org/appengine"
+ newurlfetch "google.golang.org/appengine/urlfetch"
+
+ "appengine"
+ )
+
+ func handler(w http.ResponseWriter, r *http.Request) {
+ var c appengine.Context = appengine.NewContext(r)
+ c.Infof("Logging a message with the old package")
+
+ var ctx context.Context = newappengine.NewContext(r)
+ client := &http.Client{
+ Transport: &oauth2.Transport{
+ Source: google.AppEngineTokenSource(ctx, "scope"),
+ Base: &newurlfetch.Transport{Context: ctx},
+ },
+ }
+ client.Get("...")
+ }
+
diff --git a/vendor/golang.org/x/oauth2/client_appengine.go b/vendor/golang.org/x/oauth2/client_appengine.go
new file mode 100644
index 0000000000000000000000000000000000000000..8962c49d1debbe9fdd953202586e0abc96b8f3b9
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/client_appengine.go
@@ -0,0 +1,25 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+// App Engine hooks.
+
+package oauth2
+
+import (
+ "net/http"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2/internal"
+ "google.golang.org/appengine/urlfetch"
+)
+
+func init() {
+ internal.RegisterContextClientFunc(contextClientAppEngine)
+}
+
+func contextClientAppEngine(ctx context.Context) (*http.Client, error) {
+ return urlfetch.Client(ctx), nil
+}
diff --git a/vendor/golang.org/x/oauth2/google/appengine.go b/vendor/golang.org/x/oauth2/google/appengine.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc993efb5e1013100ba3044c73ca9fefed688192
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/appengine.go
@@ -0,0 +1,86 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package google
+
+import (
+ "sort"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+)
+
+// Set at init time by appenginevm_hook.go. If true, we are on App Engine Managed VMs.
+var appengineVM bool
+
+// Set at init time by appengine_hook.go. If nil, we're not on App Engine.
+var appengineTokenFunc func(c context.Context, scopes ...string) (token string, expiry time.Time, err error)
+
+// AppEngineTokenSource returns a token source that fetches tokens
+// issued to the current App Engine application's service account.
+// If you are implementing a 3-legged OAuth 2.0 flow on App Engine
+// that involves user accounts, see oauth2.Config instead.
+//
+// The provided context must have come from appengine.NewContext.
+func AppEngineTokenSource(ctx context.Context, scope ...string) oauth2.TokenSource {
+ if appengineTokenFunc == nil {
+ panic("google: AppEngineTokenSource can only be used on App Engine.")
+ }
+ scopes := append([]string{}, scope...)
+ sort.Strings(scopes)
+ return &appEngineTokenSource{
+ ctx: ctx,
+ scopes: scopes,
+ key: strings.Join(scopes, " "),
+ }
+}
+
+// aeTokens helps the fetched tokens to be reused until their expiration.
+var (
+ aeTokensMu sync.Mutex
+ aeTokens = make(map[string]*tokenLock) // key is space-separated scopes
+)
+
+type tokenLock struct {
+ mu sync.Mutex // guards t; held while fetching or updating t
+ t *oauth2.Token
+}
+
+type appEngineTokenSource struct {
+ ctx context.Context
+ scopes []string
+ key string // to aeTokens map; space-separated scopes
+}
+
+func (ts *appEngineTokenSource) Token() (*oauth2.Token, error) {
+ if appengineTokenFunc == nil {
+ panic("google: AppEngineTokenSource can only be used on App Engine.")
+ }
+
+ aeTokensMu.Lock()
+ tok, ok := aeTokens[ts.key]
+ if !ok {
+ tok = &tokenLock{}
+ aeTokens[ts.key] = tok
+ }
+ aeTokensMu.Unlock()
+
+ tok.mu.Lock()
+ defer tok.mu.Unlock()
+ if tok.t.Valid() {
+ return tok.t, nil
+ }
+ access, exp, err := appengineTokenFunc(ts.ctx, ts.scopes...)
+ if err != nil {
+ return nil, err
+ }
+ tok.t = &oauth2.Token{
+ AccessToken: access,
+ Expiry: exp,
+ }
+ return tok.t, nil
+}
diff --git a/vendor/golang.org/x/oauth2/google/appengine_hook.go b/vendor/golang.org/x/oauth2/google/appengine_hook.go
new file mode 100644
index 0000000000000000000000000000000000000000..4f42c8b34354abd1a41790515d7d9899534397b1
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/appengine_hook.go
@@ -0,0 +1,13 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package google
+
+import "google.golang.org/appengine"
+
+func init() {
+ appengineTokenFunc = appengine.AccessToken
+}
diff --git a/vendor/golang.org/x/oauth2/google/appenginevm_hook.go b/vendor/golang.org/x/oauth2/google/appenginevm_hook.go
new file mode 100644
index 0000000000000000000000000000000000000000..633611cc3a010b7c591652ce7664ddc9c24f16e4
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/appenginevm_hook.go
@@ -0,0 +1,14 @@
+// Copyright 2015 The oauth2 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appenginevm
+
+package google
+
+import "google.golang.org/appengine"
+
+func init() {
+ appengineVM = true
+ appengineTokenFunc = appengine.AccessToken
+}
diff --git a/vendor/golang.org/x/oauth2/google/default.go b/vendor/golang.org/x/oauth2/google/default.go
new file mode 100644
index 0000000000000000000000000000000000000000..565d731c45b00f1ccd55c07319ee8ebda99dd66e
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/default.go
@@ -0,0 +1,155 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package google
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "os"
+ "path/filepath"
+ "runtime"
+
+ "cloud.google.com/go/compute/metadata"
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/jwt"
+)
+
+// DefaultClient returns an HTTP Client that uses the
+// DefaultTokenSource to obtain authentication credentials.
+//
+// This client should be used when developing services
+// that run on Google App Engine or Google Compute Engine
+// and use "Application Default Credentials."
+//
+// For more details, see:
+// https://developers.google.com/accounts/docs/application-default-credentials
+//
+func DefaultClient(ctx context.Context, scope ...string) (*http.Client, error) {
+ ts, err := DefaultTokenSource(ctx, scope...)
+ if err != nil {
+ return nil, err
+ }
+ return oauth2.NewClient(ctx, ts), nil
+}
+
+// DefaultTokenSource is a token source that uses
+// "Application Default Credentials".
+//
+// It looks for credentials in the following places,
+// preferring the first location found:
+//
+// 1. A JSON file whose path is specified by the
+// GOOGLE_APPLICATION_CREDENTIALS environment variable.
+// 2. A JSON file in a location known to the gcloud command-line tool.
+// On Windows, this is %APPDATA%/gcloud/application_default_credentials.json.
+// On other systems, $HOME/.config/gcloud/application_default_credentials.json.
+// 3. On Google App Engine it uses the appengine.AccessToken function.
+// 4. On Google Compute Engine and Google App Engine Managed VMs, it fetches
+// credentials from the metadata server.
+// (In this final case any provided scopes are ignored.)
+//
+// For more details, see:
+// https://developers.google.com/accounts/docs/application-default-credentials
+//
+func DefaultTokenSource(ctx context.Context, scope ...string) (oauth2.TokenSource, error) {
+ // First, try the environment variable.
+ const envVar = "GOOGLE_APPLICATION_CREDENTIALS"
+ if filename := os.Getenv(envVar); filename != "" {
+ ts, err := tokenSourceFromFile(ctx, filename, scope)
+ if err != nil {
+ return nil, fmt.Errorf("google: error getting credentials using %v environment variable: %v", envVar, err)
+ }
+ return ts, nil
+ }
+
+ // Second, try a well-known file.
+ filename := wellKnownFile()
+ _, err := os.Stat(filename)
+ if err == nil {
+ ts, err2 := tokenSourceFromFile(ctx, filename, scope)
+ if err2 == nil {
+ return ts, nil
+ }
+ err = err2
+ } else if os.IsNotExist(err) {
+ err = nil // ignore this error
+ }
+ if err != nil {
+ return nil, fmt.Errorf("google: error getting credentials using well-known file (%v): %v", filename, err)
+ }
+
+ // Third, if we're on Google App Engine use those credentials.
+ if appengineTokenFunc != nil && !appengineVM {
+ return AppEngineTokenSource(ctx, scope...), nil
+ }
+
+ // Fourth, if we're on Google Compute Engine use the metadata server.
+ if metadata.OnGCE() {
+ return ComputeTokenSource(""), nil
+ }
+
+ // None are found; return helpful error.
+ const url = "https://developers.google.com/accounts/docs/application-default-credentials"
+ return nil, fmt.Errorf("google: could not find default credentials. See %v for more information.", url)
+}
+
+func wellKnownFile() string {
+ const f = "application_default_credentials.json"
+ if runtime.GOOS == "windows" {
+ return filepath.Join(os.Getenv("APPDATA"), "gcloud", f)
+ }
+ return filepath.Join(guessUnixHomeDir(), ".config", "gcloud", f)
+}
+
+func tokenSourceFromFile(ctx context.Context, filename string, scopes []string) (oauth2.TokenSource, error) {
+ b, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ var d struct {
+ // Common fields
+ Type string
+ ClientID string `json:"client_id"`
+
+ // User Credential fields
+ ClientSecret string `json:"client_secret"`
+ RefreshToken string `json:"refresh_token"`
+
+ // Service Account fields
+ ClientEmail string `json:"client_email"`
+ PrivateKeyID string `json:"private_key_id"`
+ PrivateKey string `json:"private_key"`
+ }
+ if err := json.Unmarshal(b, &d); err != nil {
+ return nil, err
+ }
+ switch d.Type {
+ case "authorized_user":
+ cfg := &oauth2.Config{
+ ClientID: d.ClientID,
+ ClientSecret: d.ClientSecret,
+ Scopes: append([]string{}, scopes...), // copy
+ Endpoint: Endpoint,
+ }
+ tok := &oauth2.Token{RefreshToken: d.RefreshToken}
+ return cfg.TokenSource(ctx, tok), nil
+ case "service_account":
+ cfg := &jwt.Config{
+ Email: d.ClientEmail,
+ PrivateKey: []byte(d.PrivateKey),
+ Scopes: append([]string{}, scopes...), // copy
+ TokenURL: JWTTokenURL,
+ }
+ return cfg.TokenSource(ctx), nil
+ case "":
+ return nil, errors.New("missing 'type' field in credentials")
+ default:
+ return nil, fmt.Errorf("unknown credential type: %q", d.Type)
+ }
+}
diff --git a/vendor/golang.org/x/oauth2/google/google.go b/vendor/golang.org/x/oauth2/google/google.go
new file mode 100644
index 0000000000000000000000000000000000000000..ebe0051a5d054d3eba8ef8102a4c0a664b5fb8dc
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/google.go
@@ -0,0 +1,149 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package google provides support for making OAuth2 authorized and
+// authenticated HTTP requests to Google APIs.
+// It supports the Web server flow, client-side credentials, service accounts,
+// Google Compute Engine service accounts, and Google App Engine service
+// accounts.
+//
+// For more information, please read
+// https://developers.google.com/accounts/docs/OAuth2
+// and
+// https://developers.google.com/accounts/docs/application-default-credentials.
+package google
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "strings"
+ "time"
+
+ "cloud.google.com/go/compute/metadata"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/jwt"
+)
+
+// Endpoint is Google's OAuth 2.0 endpoint.
+var Endpoint = oauth2.Endpoint{
+ AuthURL: "https://accounts.google.com/o/oauth2/auth",
+ TokenURL: "https://accounts.google.com/o/oauth2/token",
+}
+
+// JWTTokenURL is Google's OAuth 2.0 token URL to use with the JWT flow.
+const JWTTokenURL = "https://accounts.google.com/o/oauth2/token"
+
+// ConfigFromJSON uses a Google Developers Console client_credentials.json
+// file to construct a config.
+// client_credentials.json can be downloaded from
+// https://console.developers.google.com, under "Credentials". Download the Web
+// application credentials in the JSON format and provide the contents of the
+// file as jsonKey.
+func ConfigFromJSON(jsonKey []byte, scope ...string) (*oauth2.Config, error) {
+ type cred struct {
+ ClientID string `json:"client_id"`
+ ClientSecret string `json:"client_secret"`
+ RedirectURIs []string `json:"redirect_uris"`
+ AuthURI string `json:"auth_uri"`
+ TokenURI string `json:"token_uri"`
+ }
+ var j struct {
+ Web *cred `json:"web"`
+ Installed *cred `json:"installed"`
+ }
+ if err := json.Unmarshal(jsonKey, &j); err != nil {
+ return nil, err
+ }
+ var c *cred
+ switch {
+ case j.Web != nil:
+ c = j.Web
+ case j.Installed != nil:
+ c = j.Installed
+ default:
+ return nil, fmt.Errorf("oauth2/google: no credentials found")
+ }
+ if len(c.RedirectURIs) < 1 {
+ return nil, errors.New("oauth2/google: missing redirect URL in the client_credentials.json")
+ }
+ return &oauth2.Config{
+ ClientID: c.ClientID,
+ ClientSecret: c.ClientSecret,
+ RedirectURL: c.RedirectURIs[0],
+ Scopes: scope,
+ Endpoint: oauth2.Endpoint{
+ AuthURL: c.AuthURI,
+ TokenURL: c.TokenURI,
+ },
+ }, nil
+}
+
+// JWTConfigFromJSON uses a Google Developers service account JSON key file to read
+// the credentials that authorize and authenticate the requests.
+// Create a service account on "Credentials" for your project at
+// https://console.developers.google.com to download a JSON key file.
+func JWTConfigFromJSON(jsonKey []byte, scope ...string) (*jwt.Config, error) {
+ var key struct {
+ Email string `json:"client_email"`
+ PrivateKey string `json:"private_key"`
+ PrivateKeyID string `json:"private_key_id"`
+ }
+ if err := json.Unmarshal(jsonKey, &key); err != nil {
+ return nil, err
+ }
+ config := &jwt.Config{
+ Email: key.Email,
+ PrivateKey: []byte(key.PrivateKey),
+ PrivateKeyID: key.PrivateKeyID,
+ Scopes: scope,
+ TokenURL: JWTTokenURL,
+ }
+ return config, nil
+}
+
+// ComputeTokenSource returns a token source that fetches access tokens
+// from Google Compute Engine (GCE)'s metadata server. It's only valid to use
+// this token source if your program is running on a GCE instance.
+// If no account is specified, "default" is used.
+// Further information about retrieving access tokens from the GCE metadata
+// server can be found at https://cloud.google.com/compute/docs/authentication.
+func ComputeTokenSource(account string) oauth2.TokenSource {
+ return oauth2.ReuseTokenSource(nil, computeSource{account: account})
+}
+
+type computeSource struct {
+ account string
+}
+
+func (cs computeSource) Token() (*oauth2.Token, error) {
+ if !metadata.OnGCE() {
+ return nil, errors.New("oauth2/google: can't get a token from the metadata service; not running on GCE")
+ }
+ acct := cs.account
+ if acct == "" {
+ acct = "default"
+ }
+ tokenJSON, err := metadata.Get("instance/service-accounts/" + acct + "/token")
+ if err != nil {
+ return nil, err
+ }
+ var res struct {
+ AccessToken string `json:"access_token"`
+ ExpiresInSec int `json:"expires_in"`
+ TokenType string `json:"token_type"`
+ }
+ err = json.NewDecoder(strings.NewReader(tokenJSON)).Decode(&res)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2/google: invalid token JSON from metadata: %v", err)
+ }
+ if res.ExpiresInSec == 0 || res.AccessToken == "" {
+ return nil, fmt.Errorf("oauth2/google: incomplete token received from metadata")
+ }
+ return &oauth2.Token{
+ AccessToken: res.AccessToken,
+ TokenType: res.TokenType,
+ Expiry: time.Now().Add(time.Duration(res.ExpiresInSec) * time.Second),
+ }, nil
+}
diff --git a/vendor/golang.org/x/oauth2/google/jwt.go b/vendor/golang.org/x/oauth2/google/jwt.go
new file mode 100644
index 0000000000000000000000000000000000000000..b0fdb3a888ac357f37945869f3ab3f31fbc96b4c
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/jwt.go
@@ -0,0 +1,74 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package google
+
+import (
+ "crypto/rsa"
+ "fmt"
+ "time"
+
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/internal"
+ "golang.org/x/oauth2/jws"
+)
+
+// JWTAccessTokenSourceFromJSON uses a Google Developers service account JSON
+// key file to read the credentials that authorize and authenticate the
+// requests, and returns a TokenSource that does not use any OAuth2 flow but
+// instead creates a JWT and sends that as the access token.
+// The audience is typically a URL that specifies the scope of the credentials.
+//
+// Note that this is not a standard OAuth flow, but rather an
+// optimization supported by a few Google services.
+// Unless you know otherwise, you should use JWTConfigFromJSON instead.
+func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.TokenSource, error) {
+ cfg, err := JWTConfigFromJSON(jsonKey)
+ if err != nil {
+ return nil, fmt.Errorf("google: could not parse JSON key: %v", err)
+ }
+ pk, err := internal.ParseKey(cfg.PrivateKey)
+ if err != nil {
+ return nil, fmt.Errorf("google: could not parse key: %v", err)
+ }
+ ts := &jwtAccessTokenSource{
+ email: cfg.Email,
+ audience: audience,
+ pk: pk,
+ pkID: cfg.PrivateKeyID,
+ }
+ tok, err := ts.Token()
+ if err != nil {
+ return nil, err
+ }
+ return oauth2.ReuseTokenSource(tok, ts), nil
+}
+
+type jwtAccessTokenSource struct {
+ email, audience string
+ pk *rsa.PrivateKey
+ pkID string
+}
+
+func (ts *jwtAccessTokenSource) Token() (*oauth2.Token, error) {
+ iat := time.Now()
+ exp := iat.Add(time.Hour)
+ cs := &jws.ClaimSet{
+ Iss: ts.email,
+ Sub: ts.email,
+ Aud: ts.audience,
+ Iat: iat.Unix(),
+ Exp: exp.Unix(),
+ }
+ hdr := &jws.Header{
+ Algorithm: "RS256",
+ Typ: "JWT",
+ KeyID: string(ts.pkID),
+ }
+ msg, err := jws.Encode(hdr, cs, ts.pk)
+ if err != nil {
+ return nil, fmt.Errorf("google: could not encode JWT: %v", err)
+ }
+ return &oauth2.Token{AccessToken: msg, TokenType: "Bearer", Expiry: exp}, nil
+}
diff --git a/vendor/golang.org/x/oauth2/google/sdk.go b/vendor/golang.org/x/oauth2/google/sdk.go
new file mode 100644
index 0000000000000000000000000000000000000000..d29a3bb9bbc5e24021489c613de6096b8ff91b20
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/google/sdk.go
@@ -0,0 +1,168 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package google
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "os"
+ "os/user"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "time"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/internal"
+)
+
+type sdkCredentials struct {
+ Data []struct {
+ Credential struct {
+ ClientID string `json:"client_id"`
+ ClientSecret string `json:"client_secret"`
+ AccessToken string `json:"access_token"`
+ RefreshToken string `json:"refresh_token"`
+ TokenExpiry *time.Time `json:"token_expiry"`
+ } `json:"credential"`
+ Key struct {
+ Account string `json:"account"`
+ Scope string `json:"scope"`
+ } `json:"key"`
+ }
+}
+
+// An SDKConfig provides access to tokens from an account already
+// authorized via the Google Cloud SDK.
+type SDKConfig struct {
+ conf oauth2.Config
+ initialToken *oauth2.Token
+}
+
+// NewSDKConfig creates an SDKConfig for the given Google Cloud SDK
+// account. If account is empty, the account currently active in
+// Google Cloud SDK properties is used.
+// Google Cloud SDK credentials must be created by running `gcloud auth`
+// before using this function.
+// The Google Cloud SDK is available at https://cloud.google.com/sdk/.
+func NewSDKConfig(account string) (*SDKConfig, error) {
+ configPath, err := sdkConfigPath()
+ if err != nil {
+ return nil, fmt.Errorf("oauth2/google: error getting SDK config path: %v", err)
+ }
+ credentialsPath := filepath.Join(configPath, "credentials")
+ f, err := os.Open(credentialsPath)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2/google: failed to load SDK credentials: %v", err)
+ }
+ defer f.Close()
+
+ var c sdkCredentials
+ if err := json.NewDecoder(f).Decode(&c); err != nil {
+ return nil, fmt.Errorf("oauth2/google: failed to decode SDK credentials from %q: %v", credentialsPath, err)
+ }
+ if len(c.Data) == 0 {
+ return nil, fmt.Errorf("oauth2/google: no credentials found in %q, run `gcloud auth login` to create one", credentialsPath)
+ }
+ if account == "" {
+ propertiesPath := filepath.Join(configPath, "properties")
+ f, err := os.Open(propertiesPath)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2/google: failed to load SDK properties: %v", err)
+ }
+ defer f.Close()
+ ini, err := internal.ParseINI(f)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2/google: failed to parse SDK properties %q: %v", propertiesPath, err)
+ }
+ core, ok := ini["core"]
+ if !ok {
+ return nil, fmt.Errorf("oauth2/google: failed to find [core] section in %v", ini)
+ }
+ active, ok := core["account"]
+ if !ok {
+ return nil, fmt.Errorf("oauth2/google: failed to find %q attribute in %v", "account", core)
+ }
+ account = active
+ }
+
+ for _, d := range c.Data {
+ if account == "" || d.Key.Account == account {
+ if d.Credential.AccessToken == "" && d.Credential.RefreshToken == "" {
+ return nil, fmt.Errorf("oauth2/google: no token available for account %q", account)
+ }
+ var expiry time.Time
+ if d.Credential.TokenExpiry != nil {
+ expiry = *d.Credential.TokenExpiry
+ }
+ return &SDKConfig{
+ conf: oauth2.Config{
+ ClientID: d.Credential.ClientID,
+ ClientSecret: d.Credential.ClientSecret,
+ Scopes: strings.Split(d.Key.Scope, " "),
+ Endpoint: Endpoint,
+ RedirectURL: "oob",
+ },
+ initialToken: &oauth2.Token{
+ AccessToken: d.Credential.AccessToken,
+ RefreshToken: d.Credential.RefreshToken,
+ Expiry: expiry,
+ },
+ }, nil
+ }
+ }
+ return nil, fmt.Errorf("oauth2/google: no such credentials for account %q", account)
+}
+
+// Client returns an HTTP client using Google Cloud SDK credentials to
+// authorize requests. The token will auto-refresh as necessary. The
+// underlying http.RoundTripper will be obtained using the provided
+// context. The returned client and its Transport should not be
+// modified.
+func (c *SDKConfig) Client(ctx context.Context) *http.Client {
+ return &http.Client{
+ Transport: &oauth2.Transport{
+ Source: c.TokenSource(ctx),
+ },
+ }
+}
+
+// TokenSource returns an oauth2.TokenSource that retrieve tokens from
+// Google Cloud SDK credentials using the provided context.
+// It will returns the current access token stored in the credentials,
+// and refresh it when it expires, but it won't update the credentials
+// with the new access token.
+func (c *SDKConfig) TokenSource(ctx context.Context) oauth2.TokenSource {
+ return c.conf.TokenSource(ctx, c.initialToken)
+}
+
+// Scopes are the OAuth 2.0 scopes the current account is authorized for.
+func (c *SDKConfig) Scopes() []string {
+ return c.conf.Scopes
+}
+
+// sdkConfigPath tries to guess where the gcloud config is located.
+// It can be overridden during tests.
+var sdkConfigPath = func() (string, error) {
+ if runtime.GOOS == "windows" {
+ return filepath.Join(os.Getenv("APPDATA"), "gcloud"), nil
+ }
+ homeDir := guessUnixHomeDir()
+ if homeDir == "" {
+ return "", errors.New("unable to get current user home directory: os/user lookup failed; $HOME is empty")
+ }
+ return filepath.Join(homeDir, ".config", "gcloud"), nil
+}
+
+func guessUnixHomeDir() string {
+ usr, err := user.Current()
+ if err == nil {
+ return usr.HomeDir
+ }
+ return os.Getenv("HOME")
+}
diff --git a/vendor/golang.org/x/oauth2/internal/oauth2.go b/vendor/golang.org/x/oauth2/internal/oauth2.go
new file mode 100644
index 0000000000000000000000000000000000000000..fbe1028d64e52ba0cdec9007944932df79a2e8d7
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/internal/oauth2.go
@@ -0,0 +1,76 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package internal contains support packages for oauth2 package.
+package internal
+
+import (
+ "bufio"
+ "crypto/rsa"
+ "crypto/x509"
+ "encoding/pem"
+ "errors"
+ "fmt"
+ "io"
+ "strings"
+)
+
+// ParseKey converts the binary contents of a private key file
+// to an *rsa.PrivateKey. It detects whether the private key is in a
+// PEM container or not. If so, it extracts the the private key
+// from PEM container before conversion. It only supports PEM
+// containers with no passphrase.
+func ParseKey(key []byte) (*rsa.PrivateKey, error) {
+ block, _ := pem.Decode(key)
+ if block != nil {
+ key = block.Bytes
+ }
+ parsedKey, err := x509.ParsePKCS8PrivateKey(key)
+ if err != nil {
+ parsedKey, err = x509.ParsePKCS1PrivateKey(key)
+ if err != nil {
+ return nil, fmt.Errorf("private key should be a PEM or plain PKSC1 or PKCS8; parse error: %v", err)
+ }
+ }
+ parsed, ok := parsedKey.(*rsa.PrivateKey)
+ if !ok {
+ return nil, errors.New("private key is invalid")
+ }
+ return parsed, nil
+}
+
+func ParseINI(ini io.Reader) (map[string]map[string]string, error) {
+ result := map[string]map[string]string{
+ "": map[string]string{}, // root section
+ }
+ scanner := bufio.NewScanner(ini)
+ currentSection := ""
+ for scanner.Scan() {
+ line := strings.TrimSpace(scanner.Text())
+ if strings.HasPrefix(line, ";") {
+ // comment.
+ continue
+ }
+ if strings.HasPrefix(line, "[") && strings.HasSuffix(line, "]") {
+ currentSection = strings.TrimSpace(line[1 : len(line)-1])
+ result[currentSection] = map[string]string{}
+ continue
+ }
+ parts := strings.SplitN(line, "=", 2)
+ if len(parts) == 2 && parts[0] != "" {
+ result[currentSection][strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+ }
+ }
+ if err := scanner.Err(); err != nil {
+ return nil, fmt.Errorf("error scanning ini: %v", err)
+ }
+ return result, nil
+}
+
+func CondVal(v string) []string {
+ if v == "" {
+ return nil
+ }
+ return []string{v}
+}
diff --git a/vendor/golang.org/x/oauth2/internal/token.go b/vendor/golang.org/x/oauth2/internal/token.go
new file mode 100644
index 0000000000000000000000000000000000000000..18328a0dcf2edeee851a8ad7a79a83408a54da97
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/internal/token.go
@@ -0,0 +1,225 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package internal contains support packages for oauth2 package.
+package internal
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "mime"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+
+ "golang.org/x/net/context"
+)
+
+// Token represents the crendentials used to authorize
+// the requests to access protected resources on the OAuth 2.0
+// provider's backend.
+//
+// This type is a mirror of oauth2.Token and exists to break
+// an otherwise-circular dependency. Other internal packages
+// should convert this Token into an oauth2.Token before use.
+type Token struct {
+ // AccessToken is the token that authorizes and authenticates
+ // the requests.
+ AccessToken string
+
+ // TokenType is the type of token.
+ // The Type method returns either this or "Bearer", the default.
+ TokenType string
+
+ // RefreshToken is a token that's used by the application
+ // (as opposed to the user) to refresh the access token
+ // if it expires.
+ RefreshToken string
+
+ // Expiry is the optional expiration time of the access token.
+ //
+ // If zero, TokenSource implementations will reuse the same
+ // token forever and RefreshToken or equivalent
+ // mechanisms for that TokenSource will not be used.
+ Expiry time.Time
+
+ // Raw optionally contains extra metadata from the server
+ // when updating a token.
+ Raw interface{}
+}
+
+// tokenJSON is the struct representing the HTTP response from OAuth2
+// providers returning a token in JSON form.
+type tokenJSON struct {
+ AccessToken string `json:"access_token"`
+ TokenType string `json:"token_type"`
+ RefreshToken string `json:"refresh_token"`
+ ExpiresIn expirationTime `json:"expires_in"` // at least PayPal returns string, while most return number
+ Expires expirationTime `json:"expires"` // broken Facebook spelling of expires_in
+}
+
+func (e *tokenJSON) expiry() (t time.Time) {
+ if v := e.ExpiresIn; v != 0 {
+ return time.Now().Add(time.Duration(v) * time.Second)
+ }
+ if v := e.Expires; v != 0 {
+ return time.Now().Add(time.Duration(v) * time.Second)
+ }
+ return
+}
+
+type expirationTime int32
+
+func (e *expirationTime) UnmarshalJSON(b []byte) error {
+ var n json.Number
+ err := json.Unmarshal(b, &n)
+ if err != nil {
+ return err
+ }
+ i, err := n.Int64()
+ if err != nil {
+ return err
+ }
+ *e = expirationTime(i)
+ return nil
+}
+
+var brokenAuthHeaderProviders = []string{
+ "https://accounts.google.com/",
+ "https://api.dropbox.com/",
+ "https://api.dropboxapi.com/",
+ "https://api.instagram.com/",
+ "https://api.netatmo.net/",
+ "https://api.odnoklassniki.ru/",
+ "https://api.pushbullet.com/",
+ "https://api.soundcloud.com/",
+ "https://api.twitch.tv/",
+ "https://app.box.com/",
+ "https://connect.stripe.com/",
+ "https://login.microsoftonline.com/",
+ "https://login.salesforce.com/",
+ "https://oauth.sandbox.trainingpeaks.com/",
+ "https://oauth.trainingpeaks.com/",
+ "https://oauth.vk.com/",
+ "https://openapi.baidu.com/",
+ "https://slack.com/",
+ "https://test-sandbox.auth.corp.google.com",
+ "https://test.salesforce.com/",
+ "https://user.gini.net/",
+ "https://www.douban.com/",
+ "https://www.googleapis.com/",
+ "https://www.linkedin.com/",
+ "https://www.strava.com/oauth/",
+ "https://www.wunderlist.com/oauth/",
+ "https://api.patreon.com/",
+}
+
+func RegisterBrokenAuthHeaderProvider(tokenURL string) {
+ brokenAuthHeaderProviders = append(brokenAuthHeaderProviders, tokenURL)
+}
+
+// providerAuthHeaderWorks reports whether the OAuth2 server identified by the tokenURL
+// implements the OAuth2 spec correctly
+// See https://code.google.com/p/goauth2/issues/detail?id=31 for background.
+// In summary:
+// - Reddit only accepts client secret in the Authorization header
+// - Dropbox accepts either it in URL param or Auth header, but not both.
+// - Google only accepts URL param (not spec compliant?), not Auth header
+// - Stripe only accepts client secret in Auth header with Bearer method, not Basic
+func providerAuthHeaderWorks(tokenURL string) bool {
+ for _, s := range brokenAuthHeaderProviders {
+ if strings.HasPrefix(tokenURL, s) {
+ // Some sites fail to implement the OAuth2 spec fully.
+ return false
+ }
+ }
+
+ // Assume the provider implements the spec properly
+ // otherwise. We can add more exceptions as they're
+ // discovered. We will _not_ be adding configurable hooks
+ // to this package to let users select server bugs.
+ return true
+}
+
+func RetrieveToken(ctx context.Context, clientID, clientSecret, tokenURL string, v url.Values) (*Token, error) {
+ hc, err := ContextClient(ctx)
+ if err != nil {
+ return nil, err
+ }
+ v.Set("client_id", clientID)
+ bustedAuth := !providerAuthHeaderWorks(tokenURL)
+ if bustedAuth && clientSecret != "" {
+ v.Set("client_secret", clientSecret)
+ }
+ req, err := http.NewRequest("POST", tokenURL, strings.NewReader(v.Encode()))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+ if !bustedAuth {
+ req.SetBasicAuth(clientID, clientSecret)
+ }
+ r, err := hc.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer r.Body.Close()
+ body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1<<20))
+ if err != nil {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
+ }
+ if code := r.StatusCode; code < 200 || code > 299 {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", r.Status, body)
+ }
+
+ var token *Token
+ content, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
+ switch content {
+ case "application/x-www-form-urlencoded", "text/plain":
+ vals, err := url.ParseQuery(string(body))
+ if err != nil {
+ return nil, err
+ }
+ token = &Token{
+ AccessToken: vals.Get("access_token"),
+ TokenType: vals.Get("token_type"),
+ RefreshToken: vals.Get("refresh_token"),
+ Raw: vals,
+ }
+ e := vals.Get("expires_in")
+ if e == "" {
+ // TODO(jbd): Facebook's OAuth2 implementation is broken and
+ // returns expires_in field in expires. Remove the fallback to expires,
+ // when Facebook fixes their implementation.
+ e = vals.Get("expires")
+ }
+ expires, _ := strconv.Atoi(e)
+ if expires != 0 {
+ token.Expiry = time.Now().Add(time.Duration(expires) * time.Second)
+ }
+ default:
+ var tj tokenJSON
+ if err = json.Unmarshal(body, &tj); err != nil {
+ return nil, err
+ }
+ token = &Token{
+ AccessToken: tj.AccessToken,
+ TokenType: tj.TokenType,
+ RefreshToken: tj.RefreshToken,
+ Expiry: tj.expiry(),
+ Raw: make(map[string]interface{}),
+ }
+ json.Unmarshal(body, &token.Raw) // no error checks for optional fields
+ }
+ // Don't overwrite `RefreshToken` with an empty value
+ // if this was a token refreshing request.
+ if token.RefreshToken == "" {
+ token.RefreshToken = v.Get("refresh_token")
+ }
+ return token, nil
+}
diff --git a/vendor/golang.org/x/oauth2/internal/transport.go b/vendor/golang.org/x/oauth2/internal/transport.go
new file mode 100644
index 0000000000000000000000000000000000000000..f1f173e345db0c2582b7491d9639aa95ceb3cb4c
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/internal/transport.go
@@ -0,0 +1,69 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package internal contains support packages for oauth2 package.
+package internal
+
+import (
+ "net/http"
+
+ "golang.org/x/net/context"
+)
+
+// HTTPClient is the context key to use with golang.org/x/net/context's
+// WithValue function to associate an *http.Client value with a context.
+var HTTPClient ContextKey
+
+// ContextKey is just an empty struct. It exists so HTTPClient can be
+// an immutable public variable with a unique type. It's immutable
+// because nobody else can create a ContextKey, being unexported.
+type ContextKey struct{}
+
+// ContextClientFunc is a func which tries to return an *http.Client
+// given a Context value. If it returns an error, the search stops
+// with that error. If it returns (nil, nil), the search continues
+// down the list of registered funcs.
+type ContextClientFunc func(context.Context) (*http.Client, error)
+
+var contextClientFuncs []ContextClientFunc
+
+func RegisterContextClientFunc(fn ContextClientFunc) {
+ contextClientFuncs = append(contextClientFuncs, fn)
+}
+
+func ContextClient(ctx context.Context) (*http.Client, error) {
+ if ctx != nil {
+ if hc, ok := ctx.Value(HTTPClient).(*http.Client); ok {
+ return hc, nil
+ }
+ }
+ for _, fn := range contextClientFuncs {
+ c, err := fn(ctx)
+ if err != nil {
+ return nil, err
+ }
+ if c != nil {
+ return c, nil
+ }
+ }
+ return http.DefaultClient, nil
+}
+
+func ContextTransport(ctx context.Context) http.RoundTripper {
+ hc, err := ContextClient(ctx)
+ // This is a rare error case (somebody using nil on App Engine).
+ if err != nil {
+ return ErrorTransport{err}
+ }
+ return hc.Transport
+}
+
+// ErrorTransport returns the specified error on RoundTrip.
+// This RoundTripper should be used in rare error cases where
+// error handling can be postponed to response handling time.
+type ErrorTransport struct{ Err error }
+
+func (t ErrorTransport) RoundTrip(*http.Request) (*http.Response, error) {
+ return nil, t.Err
+}
diff --git a/vendor/golang.org/x/oauth2/jws/jws.go b/vendor/golang.org/x/oauth2/jws/jws.go
new file mode 100644
index 0000000000000000000000000000000000000000..33857dbafa44fe3b3a3c7c7d91da94dcac5a31d6
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/jws/jws.go
@@ -0,0 +1,174 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package jws provides encoding and decoding utilities for
+// signed JWS messages.
+package jws
+
+import (
+ "bytes"
+ "crypto"
+ "crypto/rand"
+ "crypto/rsa"
+ "crypto/sha256"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "strings"
+ "time"
+)
+
+// ClaimSet contains information about the JWT signature including the
+// permissions being requested (scopes), the target of the token, the issuer,
+// the time the token was issued, and the lifetime of the token.
+type ClaimSet struct {
+ Iss string `json:"iss"` // email address of the client_id of the application making the access token request
+ Scope string `json:"scope,omitempty"` // space-delimited list of the permissions the application requests
+ Aud string `json:"aud"` // descriptor of the intended target of the assertion (Optional).
+ Exp int64 `json:"exp"` // the expiration time of the assertion (seconds since Unix epoch)
+ Iat int64 `json:"iat"` // the time the assertion was issued (seconds since Unix epoch)
+ Typ string `json:"typ,omitempty"` // token type (Optional).
+
+ // Email for which the application is requesting delegated access (Optional).
+ Sub string `json:"sub,omitempty"`
+
+ // The old name of Sub. Client keeps setting Prn to be
+ // complaint with legacy OAuth 2.0 providers. (Optional)
+ Prn string `json:"prn,omitempty"`
+
+ // See http://tools.ietf.org/html/draft-jones-json-web-token-10#section-4.3
+ // This array is marshalled using custom code (see (c *ClaimSet) encode()).
+ PrivateClaims map[string]interface{} `json:"-"`
+}
+
+func (c *ClaimSet) encode() (string, error) {
+ // Reverting time back for machines whose time is not perfectly in sync.
+ // If client machine's time is in the future according
+ // to Google servers, an access token will not be issued.
+ now := time.Now().Add(-10 * time.Second)
+ if c.Iat == 0 {
+ c.Iat = now.Unix()
+ }
+ if c.Exp == 0 {
+ c.Exp = now.Add(time.Hour).Unix()
+ }
+ if c.Exp < c.Iat {
+ return "", fmt.Errorf("jws: invalid Exp = %v; must be later than Iat = %v", c.Exp, c.Iat)
+ }
+
+ b, err := json.Marshal(c)
+ if err != nil {
+ return "", err
+ }
+
+ if len(c.PrivateClaims) == 0 {
+ return base64.RawURLEncoding.EncodeToString(b), nil
+ }
+
+ // Marshal private claim set and then append it to b.
+ prv, err := json.Marshal(c.PrivateClaims)
+ if err != nil {
+ return "", fmt.Errorf("jws: invalid map of private claims %v", c.PrivateClaims)
+ }
+
+ // Concatenate public and private claim JSON objects.
+ if !bytes.HasSuffix(b, []byte{'}'}) {
+ return "", fmt.Errorf("jws: invalid JSON %s", b)
+ }
+ if !bytes.HasPrefix(prv, []byte{'{'}) {
+ return "", fmt.Errorf("jws: invalid JSON %s", prv)
+ }
+ b[len(b)-1] = ',' // Replace closing curly brace with a comma.
+ b = append(b, prv[1:]...) // Append private claims.
+ return base64.RawURLEncoding.EncodeToString(b), nil
+}
+
+// Header represents the header for the signed JWS payloads.
+type Header struct {
+ // The algorithm used for signature.
+ Algorithm string `json:"alg"`
+
+ // Represents the token type.
+ Typ string `json:"typ"`
+
+ // The optional hint of which key is being used.
+ KeyID string `json:"kid,omitempty"`
+}
+
+func (h *Header) encode() (string, error) {
+ b, err := json.Marshal(h)
+ if err != nil {
+ return "", err
+ }
+ return base64.RawURLEncoding.EncodeToString(b), nil
+}
+
+// Decode decodes a claim set from a JWS payload.
+func Decode(payload string) (*ClaimSet, error) {
+ // decode returned id token to get expiry
+ s := strings.Split(payload, ".")
+ if len(s) < 2 {
+ // TODO(jbd): Provide more context about the error.
+ return nil, errors.New("jws: invalid token received")
+ }
+ decoded, err := base64.RawURLEncoding.DecodeString(s[1])
+ if err != nil {
+ return nil, err
+ }
+ c := &ClaimSet{}
+ err = json.NewDecoder(bytes.NewBuffer(decoded)).Decode(c)
+ return c, err
+}
+
+// Signer returns a signature for the given data.
+type Signer func(data []byte) (sig []byte, err error)
+
+// EncodeWithSigner encodes a header and claim set with the provided signer.
+func EncodeWithSigner(header *Header, c *ClaimSet, sg Signer) (string, error) {
+ head, err := header.encode()
+ if err != nil {
+ return "", err
+ }
+ cs, err := c.encode()
+ if err != nil {
+ return "", err
+ }
+ ss := fmt.Sprintf("%s.%s", head, cs)
+ sig, err := sg([]byte(ss))
+ if err != nil {
+ return "", err
+ }
+ return fmt.Sprintf("%s.%s", ss, base64.RawURLEncoding.EncodeToString(sig)), nil
+}
+
+// Encode encodes a signed JWS with provided header and claim set.
+// This invokes EncodeWithSigner using crypto/rsa.SignPKCS1v15 with the given RSA private key.
+func Encode(header *Header, c *ClaimSet, key *rsa.PrivateKey) (string, error) {
+ sg := func(data []byte) (sig []byte, err error) {
+ h := sha256.New()
+ h.Write(data)
+ return rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, h.Sum(nil))
+ }
+ return EncodeWithSigner(header, c, sg)
+}
+
+// Verify tests whether the provided JWT token's signature was produced by the private key
+// associated with the supplied public key.
+func Verify(token string, key *rsa.PublicKey) error {
+ parts := strings.Split(token, ".")
+ if len(parts) != 3 {
+ return errors.New("jws: invalid token received, token must have 3 parts")
+ }
+
+ signedContent := parts[0] + "." + parts[1]
+ signatureString, err := base64.RawURLEncoding.DecodeString(parts[2])
+ if err != nil {
+ return err
+ }
+
+ h := sha256.New()
+ h.Write([]byte(signedContent))
+ return rsa.VerifyPKCS1v15(key, crypto.SHA256, h.Sum(nil), []byte(signatureString))
+}
diff --git a/vendor/golang.org/x/oauth2/jwt/jwt.go b/vendor/golang.org/x/oauth2/jwt/jwt.go
new file mode 100644
index 0000000000000000000000000000000000000000..f4b9523e6e4ccd47e52d39217ce9306e09d472eb
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/jwt/jwt.go
@@ -0,0 +1,157 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package jwt implements the OAuth 2.0 JSON Web Token flow, commonly
+// known as "two-legged OAuth 2.0".
+//
+// See: https://tools.ietf.org/html/draft-ietf-oauth-jwt-bearer-12
+package jwt
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/internal"
+ "golang.org/x/oauth2/jws"
+)
+
+var (
+ defaultGrantType = "urn:ietf:params:oauth:grant-type:jwt-bearer"
+ defaultHeader = &jws.Header{Algorithm: "RS256", Typ: "JWT"}
+)
+
+// Config is the configuration for using JWT to fetch tokens,
+// commonly known as "two-legged OAuth 2.0".
+type Config struct {
+ // Email is the OAuth client identifier used when communicating with
+ // the configured OAuth provider.
+ Email string
+
+ // PrivateKey contains the contents of an RSA private key or the
+ // contents of a PEM file that contains a private key. The provided
+ // private key is used to sign JWT payloads.
+ // PEM containers with a passphrase are not supported.
+ // Use the following command to convert a PKCS 12 file into a PEM.
+ //
+ // $ openssl pkcs12 -in key.p12 -out key.pem -nodes
+ //
+ PrivateKey []byte
+
+ // PrivateKeyID contains an optional hint indicating which key is being
+ // used.
+ PrivateKeyID string
+
+ // Subject is the optional user to impersonate.
+ Subject string
+
+ // Scopes optionally specifies a list of requested permission scopes.
+ Scopes []string
+
+ // TokenURL is the endpoint required to complete the 2-legged JWT flow.
+ TokenURL string
+
+ // Expires optionally specifies how long the token is valid for.
+ Expires time.Duration
+}
+
+// TokenSource returns a JWT TokenSource using the configuration
+// in c and the HTTP client from the provided context.
+func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource {
+ return oauth2.ReuseTokenSource(nil, jwtSource{ctx, c})
+}
+
+// Client returns an HTTP client wrapping the context's
+// HTTP transport and adding Authorization headers with tokens
+// obtained from c.
+//
+// The returned client and its Transport should not be modified.
+func (c *Config) Client(ctx context.Context) *http.Client {
+ return oauth2.NewClient(ctx, c.TokenSource(ctx))
+}
+
+// jwtSource is a source that always does a signed JWT request for a token.
+// It should typically be wrapped with a reuseTokenSource.
+type jwtSource struct {
+ ctx context.Context
+ conf *Config
+}
+
+func (js jwtSource) Token() (*oauth2.Token, error) {
+ pk, err := internal.ParseKey(js.conf.PrivateKey)
+ if err != nil {
+ return nil, err
+ }
+ hc := oauth2.NewClient(js.ctx, nil)
+ claimSet := &jws.ClaimSet{
+ Iss: js.conf.Email,
+ Scope: strings.Join(js.conf.Scopes, " "),
+ Aud: js.conf.TokenURL,
+ }
+ if subject := js.conf.Subject; subject != "" {
+ claimSet.Sub = subject
+ // prn is the old name of sub. Keep setting it
+ // to be compatible with legacy OAuth 2.0 providers.
+ claimSet.Prn = subject
+ }
+ if t := js.conf.Expires; t > 0 {
+ claimSet.Exp = time.Now().Add(t).Unix()
+ }
+ payload, err := jws.Encode(defaultHeader, claimSet, pk)
+ if err != nil {
+ return nil, err
+ }
+ v := url.Values{}
+ v.Set("grant_type", defaultGrantType)
+ v.Set("assertion", payload)
+ resp, err := hc.PostForm(js.conf.TokenURL, v)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
+ }
+ defer resp.Body.Close()
+ body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1<<20))
+ if err != nil {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
+ }
+ if c := resp.StatusCode; c < 200 || c > 299 {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v\nResponse: %s", resp.Status, body)
+ }
+ // tokenRes is the JSON response body.
+ var tokenRes struct {
+ AccessToken string `json:"access_token"`
+ TokenType string `json:"token_type"`
+ IDToken string `json:"id_token"`
+ ExpiresIn int64 `json:"expires_in"` // relative seconds from now
+ }
+ if err := json.Unmarshal(body, &tokenRes); err != nil {
+ return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
+ }
+ token := &oauth2.Token{
+ AccessToken: tokenRes.AccessToken,
+ TokenType: tokenRes.TokenType,
+ }
+ raw := make(map[string]interface{})
+ json.Unmarshal(body, &raw) // no error checks for optional fields
+ token = token.WithExtra(raw)
+
+ if secs := tokenRes.ExpiresIn; secs > 0 {
+ token.Expiry = time.Now().Add(time.Duration(secs) * time.Second)
+ }
+ if v := tokenRes.IDToken; v != "" {
+ // decode returned id token to get expiry
+ claimSet, err := jws.Decode(v)
+ if err != nil {
+ return nil, fmt.Errorf("oauth2: error decoding JWT token: %v", err)
+ }
+ token.Expiry = time.Unix(claimSet.Exp, 0)
+ }
+ return token, nil
+}
diff --git a/vendor/golang.org/x/oauth2/oauth2.go b/vendor/golang.org/x/oauth2/oauth2.go
new file mode 100644
index 0000000000000000000000000000000000000000..b0d527027249394ed9068bb5fba87c9e424cdfb9
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/oauth2.go
@@ -0,0 +1,339 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package oauth2 provides support for making
+// OAuth2 authorized and authenticated HTTP requests.
+// It can additionally grant authorization with Bearer JWT.
+package oauth2
+
+import (
+ "bytes"
+ "errors"
+ "net/http"
+ "net/url"
+ "strings"
+ "sync"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2/internal"
+)
+
+// NoContext is the default context you should supply if not using
+// your own context.Context (see https://golang.org/x/net/context).
+var NoContext = context.TODO()
+
+// RegisterBrokenAuthHeaderProvider registers an OAuth2 server
+// identified by the tokenURL prefix as an OAuth2 implementation
+// which doesn't support the HTTP Basic authentication
+// scheme to authenticate with the authorization server.
+// Once a server is registered, credentials (client_id and client_secret)
+// will be passed as query parameters rather than being present
+// in the Authorization header.
+// See https://code.google.com/p/goauth2/issues/detail?id=31 for background.
+func RegisterBrokenAuthHeaderProvider(tokenURL string) {
+ internal.RegisterBrokenAuthHeaderProvider(tokenURL)
+}
+
+// Config describes a typical 3-legged OAuth2 flow, with both the
+// client application information and the server's endpoint URLs.
+// For the client credentials 2-legged OAuth2 flow, see the clientcredentials
+// package (https://golang.org/x/oauth2/clientcredentials).
+type Config struct {
+ // ClientID is the application's ID.
+ ClientID string
+
+ // ClientSecret is the application's secret.
+ ClientSecret string
+
+ // Endpoint contains the resource server's token endpoint
+ // URLs. These are constants specific to each server and are
+ // often available via site-specific packages, such as
+ // google.Endpoint or github.Endpoint.
+ Endpoint Endpoint
+
+ // RedirectURL is the URL to redirect users going through
+ // the OAuth flow, after the resource owner's URLs.
+ RedirectURL string
+
+ // Scope specifies optional requested permissions.
+ Scopes []string
+}
+
+// A TokenSource is anything that can return a token.
+type TokenSource interface {
+ // Token returns a token or an error.
+ // Token must be safe for concurrent use by multiple goroutines.
+ // The returned Token must not be modified.
+ Token() (*Token, error)
+}
+
+// Endpoint contains the OAuth 2.0 provider's authorization and token
+// endpoint URLs.
+type Endpoint struct {
+ AuthURL string
+ TokenURL string
+}
+
+var (
+ // AccessTypeOnline and AccessTypeOffline are options passed
+ // to the Options.AuthCodeURL method. They modify the
+ // "access_type" field that gets sent in the URL returned by
+ // AuthCodeURL.
+ //
+ // Online is the default if neither is specified. If your
+ // application needs to refresh access tokens when the user
+ // is not present at the browser, then use offline. This will
+ // result in your application obtaining a refresh token the
+ // first time your application exchanges an authorization
+ // code for a user.
+ AccessTypeOnline AuthCodeOption = SetAuthURLParam("access_type", "online")
+ AccessTypeOffline AuthCodeOption = SetAuthURLParam("access_type", "offline")
+
+ // ApprovalForce forces the users to view the consent dialog
+ // and confirm the permissions request at the URL returned
+ // from AuthCodeURL, even if they've already done so.
+ ApprovalForce AuthCodeOption = SetAuthURLParam("approval_prompt", "force")
+)
+
+// An AuthCodeOption is passed to Config.AuthCodeURL.
+type AuthCodeOption interface {
+ setValue(url.Values)
+}
+
+type setParam struct{ k, v string }
+
+func (p setParam) setValue(m url.Values) { m.Set(p.k, p.v) }
+
+// SetAuthURLParam builds an AuthCodeOption which passes key/value parameters
+// to a provider's authorization endpoint.
+func SetAuthURLParam(key, value string) AuthCodeOption {
+ return setParam{key, value}
+}
+
+// AuthCodeURL returns a URL to OAuth 2.0 provider's consent page
+// that asks for permissions for the required scopes explicitly.
+//
+// State is a token to protect the user from CSRF attacks. You must
+// always provide a non-zero string and validate that it matches the
+// the state query parameter on your redirect callback.
+// See http://tools.ietf.org/html/rfc6749#section-10.12 for more info.
+//
+// Opts may include AccessTypeOnline or AccessTypeOffline, as well
+// as ApprovalForce.
+func (c *Config) AuthCodeURL(state string, opts ...AuthCodeOption) string {
+ var buf bytes.Buffer
+ buf.WriteString(c.Endpoint.AuthURL)
+ v := url.Values{
+ "response_type": {"code"},
+ "client_id": {c.ClientID},
+ "redirect_uri": internal.CondVal(c.RedirectURL),
+ "scope": internal.CondVal(strings.Join(c.Scopes, " ")),
+ "state": internal.CondVal(state),
+ }
+ for _, opt := range opts {
+ opt.setValue(v)
+ }
+ if strings.Contains(c.Endpoint.AuthURL, "?") {
+ buf.WriteByte('&')
+ } else {
+ buf.WriteByte('?')
+ }
+ buf.WriteString(v.Encode())
+ return buf.String()
+}
+
+// PasswordCredentialsToken converts a resource owner username and password
+// pair into a token.
+//
+// Per the RFC, this grant type should only be used "when there is a high
+// degree of trust between the resource owner and the client (e.g., the client
+// is part of the device operating system or a highly privileged application),
+// and when other authorization grant types are not available."
+// See https://tools.ietf.org/html/rfc6749#section-4.3 for more info.
+//
+// The HTTP client to use is derived from the context.
+// If nil, http.DefaultClient is used.
+func (c *Config) PasswordCredentialsToken(ctx context.Context, username, password string) (*Token, error) {
+ return retrieveToken(ctx, c, url.Values{
+ "grant_type": {"password"},
+ "username": {username},
+ "password": {password},
+ "scope": internal.CondVal(strings.Join(c.Scopes, " ")),
+ })
+}
+
+// Exchange converts an authorization code into a token.
+//
+// It is used after a resource provider redirects the user back
+// to the Redirect URI (the URL obtained from AuthCodeURL).
+//
+// The HTTP client to use is derived from the context.
+// If a client is not provided via the context, http.DefaultClient is used.
+//
+// The code will be in the *http.Request.FormValue("code"). Before
+// calling Exchange, be sure to validate FormValue("state").
+func (c *Config) Exchange(ctx context.Context, code string) (*Token, error) {
+ return retrieveToken(ctx, c, url.Values{
+ "grant_type": {"authorization_code"},
+ "code": {code},
+ "redirect_uri": internal.CondVal(c.RedirectURL),
+ "scope": internal.CondVal(strings.Join(c.Scopes, " ")),
+ })
+}
+
+// Client returns an HTTP client using the provided token.
+// The token will auto-refresh as necessary. The underlying
+// HTTP transport will be obtained using the provided context.
+// The returned client and its Transport should not be modified.
+func (c *Config) Client(ctx context.Context, t *Token) *http.Client {
+ return NewClient(ctx, c.TokenSource(ctx, t))
+}
+
+// TokenSource returns a TokenSource that returns t until t expires,
+// automatically refreshing it as necessary using the provided context.
+//
+// Most users will use Config.Client instead.
+func (c *Config) TokenSource(ctx context.Context, t *Token) TokenSource {
+ tkr := &tokenRefresher{
+ ctx: ctx,
+ conf: c,
+ }
+ if t != nil {
+ tkr.refreshToken = t.RefreshToken
+ }
+ return &reuseTokenSource{
+ t: t,
+ new: tkr,
+ }
+}
+
+// tokenRefresher is a TokenSource that makes "grant_type"=="refresh_token"
+// HTTP requests to renew a token using a RefreshToken.
+type tokenRefresher struct {
+ ctx context.Context // used to get HTTP requests
+ conf *Config
+ refreshToken string
+}
+
+// WARNING: Token is not safe for concurrent access, as it
+// updates the tokenRefresher's refreshToken field.
+// Within this package, it is used by reuseTokenSource which
+// synchronizes calls to this method with its own mutex.
+func (tf *tokenRefresher) Token() (*Token, error) {
+ if tf.refreshToken == "" {
+ return nil, errors.New("oauth2: token expired and refresh token is not set")
+ }
+
+ tk, err := retrieveToken(tf.ctx, tf.conf, url.Values{
+ "grant_type": {"refresh_token"},
+ "refresh_token": {tf.refreshToken},
+ })
+
+ if err != nil {
+ return nil, err
+ }
+ if tf.refreshToken != tk.RefreshToken {
+ tf.refreshToken = tk.RefreshToken
+ }
+ return tk, err
+}
+
+// reuseTokenSource is a TokenSource that holds a single token in memory
+// and validates its expiry before each call to retrieve it with
+// Token. If it's expired, it will be auto-refreshed using the
+// new TokenSource.
+type reuseTokenSource struct {
+ new TokenSource // called when t is expired.
+
+ mu sync.Mutex // guards t
+ t *Token
+}
+
+// Token returns the current token if it's still valid, else will
+// refresh the current token (using r.Context for HTTP client
+// information) and return the new one.
+func (s *reuseTokenSource) Token() (*Token, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ if s.t.Valid() {
+ return s.t, nil
+ }
+ t, err := s.new.Token()
+ if err != nil {
+ return nil, err
+ }
+ s.t = t
+ return t, nil
+}
+
+// StaticTokenSource returns a TokenSource that always returns the same token.
+// Because the provided token t is never refreshed, StaticTokenSource is only
+// useful for tokens that never expire.
+func StaticTokenSource(t *Token) TokenSource {
+ return staticTokenSource{t}
+}
+
+// staticTokenSource is a TokenSource that always returns the same Token.
+type staticTokenSource struct {
+ t *Token
+}
+
+func (s staticTokenSource) Token() (*Token, error) {
+ return s.t, nil
+}
+
+// HTTPClient is the context key to use with golang.org/x/net/context's
+// WithValue function to associate an *http.Client value with a context.
+var HTTPClient internal.ContextKey
+
+// NewClient creates an *http.Client from a Context and TokenSource.
+// The returned client is not valid beyond the lifetime of the context.
+//
+// As a special case, if src is nil, a non-OAuth2 client is returned
+// using the provided context. This exists to support related OAuth2
+// packages.
+func NewClient(ctx context.Context, src TokenSource) *http.Client {
+ if src == nil {
+ c, err := internal.ContextClient(ctx)
+ if err != nil {
+ return &http.Client{Transport: internal.ErrorTransport{Err: err}}
+ }
+ return c
+ }
+ return &http.Client{
+ Transport: &Transport{
+ Base: internal.ContextTransport(ctx),
+ Source: ReuseTokenSource(nil, src),
+ },
+ }
+}
+
+// ReuseTokenSource returns a TokenSource which repeatedly returns the
+// same token as long as it's valid, starting with t.
+// When its cached token is invalid, a new token is obtained from src.
+//
+// ReuseTokenSource is typically used to reuse tokens from a cache
+// (such as a file on disk) between runs of a program, rather than
+// obtaining new tokens unnecessarily.
+//
+// The initial token t may be nil, in which case the TokenSource is
+// wrapped in a caching version if it isn't one already. This also
+// means it's always safe to wrap ReuseTokenSource around any other
+// TokenSource without adverse effects.
+func ReuseTokenSource(t *Token, src TokenSource) TokenSource {
+ // Don't wrap a reuseTokenSource in itself. That would work,
+ // but cause an unnecessary number of mutex operations.
+ // Just build the equivalent one.
+ if rt, ok := src.(*reuseTokenSource); ok {
+ if t == nil {
+ // Just use it directly.
+ return rt
+ }
+ src = rt.new
+ }
+ return &reuseTokenSource{
+ t: t,
+ new: src,
+ }
+}
diff --git a/vendor/golang.org/x/oauth2/token.go b/vendor/golang.org/x/oauth2/token.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a3167f15b04d4305bcfa8d9aba3d67039df2daf
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/token.go
@@ -0,0 +1,158 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package oauth2
+
+import (
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2/internal"
+)
+
+// expiryDelta determines how earlier a token should be considered
+// expired than its actual expiration time. It is used to avoid late
+// expirations due to client-server time mismatches.
+const expiryDelta = 10 * time.Second
+
+// Token represents the crendentials used to authorize
+// the requests to access protected resources on the OAuth 2.0
+// provider's backend.
+//
+// Most users of this package should not access fields of Token
+// directly. They're exported mostly for use by related packages
+// implementing derivative OAuth2 flows.
+type Token struct {
+ // AccessToken is the token that authorizes and authenticates
+ // the requests.
+ AccessToken string `json:"access_token"`
+
+ // TokenType is the type of token.
+ // The Type method returns either this or "Bearer", the default.
+ TokenType string `json:"token_type,omitempty"`
+
+ // RefreshToken is a token that's used by the application
+ // (as opposed to the user) to refresh the access token
+ // if it expires.
+ RefreshToken string `json:"refresh_token,omitempty"`
+
+ // Expiry is the optional expiration time of the access token.
+ //
+ // If zero, TokenSource implementations will reuse the same
+ // token forever and RefreshToken or equivalent
+ // mechanisms for that TokenSource will not be used.
+ Expiry time.Time `json:"expiry,omitempty"`
+
+ // raw optionally contains extra metadata from the server
+ // when updating a token.
+ raw interface{}
+}
+
+// Type returns t.TokenType if non-empty, else "Bearer".
+func (t *Token) Type() string {
+ if strings.EqualFold(t.TokenType, "bearer") {
+ return "Bearer"
+ }
+ if strings.EqualFold(t.TokenType, "mac") {
+ return "MAC"
+ }
+ if strings.EqualFold(t.TokenType, "basic") {
+ return "Basic"
+ }
+ if t.TokenType != "" {
+ return t.TokenType
+ }
+ return "Bearer"
+}
+
+// SetAuthHeader sets the Authorization header to r using the access
+// token in t.
+//
+// This method is unnecessary when using Transport or an HTTP Client
+// returned by this package.
+func (t *Token) SetAuthHeader(r *http.Request) {
+ r.Header.Set("Authorization", t.Type()+" "+t.AccessToken)
+}
+
+// WithExtra returns a new Token that's a clone of t, but using the
+// provided raw extra map. This is only intended for use by packages
+// implementing derivative OAuth2 flows.
+func (t *Token) WithExtra(extra interface{}) *Token {
+ t2 := new(Token)
+ *t2 = *t
+ t2.raw = extra
+ return t2
+}
+
+// Extra returns an extra field.
+// Extra fields are key-value pairs returned by the server as a
+// part of the token retrieval response.
+func (t *Token) Extra(key string) interface{} {
+ if raw, ok := t.raw.(map[string]interface{}); ok {
+ return raw[key]
+ }
+
+ vals, ok := t.raw.(url.Values)
+ if !ok {
+ return nil
+ }
+
+ v := vals.Get(key)
+ switch s := strings.TrimSpace(v); strings.Count(s, ".") {
+ case 0: // Contains no "."; try to parse as int
+ if i, err := strconv.ParseInt(s, 10, 64); err == nil {
+ return i
+ }
+ case 1: // Contains a single "."; try to parse as float
+ if f, err := strconv.ParseFloat(s, 64); err == nil {
+ return f
+ }
+ }
+
+ return v
+}
+
+// expired reports whether the token is expired.
+// t must be non-nil.
+func (t *Token) expired() bool {
+ if t.Expiry.IsZero() {
+ return false
+ }
+ return t.Expiry.Add(-expiryDelta).Before(time.Now())
+}
+
+// Valid reports whether t is non-nil, has an AccessToken, and is not expired.
+func (t *Token) Valid() bool {
+ return t != nil && t.AccessToken != "" && !t.expired()
+}
+
+// tokenFromInternal maps an *internal.Token struct into
+// a *Token struct.
+func tokenFromInternal(t *internal.Token) *Token {
+ if t == nil {
+ return nil
+ }
+ return &Token{
+ AccessToken: t.AccessToken,
+ TokenType: t.TokenType,
+ RefreshToken: t.RefreshToken,
+ Expiry: t.Expiry,
+ raw: t.Raw,
+ }
+}
+
+// retrieveToken takes a *Config and uses that to retrieve an *internal.Token.
+// This token is then mapped from *internal.Token into an *oauth2.Token which is returned along
+// with an error..
+func retrieveToken(ctx context.Context, c *Config, v url.Values) (*Token, error) {
+ tk, err := internal.RetrieveToken(ctx, c.ClientID, c.ClientSecret, c.Endpoint.TokenURL, v)
+ if err != nil {
+ return nil, err
+ }
+ return tokenFromInternal(tk), nil
+}
diff --git a/vendor/golang.org/x/oauth2/transport.go b/vendor/golang.org/x/oauth2/transport.go
new file mode 100644
index 0000000000000000000000000000000000000000..92ac7e2531f452bd146ae1dc6a2ed0d90040b8d1
--- /dev/null
+++ b/vendor/golang.org/x/oauth2/transport.go
@@ -0,0 +1,132 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package oauth2
+
+import (
+ "errors"
+ "io"
+ "net/http"
+ "sync"
+)
+
+// Transport is an http.RoundTripper that makes OAuth 2.0 HTTP requests,
+// wrapping a base RoundTripper and adding an Authorization header
+// with a token from the supplied Sources.
+//
+// Transport is a low-level mechanism. Most code will use the
+// higher-level Config.Client method instead.
+type Transport struct {
+ // Source supplies the token to add to outgoing requests'
+ // Authorization headers.
+ Source TokenSource
+
+ // Base is the base RoundTripper used to make HTTP requests.
+ // If nil, http.DefaultTransport is used.
+ Base http.RoundTripper
+
+ mu sync.Mutex // guards modReq
+ modReq map[*http.Request]*http.Request // original -> modified
+}
+
+// RoundTrip authorizes and authenticates the request with an
+// access token. If no token exists or token is expired,
+// tries to refresh/fetch a new token.
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+ if t.Source == nil {
+ return nil, errors.New("oauth2: Transport's Source is nil")
+ }
+ token, err := t.Source.Token()
+ if err != nil {
+ return nil, err
+ }
+
+ req2 := cloneRequest(req) // per RoundTripper contract
+ token.SetAuthHeader(req2)
+ t.setModReq(req, req2)
+ res, err := t.base().RoundTrip(req2)
+ if err != nil {
+ t.setModReq(req, nil)
+ return nil, err
+ }
+ res.Body = &onEOFReader{
+ rc: res.Body,
+ fn: func() { t.setModReq(req, nil) },
+ }
+ return res, nil
+}
+
+// CancelRequest cancels an in-flight request by closing its connection.
+func (t *Transport) CancelRequest(req *http.Request) {
+ type canceler interface {
+ CancelRequest(*http.Request)
+ }
+ if cr, ok := t.base().(canceler); ok {
+ t.mu.Lock()
+ modReq := t.modReq[req]
+ delete(t.modReq, req)
+ t.mu.Unlock()
+ cr.CancelRequest(modReq)
+ }
+}
+
+func (t *Transport) base() http.RoundTripper {
+ if t.Base != nil {
+ return t.Base
+ }
+ return http.DefaultTransport
+}
+
+func (t *Transport) setModReq(orig, mod *http.Request) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ if t.modReq == nil {
+ t.modReq = make(map[*http.Request]*http.Request)
+ }
+ if mod == nil {
+ delete(t.modReq, orig)
+ } else {
+ t.modReq[orig] = mod
+ }
+}
+
+// cloneRequest returns a clone of the provided *http.Request.
+// The clone is a shallow copy of the struct and its Header map.
+func cloneRequest(r *http.Request) *http.Request {
+ // shallow copy of the struct
+ r2 := new(http.Request)
+ *r2 = *r
+ // deep copy of the Header
+ r2.Header = make(http.Header, len(r.Header))
+ for k, s := range r.Header {
+ r2.Header[k] = append([]string(nil), s...)
+ }
+ return r2
+}
+
+type onEOFReader struct {
+ rc io.ReadCloser
+ fn func()
+}
+
+func (r *onEOFReader) Read(p []byte) (n int, err error) {
+ n, err = r.rc.Read(p)
+ if err == io.EOF {
+ r.runFunc()
+ }
+ return
+}
+
+func (r *onEOFReader) Close() error {
+ err := r.rc.Close()
+ r.runFunc()
+ return err
+}
+
+func (r *onEOFReader) runFunc() {
+ if fn := r.fn; fn != nil {
+ fn()
+ r.fn = nil
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/LICENSE b/vendor/google.golang.org/cloud/LICENSE
similarity index 99%
rename from Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/LICENSE
rename to vendor/google.golang.org/cloud/LICENSE
index 13f15dfce0c544754312f07cbdfe67f5c486e255..a4c5efd822fb2c4aaf6d946aded2738b9bf7d603 100644
--- a/Godeps/_workspace/src/github.com/matttproud/golang_protobuf_extensions/LICENSE
+++ b/vendor/google.golang.org/cloud/LICENSE
@@ -1,3 +1,4 @@
+
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
@@ -186,7 +187,7 @@
same "printed page" as the copyright notice for easier
identification within third-party archives.
- Copyright 2013 Matt T. Proud
+ Copyright 2014 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
diff --git a/vendor/google.golang.org/cloud/compute/metadata/metadata.go b/vendor/google.golang.org/cloud/compute/metadata/metadata.go
new file mode 100644
index 0000000000000000000000000000000000000000..9977ae743521753244c7c5e97247f968afd5e17f
--- /dev/null
+++ b/vendor/google.golang.org/cloud/compute/metadata/metadata.go
@@ -0,0 +1,438 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 metadata provides access to Google Compute Engine (GCE)
+// metadata and API service accounts.
+//
+// This package is a wrapper around the GCE metadata service,
+// as documented at https://developers.google.com/compute/docs/metadata.
+package metadata
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/url"
+ "os"
+ "runtime"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/context"
+ "golang.org/x/net/context/ctxhttp"
+
+ "google.golang.org/cloud/internal"
+)
+
+const (
+ // metadataIP is the documented metadata server IP address.
+ metadataIP = "169.254.169.254"
+
+ // metadataHostEnv is the environment variable specifying the
+ // GCE metadata hostname. If empty, the default value of
+ // metadataIP ("169.254.169.254") is used instead.
+ // This is variable name is not defined by any spec, as far as
+ // I know; it was made up for the Go package.
+ metadataHostEnv = "GCE_METADATA_HOST"
+)
+
+type cachedValue struct {
+ k string
+ trim bool
+ mu sync.Mutex
+ v string
+}
+
+var (
+ projID = &cachedValue{k: "project/project-id", trim: true}
+ projNum = &cachedValue{k: "project/numeric-project-id", trim: true}
+ instID = &cachedValue{k: "instance/id", trim: true}
+)
+
+var (
+ metaClient = &http.Client{
+ Transport: &internal.Transport{
+ Base: &http.Transport{
+ Dial: (&net.Dialer{
+ Timeout: 2 * time.Second,
+ KeepAlive: 30 * time.Second,
+ }).Dial,
+ ResponseHeaderTimeout: 2 * time.Second,
+ },
+ },
+ }
+ subscribeClient = &http.Client{
+ Transport: &internal.Transport{
+ Base: &http.Transport{
+ Dial: (&net.Dialer{
+ Timeout: 2 * time.Second,
+ KeepAlive: 30 * time.Second,
+ }).Dial,
+ },
+ },
+ }
+)
+
+// NotDefinedError is returned when requested metadata is not defined.
+//
+// The underlying string is the suffix after "/computeMetadata/v1/".
+//
+// This error is not returned if the value is defined to be the empty
+// string.
+type NotDefinedError string
+
+func (suffix NotDefinedError) Error() string {
+ return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))
+}
+
+// Get returns a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+//
+// If the GCE_METADATA_HOST environment variable is not defined, a default of
+// 169.254.169.254 will be used instead.
+//
+// If the requested metadata is not defined, the returned error will
+// be of type NotDefinedError.
+func Get(suffix string) (string, error) {
+ val, _, err := getETag(metaClient, suffix)
+ return val, err
+}
+
+// getETag returns a value from the metadata service as well as the associated
+// ETag using the provided client. This func is otherwise equivalent to Get.
+func getETag(client *http.Client, suffix string) (value, etag string, err error) {
+ // Using a fixed IP makes it very difficult to spoof the metadata service in
+ // a container, which is an important use-case for local testing of cloud
+ // deployments. To enable spoofing of the metadata service, the environment
+ // variable GCE_METADATA_HOST is first inspected to decide where metadata
+ // requests shall go.
+ host := os.Getenv(metadataHostEnv)
+ if host == "" {
+ // Using 169.254.169.254 instead of "metadata" here because Go
+ // binaries built with the "netgo" tag and without cgo won't
+ // know the search suffix for "metadata" is
+ // ".google.internal", and this IP address is documented as
+ // being stable anyway.
+ host = metadataIP
+ }
+ url := "http://" + host + "/computeMetadata/v1/" + suffix
+ req, _ := http.NewRequest("GET", url, nil)
+ req.Header.Set("Metadata-Flavor", "Google")
+ res, err := client.Do(req)
+ if err != nil {
+ return "", "", err
+ }
+ defer res.Body.Close()
+ if res.StatusCode == http.StatusNotFound {
+ return "", "", NotDefinedError(suffix)
+ }
+ if res.StatusCode != 200 {
+ return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)
+ }
+ all, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ return "", "", err
+ }
+ return string(all), res.Header.Get("Etag"), nil
+}
+
+func getTrimmed(suffix string) (s string, err error) {
+ s, err = Get(suffix)
+ s = strings.TrimSpace(s)
+ return
+}
+
+func (c *cachedValue) get() (v string, err error) {
+ defer c.mu.Unlock()
+ c.mu.Lock()
+ if c.v != "" {
+ return c.v, nil
+ }
+ if c.trim {
+ v, err = getTrimmed(c.k)
+ } else {
+ v, err = Get(c.k)
+ }
+ if err == nil {
+ c.v = v
+ }
+ return
+}
+
+var (
+ onGCEOnce sync.Once
+ onGCE bool
+)
+
+// OnGCE reports whether this process is running on Google Compute Engine.
+func OnGCE() bool {
+ onGCEOnce.Do(initOnGCE)
+ return onGCE
+}
+
+func initOnGCE() {
+ onGCE = testOnGCE()
+}
+
+func testOnGCE() bool {
+ // The user explicitly said they're on GCE, so trust them.
+ if os.Getenv(metadataHostEnv) != "" {
+ return true
+ }
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ resc := make(chan bool, 2)
+
+ // Try two strategies in parallel.
+ // See https://github.com/GoogleCloudPlatform/gcloud-golang/issues/194
+ go func() {
+ res, err := ctxhttp.Get(ctx, metaClient, "http://"+metadataIP)
+ if err != nil {
+ resc <- false
+ return
+ }
+ defer res.Body.Close()
+ resc <- res.Header.Get("Metadata-Flavor") == "Google"
+ }()
+
+ go func() {
+ addrs, err := net.LookupHost("metadata.google.internal")
+ if err != nil || len(addrs) == 0 {
+ resc <- false
+ return
+ }
+ resc <- strsContains(addrs, metadataIP)
+ }()
+
+ tryHarder := systemInfoSuggestsGCE()
+ if tryHarder {
+ res := <-resc
+ if res {
+ // The first strategy succeeded, so let's use it.
+ return true
+ }
+ // Wait for either the DNS or metadata server probe to
+ // contradict the other one and say we are running on
+ // GCE. Give it a lot of time to do so, since the system
+ // info already suggests we're running on a GCE BIOS.
+ timer := time.NewTimer(5 * time.Second)
+ defer timer.Stop()
+ select {
+ case res = <-resc:
+ return res
+ case <-timer.C:
+ // Too slow. Who knows what this system is.
+ return false
+ }
+ }
+
+ // There's no hint from the system info that we're running on
+ // GCE, so use the first probe's result as truth, whether it's
+ // true or false. The goal here is to optimize for speed for
+ // users who are NOT running on GCE. We can't assume that
+ // either a DNS lookup or an HTTP request to a blackholed IP
+ // address is fast. Worst case this should return when the
+ // metaClient's Transport.ResponseHeaderTimeout or
+ // Transport.Dial.Timeout fires (in two seconds).
+ return <-resc
+}
+
+// systemInfoSuggestsGCE reports whether the local system (without
+// doing network requests) suggests that we're running on GCE. If this
+// returns true, testOnGCE tries a bit harder to reach its metadata
+// server.
+func systemInfoSuggestsGCE() bool {
+ if runtime.GOOS != "linux" {
+ // We don't have any non-Linux clues available, at least yet.
+ return false
+ }
+ slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name")
+ name := strings.TrimSpace(string(slurp))
+ return name == "Google" || name == "Google Compute Engine"
+}
+
+// Subscribe subscribes to a value from the metadata service.
+// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
+// The suffix may contain query parameters.
+//
+// Subscribe calls fn with the latest metadata value indicated by the provided
+// suffix. If the metadata value is deleted, fn is called with the empty string
+// and ok false. Subscribe blocks until fn returns a non-nil error or the value
+// is deleted. Subscribe returns the error value returned from the last call to
+// fn, which may be nil when ok == false.
+func Subscribe(suffix string, fn func(v string, ok bool) error) error {
+ const failedSubscribeSleep = time.Second * 5
+
+ // First check to see if the metadata value exists at all.
+ val, lastETag, err := getETag(subscribeClient, suffix)
+ if err != nil {
+ return err
+ }
+
+ if err := fn(val, true); err != nil {
+ return err
+ }
+
+ ok := true
+ if strings.ContainsRune(suffix, '?') {
+ suffix += "&wait_for_change=true&last_etag="
+ } else {
+ suffix += "?wait_for_change=true&last_etag="
+ }
+ for {
+ val, etag, err := getETag(subscribeClient, suffix+url.QueryEscape(lastETag))
+ if err != nil {
+ if _, deleted := err.(NotDefinedError); !deleted {
+ time.Sleep(failedSubscribeSleep)
+ continue // Retry on other errors.
+ }
+ ok = false
+ }
+ lastETag = etag
+
+ if err := fn(val, ok); err != nil || !ok {
+ return err
+ }
+ }
+}
+
+// ProjectID returns the current instance's project ID string.
+func ProjectID() (string, error) { return projID.get() }
+
+// NumericProjectID returns the current instance's numeric project ID.
+func NumericProjectID() (string, error) { return projNum.get() }
+
+// InternalIP returns the instance's primary internal IP address.
+func InternalIP() (string, error) {
+ return getTrimmed("instance/network-interfaces/0/ip")
+}
+
+// ExternalIP returns the instance's primary external (public) IP address.
+func ExternalIP() (string, error) {
+ return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")
+}
+
+// Hostname returns the instance's hostname. This will be of the form
+// "<instanceID>.c.<projID>.internal".
+func Hostname() (string, error) {
+ return getTrimmed("instance/hostname")
+}
+
+// InstanceTags returns the list of user-defined instance tags,
+// assigned when initially creating a GCE instance.
+func InstanceTags() ([]string, error) {
+ var s []string
+ j, err := Get("instance/tags")
+ if err != nil {
+ return nil, err
+ }
+ if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {
+ return nil, err
+ }
+ return s, nil
+}
+
+// InstanceID returns the current VM's numeric instance ID.
+func InstanceID() (string, error) {
+ return instID.get()
+}
+
+// InstanceName returns the current VM's instance ID string.
+func InstanceName() (string, error) {
+ host, err := Hostname()
+ if err != nil {
+ return "", err
+ }
+ return strings.Split(host, ".")[0], nil
+}
+
+// Zone returns the current VM's zone, such as "us-central1-b".
+func Zone() (string, error) {
+ zone, err := getTrimmed("instance/zone")
+ // zone is of the form "projects/<projNum>/zones/<zoneName>".
+ if err != nil {
+ return "", err
+ }
+ return zone[strings.LastIndex(zone, "/")+1:], nil
+}
+
+// InstanceAttributes returns the list of user-defined attributes,
+// assigned when initially creating a GCE VM instance. The value of an
+// attribute can be obtained with InstanceAttributeValue.
+func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") }
+
+// ProjectAttributes returns the list of user-defined attributes
+// applying to the project as a whole, not just this VM. The value of
+// an attribute can be obtained with ProjectAttributeValue.
+func ProjectAttributes() ([]string, error) { return lines("project/attributes/") }
+
+func lines(suffix string) ([]string, error) {
+ j, err := Get(suffix)
+ if err != nil {
+ return nil, err
+ }
+ s := strings.Split(strings.TrimSpace(j), "\n")
+ for i := range s {
+ s[i] = strings.TrimSpace(s[i])
+ }
+ return s, nil
+}
+
+// InstanceAttributeValue returns the value of the provided VM
+// instance attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// InstanceAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func InstanceAttributeValue(attr string) (string, error) {
+ return Get("instance/attributes/" + attr)
+}
+
+// ProjectAttributeValue returns the value of the provided
+// project attribute.
+//
+// If the requested attribute is not defined, the returned error will
+// be of type NotDefinedError.
+//
+// ProjectAttributeValue may return ("", nil) if the attribute was
+// defined to be the empty string.
+func ProjectAttributeValue(attr string) (string, error) {
+ return Get("project/attributes/" + attr)
+}
+
+// Scopes returns the service account scopes for the given account.
+// The account may be empty or the string "default" to use the instance's
+// main account.
+func Scopes(serviceAccount string) ([]string, error) {
+ if serviceAccount == "" {
+ serviceAccount = "default"
+ }
+ return lines("instance/service-accounts/" + serviceAccount + "/scopes")
+}
+
+func strsContains(ss []string, s string) bool {
+ for _, v := range ss {
+ if v == s {
+ return true
+ }
+ }
+ return false
+}
diff --git a/vendor/google.golang.org/cloud/internal/cloud.go b/vendor/google.golang.org/cloud/internal/cloud.go
new file mode 100644
index 0000000000000000000000000000000000000000..59428803dd9cb127eec5906331ff74df9cd823f8
--- /dev/null
+++ b/vendor/google.golang.org/cloud/internal/cloud.go
@@ -0,0 +1,128 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 internal provides support for the cloud packages.
+//
+// Users should not import this package directly.
+package internal
+
+import (
+ "fmt"
+ "net/http"
+ "sync"
+
+ "golang.org/x/net/context"
+)
+
+type contextKey struct{}
+
+func WithContext(parent context.Context, projID string, c *http.Client) context.Context {
+ if c == nil {
+ panic("nil *http.Client passed to WithContext")
+ }
+ if projID == "" {
+ panic("empty project ID passed to WithContext")
+ }
+ return context.WithValue(parent, contextKey{}, &cloudContext{
+ ProjectID: projID,
+ HTTPClient: c,
+ })
+}
+
+const userAgent = "gcloud-golang/0.1"
+
+type cloudContext struct {
+ ProjectID string
+ HTTPClient *http.Client
+
+ mu sync.Mutex // guards svc
+ svc map[string]interface{} // e.g. "storage" => *rawStorage.Service
+}
+
+// Service returns the result of the fill function if it's never been
+// called before for the given name (which is assumed to be an API
+// service name, like "datastore"). If it has already been cached, the fill
+// func is not run.
+// It's safe for concurrent use by multiple goroutines.
+func Service(ctx context.Context, name string, fill func(*http.Client) interface{}) interface{} {
+ return cc(ctx).service(name, fill)
+}
+
+func (c *cloudContext) service(name string, fill func(*http.Client) interface{}) interface{} {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+
+ if c.svc == nil {
+ c.svc = make(map[string]interface{})
+ } else if v, ok := c.svc[name]; ok {
+ return v
+ }
+ v := fill(c.HTTPClient)
+ c.svc[name] = v
+ return v
+}
+
+// Transport is an http.RoundTripper that appends
+// Google Cloud client's user-agent to the original
+// request's user-agent header.
+type Transport struct {
+ // Base is the actual http.RoundTripper
+ // requests will use. It must not be nil.
+ Base http.RoundTripper
+}
+
+// RoundTrip appends a user-agent to the existing user-agent
+// header and delegates the request to the base http.RoundTripper.
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+ req = cloneRequest(req)
+ ua := req.Header.Get("User-Agent")
+ if ua == "" {
+ ua = userAgent
+ } else {
+ ua = fmt.Sprintf("%s %s", ua, userAgent)
+ }
+ req.Header.Set("User-Agent", ua)
+ return t.Base.RoundTrip(req)
+}
+
+// cloneRequest returns a clone of the provided *http.Request.
+// The clone is a shallow copy of the struct and its Header map.
+func cloneRequest(r *http.Request) *http.Request {
+ // shallow copy of the struct
+ r2 := new(http.Request)
+ *r2 = *r
+ // deep copy of the Header
+ r2.Header = make(http.Header)
+ for k, s := range r.Header {
+ r2.Header[k] = s
+ }
+ return r2
+}
+
+func ProjID(ctx context.Context) string {
+ return cc(ctx).ProjectID
+}
+
+func HTTPClient(ctx context.Context) *http.Client {
+ return cc(ctx).HTTPClient
+}
+
+// cc returns the internal *cloudContext (cc) state for a context.Context.
+// It panics if the user did it wrong.
+func cc(ctx context.Context) *cloudContext {
+ if c, ok := ctx.Value(contextKey{}).(*cloudContext); ok {
+ return c
+ }
+ panic("invalid context.Context type; it should be created with cloud.NewContext")
+}
diff --git a/vendor/gopkg.in/inf.v0/LICENSE b/vendor/gopkg.in/inf.v0/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..87a5cede33929e3d2aedebbe7a2497b16c14f23b
--- /dev/null
+++ b/vendor/gopkg.in/inf.v0/LICENSE
@@ -0,0 +1,28 @@
+Copyright (c) 2012 Péter Surányi. Portions Copyright (c) 2009 The Go
+Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/dec.go b/vendor/gopkg.in/inf.v0/dec.go
similarity index 100%
rename from Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/dec.go
rename to vendor/gopkg.in/inf.v0/dec.go
diff --git a/Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/rounder.go b/vendor/gopkg.in/inf.v0/rounder.go
similarity index 100%
rename from Godeps/_workspace/src/speter.net/go/exp/math/dec/inf/rounder.go
rename to vendor/gopkg.in/inf.v0/rounder.go
diff --git a/vendor/gopkg.in/yaml.v2/.travis.yml b/vendor/gopkg.in/yaml.v2/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..004172a2e37f4efe27ad56e6f22ef9ed0cdcb78f
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+go:
+ - 1.4
+ - 1.5
+ - 1.6
+ - tip
+
+go_import_path: gopkg.in/yaml.v2
diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..866d74a7ad79165312a2ce3904b4bdb53e6aedf7
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2011-2016 Canonical Ltd.
+
+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/Godeps/_workspace/src/gopkg.in/yaml.v2/LICENSE.libyaml b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/LICENSE.libyaml
rename to vendor/gopkg.in/yaml.v2/LICENSE.libyaml
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md
similarity index 95%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/README.md
rename to vendor/gopkg.in/yaml.v2/README.md
index d6c919e6073d0e2c298f9791a961703533738a68..7b8bd86701e3279d3a924ce3371acb3dcfd35b3b 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/README.md
+++ b/vendor/gopkg.in/yaml.v2/README.md
@@ -67,7 +67,10 @@ b:
type T struct {
A string
- B struct{C int; D []int ",flow"}
+ B struct {
+ RenamedC int `yaml:"c"`
+ D []int `yaml:",flow"`
+ }
}
func main() {
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/apic.go b/vendor/gopkg.in/yaml.v2/apic.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/apic.go
rename to vendor/gopkg.in/yaml.v2/apic.go
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/decode.go b/vendor/gopkg.in/yaml.v2/decode.go
similarity index 94%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/decode.go
rename to vendor/gopkg.in/yaml.v2/decode.go
index c50c62900869c758dc53dd83e049ab4d4c26ad9f..085cddc44beb962ede8bcf965cd99ab3110916cd 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/decode.go
+++ b/vendor/gopkg.in/yaml.v2/decode.go
@@ -32,9 +32,9 @@ type node struct {
// Parser, produces a node tree out of a libyaml event stream.
type parser struct {
- parser yaml_parser_t
- event yaml_event_t
- doc *node
+ parser yaml_parser_t
+ event yaml_event_t
+ doc *node
}
func newParser(b []byte) *parser {
@@ -194,10 +194,10 @@ type decoder struct {
}
var (
- mapItemType = reflect.TypeOf(MapItem{})
- durationType = reflect.TypeOf(time.Duration(0))
+ mapItemType = reflect.TypeOf(MapItem{})
+ durationType = reflect.TypeOf(time.Duration(0))
defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
- ifaceType = defaultMapType.Elem()
+ ifaceType = defaultMapType.Elem()
)
func newDecoder() *decoder {
@@ -476,35 +476,37 @@ func settableValueOf(i interface{}) reflect.Value {
}
func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
+ l := len(n.children)
+
var iface reflect.Value
switch out.Kind() {
case reflect.Slice:
- // okay
+ out.Set(reflect.MakeSlice(out.Type(), l, l))
case reflect.Interface:
// No type hints. Will have to use a generic sequence.
iface = out
- out = settableValueOf(make([]interface{}, 0))
+ out = settableValueOf(make([]interface{}, l))
default:
d.terror(n, yaml_SEQ_TAG, out)
return false
}
et := out.Type().Elem()
- l := len(n.children)
+ j := 0
for i := 0; i < l; i++ {
e := reflect.New(et).Elem()
if ok := d.unmarshal(n.children[i], e); ok {
- out.Set(reflect.Append(out, e))
+ out.Index(j).Set(e)
+ j++
}
}
+ out.Set(out.Slice(0, j))
if iface.IsValid() {
iface.Set(out)
}
return true
}
-
-
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
switch out.Kind() {
case reflect.Struct:
@@ -605,6 +607,15 @@ func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
}
name := settableValueOf("")
l := len(n.children)
+
+ var inlineMap reflect.Value
+ var elemType reflect.Type
+ if sinfo.InlineMap != -1 {
+ inlineMap = out.Field(sinfo.InlineMap)
+ inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
+ elemType = inlineMap.Type().Elem()
+ }
+
for i := 0; i < l; i += 2 {
ni := n.children[i]
if isMerge(ni) {
@@ -622,6 +633,13 @@ func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
field = out.FieldByIndex(info.Inline)
}
d.unmarshal(n.children[i+1], field)
+ } else if sinfo.InlineMap != -1 {
+ if inlineMap.IsNil() {
+ inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+ }
+ value := reflect.New(elemType).Elem()
+ d.unmarshal(n.children[i+1], value)
+ inlineMap.SetMapIndex(name, value)
}
}
return true
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/emitterc.go b/vendor/gopkg.in/yaml.v2/emitterc.go
similarity index 99%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/emitterc.go
rename to vendor/gopkg.in/yaml.v2/emitterc.go
index 9b3dc4a437036c61a8f9f2819880cfcd902acf08..2befd553ed0263a2bb85819e344e244014dfadc9 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/emitterc.go
+++ b/vendor/gopkg.in/yaml.v2/emitterc.go
@@ -1019,7 +1019,7 @@ func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
preceeded_by_whitespace = true
for i, w := 0, 0; i < len(value); i += w {
- w = width(value[0])
+ w = width(value[i])
followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
if i == 0 {
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/encode.go b/vendor/gopkg.in/yaml.v2/encode.go
similarity index 93%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/encode.go
rename to vendor/gopkg.in/yaml.v2/encode.go
index 972bc0384a979eca28023186b7b462be733154bb..84f84995517b6bced35582e4890988cab474e934 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/encode.go
+++ b/vendor/gopkg.in/yaml.v2/encode.go
@@ -2,6 +2,7 @@ package yaml
import (
"encoding"
+ "fmt"
"reflect"
"regexp"
"sort"
@@ -74,8 +75,7 @@ func (e *encoder) marshal(tag string, in reflect.Value) {
return
}
in = reflect.ValueOf(v)
- }
- if m, ok := iface.(encoding.TextMarshaler); ok {
+ } else if m, ok := iface.(encoding.TextMarshaler); ok {
text, err := m.MarshalText()
if err != nil {
fail(err)
@@ -165,6 +165,22 @@ func (e *encoder) structv(tag string, in reflect.Value) {
e.flow = info.Flow
e.marshal("", value)
}
+ if sinfo.InlineMap >= 0 {
+ m := in.Field(sinfo.InlineMap)
+ if m.Len() > 0 {
+ e.flow = false
+ keys := keyList(m.MapKeys())
+ sort.Sort(keys)
+ for _, k := range keys {
+ if _, found := sinfo.FieldsMap[k.String()]; found {
+ panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
+ }
+ e.marshal("", k)
+ e.flow = false
+ e.marshal("", m.MapIndex(k))
+ }
+ }
+ }
})
}
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/parserc.go b/vendor/gopkg.in/yaml.v2/parserc.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/parserc.go
rename to vendor/gopkg.in/yaml.v2/parserc.go
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/readerc.go b/vendor/gopkg.in/yaml.v2/readerc.go
similarity index 99%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/readerc.go
rename to vendor/gopkg.in/yaml.v2/readerc.go
index d5fb09727720a206d1fed349eb1b6882c659cac2..f450791717bf2b80b70932fbd795051c8522952b 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/readerc.go
+++ b/vendor/gopkg.in/yaml.v2/readerc.go
@@ -247,7 +247,7 @@ func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
if parser.encoding == yaml_UTF16LE_ENCODING {
low, high = 0, 1
} else {
- high, low = 1, 0
+ low, high = 1, 0
}
// The UTF-16 encoding is not as simple as one might
@@ -357,23 +357,26 @@ func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
if value <= 0x7F {
// 0000 0000-0000 007F . 0xxxxxxx
parser.buffer[buffer_len+0] = byte(value)
+ buffer_len += 1
} else if value <= 0x7FF {
// 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
+ buffer_len += 2
} else if value <= 0xFFFF {
// 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
+ buffer_len += 3
} else {
// 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
+ buffer_len += 4
}
- buffer_len += width
parser.unread++
}
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/resolve.go b/vendor/gopkg.in/yaml.v2/resolve.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/resolve.go
rename to vendor/gopkg.in/yaml.v2/resolve.go
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go b/vendor/gopkg.in/yaml.v2/scannerc.go
similarity index 98%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go
rename to vendor/gopkg.in/yaml.v2/scannerc.go
index fe93b190c2ac7d7ca23c8ccabea37709f28c1272..25808000f28f7971a7bef97530fa5eec5181abed 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go
+++ b/vendor/gopkg.in/yaml.v2/scannerc.go
@@ -961,7 +961,7 @@ func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml
}
// Pop indentation levels from the indents stack until the current level
-// becomes less or equal to the column. For each intendation level, append
+// becomes less or equal to the column. For each indentation level, append
// the BLOCK-END token.
func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool {
// In the flow context, do nothing.
@@ -969,7 +969,7 @@ func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool {
return true
}
- // Loop through the intendation levels in the stack.
+ // Loop through the indentation levels in the stack.
for parser.indent > column {
// Create a token and append it to the queue.
token := yaml_token_t{
@@ -1546,7 +1546,7 @@ func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool
// Unknown directive.
} else {
yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "found uknown directive name")
+ start_mark, "found unknown directive name")
return false
}
@@ -2085,14 +2085,14 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
return false
}
if is_digit(parser.buffer, parser.buffer_pos) {
- // Check that the intendation is greater than 0.
+ // Check that the indentation is greater than 0.
if parser.buffer[parser.buffer_pos] == '0' {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an intendation indicator equal to 0")
+ start_mark, "found an indentation indicator equal to 0")
return false
}
- // Get the intendation level and eat the indicator.
+ // Get the indentation level and eat the indicator.
increment = as_digit(parser.buffer, parser.buffer_pos)
skip(parser)
}
@@ -2102,7 +2102,7 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
if parser.buffer[parser.buffer_pos] == '0' {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an intendation indicator equal to 0")
+ start_mark, "found an indentation indicator equal to 0")
return false
}
increment = as_digit(parser.buffer, parser.buffer_pos)
@@ -2157,7 +2157,7 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
end_mark := parser.mark
- // Set the intendation level if it was specified.
+ // Set the indentation level if it was specified.
var indent int
if increment > 0 {
if parser.indent >= 0 {
@@ -2217,7 +2217,7 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
leading_break = read_line(parser, leading_break)
- // Eat the following intendation spaces and line breaks.
+ // Eat the following indentation spaces and line breaks.
if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
return false
}
@@ -2245,15 +2245,15 @@ func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, l
return true
}
-// Scan intendation spaces and line breaks for a block scalar. Determine the
-// intendation level if needed.
+// Scan indentation spaces and line breaks for a block scalar. Determine the
+// indentation level if needed.
func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
*end_mark = parser.mark
- // Eat the intendation spaces and line breaks.
+ // Eat the indentation spaces and line breaks.
max_indent := 0
for {
- // Eat the intendation spaces.
+ // Eat the indentation spaces.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
@@ -2267,10 +2267,10 @@ func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, br
max_indent = parser.mark.column
}
- // Check for a tab character messing the intendation.
+ // Check for a tab character messing the indentation.
if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found a tab character where an intendation space is expected")
+ start_mark, "found a tab character where an indentation space is expected")
}
// Have we found a non-empty line?
@@ -2655,10 +2655,10 @@ func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) b
for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
if is_blank(parser.buffer, parser.buffer_pos) {
- // Check for tab character that abuse intendation.
+ // Check for tab character that abuse indentation.
if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {
yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
- start_mark, "found a tab character that violate intendation")
+ start_mark, "found a tab character that violate indentation")
return false
}
@@ -2687,7 +2687,7 @@ func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) b
}
}
- // Check intendation level.
+ // Check indentation level.
if parser.flow_level == 0 && parser.mark.column < indent {
break
}
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/sorter.go b/vendor/gopkg.in/yaml.v2/sorter.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/sorter.go
rename to vendor/gopkg.in/yaml.v2/sorter.go
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/writerc.go b/vendor/gopkg.in/yaml.v2/writerc.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/writerc.go
rename to vendor/gopkg.in/yaml.v2/writerc.go
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/yaml.go b/vendor/gopkg.in/yaml.v2/yaml.go
similarity index 89%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/yaml.go
rename to vendor/gopkg.in/yaml.v2/yaml.go
index 5d1b86c219871bf29dc3ff3a5599b0d6bcc14c9d..36d6b883a6c0ba97ce3f7fe5d1c5c50ed345d390 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/yaml.go
+++ b/vendor/gopkg.in/yaml.v2/yaml.go
@@ -32,7 +32,6 @@ type Unmarshaler interface {
UnmarshalYAML(unmarshal func(interface{}) error) error
}
-
// The Marshaler interface may be implemented by types to customize their
// behavior when being marshaled into a YAML document. The returned value
// is marshaled in place of the original value implementing Marshaler.
@@ -90,7 +89,7 @@ func Unmarshal(in []byte, out interface{}) (err error) {
}
d.unmarshal(node, v)
}
- if d.terrors != nil {
+ if len(d.terrors) > 0 {
return &TypeError{d.terrors}
}
return nil
@@ -118,11 +117,12 @@ func Unmarshal(in []byte, out interface{}) (err error) {
// Does not apply to zero valued structs.
//
// flow Marshal using a flow style (useful for structs,
-// sequences and maps.
+// sequences and maps).
//
-// inline Inline the struct it's applied to, so its fields
-// are processed as if they were part of the outer
-// struct.
+// inline Inline the field, which must be a struct or a map,
+// causing all of its fields or keys to be processed as if
+// they were part of the outer struct. For maps, keys must
+// not conflict with the yaml keys of other struct fields.
//
// In addition, if the key is "-", the field is ignored.
//
@@ -164,7 +164,7 @@ func fail(err error) {
}
func failf(format string, args ...interface{}) {
- panic(yamlError{fmt.Errorf("yaml: " + format, args...)})
+ panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
}
// A TypeError is returned by Unmarshal when one or more fields in
@@ -222,7 +222,7 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
inlineMap := -1
for i := 0; i != n; i++ {
field := st.Field(i)
- if field.PkgPath != "" {
+ if field.PkgPath != "" && !field.Anonymous {
continue // Private field
}
@@ -256,15 +256,14 @@ func getStructInfo(st reflect.Type) (*structInfo, error) {
if inline {
switch field.Type.Kind() {
- // TODO: Implement support for inline maps.
- //case reflect.Map:
- // if inlineMap >= 0 {
- // return nil, errors.New("Multiple ,inline maps in struct " + st.String())
- // }
- // if field.Type.Key() != reflect.TypeOf("") {
- // return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
- // }
- // inlineMap = info.Num
+ case reflect.Map:
+ if inlineMap >= 0 {
+ return nil, errors.New("Multiple ,inline maps in struct " + st.String())
+ }
+ if field.Type.Key() != reflect.TypeOf("") {
+ return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
+ }
+ inlineMap = info.Num
case reflect.Struct:
sinfo, err := getStructInfo(field.Type)
if err != nil {
@@ -325,10 +324,23 @@ func isZero(v reflect.Value) bool {
return v.Len() == 0
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return v.Int() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return v.Uint() == 0
case reflect.Bool:
return !v.Bool()
+ case reflect.Struct:
+ vt := v.Type()
+ for i := v.NumField() - 1; i >= 0; i-- {
+ if vt.Field(i).PkgPath != "" {
+ continue // Private field
+ }
+ if !isZero(v.Field(i)) {
+ return false
+ }
+ }
+ return true
}
return false
}
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/yamlh.go b/vendor/gopkg.in/yaml.v2/yamlh.go
similarity index 99%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/yamlh.go
rename to vendor/gopkg.in/yaml.v2/yamlh.go
index 4b020b1b3086c48d7f085a756cd7b740b3d0852f..d60a6b6b0035bec3773f023680b38cd3dbec93d0 100644
--- a/Godeps/_workspace/src/gopkg.in/yaml.v2/yamlh.go
+++ b/vendor/gopkg.in/yaml.v2/yamlh.go
@@ -296,7 +296,7 @@ const (
// Not in original libyaml.
yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
- yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
+ yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
diff --git a/Godeps/_workspace/src/gopkg.in/yaml.v2/yamlprivateh.go b/vendor/gopkg.in/yaml.v2/yamlprivateh.go
similarity index 100%
rename from Godeps/_workspace/src/gopkg.in/yaml.v2/yamlprivateh.go
rename to vendor/gopkg.in/yaml.v2/yamlprivateh.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/LICENSE b/vendor/k8s.io/kubernetes/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/LICENSE
rename to vendor/k8s.io/kubernetes/LICENSE
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/deep_copy_generated.go b/vendor/k8s.io/kubernetes/federation/apis/federation/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..0b03ff9b3a28042ac82bdb30bb7a464cd004f7d9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/deep_copy_generated.go
@@ -0,0 +1,145 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package federation
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_federation_Cluster,
+ DeepCopy_federation_ClusterCondition,
+ DeepCopy_federation_ClusterList,
+ DeepCopy_federation_ClusterSpec,
+ DeepCopy_federation_ClusterStatus,
+ DeepCopy_federation_ServerAddressByClientCIDR,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_federation_Cluster(in Cluster, out *Cluster, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_federation_ClusterSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_federation_ClusterStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_federation_ClusterCondition(in ClusterCondition, out *ClusterCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_federation_ClusterList(in ClusterList, out *ClusterList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Cluster, len(in))
+ for i := range in {
+ if err := DeepCopy_federation_Cluster(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_federation_ClusterSpec(in ClusterSpec, out *ClusterSpec, c *conversion.Cloner) error {
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]ServerAddressByClientCIDR, len(in))
+ for i := range in {
+ if err := DeepCopy_federation_ServerAddressByClientCIDR(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ if in.SecretRef != nil {
+ in, out := in.SecretRef, &out.SecretRef
+ *out = new(api.LocalObjectReference)
+ if err := api.DeepCopy_api_LocalObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ return nil
+}
+
+func DeepCopy_federation_ClusterStatus(in ClusterStatus, out *ClusterStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]ClusterCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_federation_ClusterCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.Zones != nil {
+ in, out := in.Zones, &out.Zones
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Zones = nil
+ }
+ out.Region = in.Region
+ return nil
+}
+
+func DeepCopy_federation_ServerAddressByClientCIDR(in ServerAddressByClientCIDR, out *ServerAddressByClientCIDR, c *conversion.Cloner) error {
+ out.ClientCIDR = in.ClientCIDR
+ out.ServerAddress = in.ServerAddress
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/install/install.go b/vendor/k8s.io/kubernetes/federation/apis/federation/install/install.go
similarity index 70%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/install/install.go
rename to vendor/k8s.io/kubernetes/federation/apis/federation/install/install.go
index 58d121ba86e269228b9b6cf870a54a6b2cfc6c77..a1dc24cab56d85f0cc5905c7045c90c70bd1a747 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/install/install.go
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/install/install.go
@@ -1,5 +1,5 @@
/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,8 +14,6 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package install installs the v1 monolithic api, making it available as an
-// option to all of the API encoding/decoding machinery.
package install
import (
@@ -23,22 +21,23 @@ import (
"github.com/golang/glog"
+ "k8s.io/kubernetes/federation/apis/federation"
+ "k8s.io/kubernetes/federation/apis/federation/v1beta1"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/apimachinery"
"k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets"
)
-const importPrefix = "k8s.io/kubernetes/pkg/api"
+const importPrefix = "k8s.io/kubernetes/federation/apis/federation"
var accessor = meta.NewAccessor()
// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
+var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
func init() {
registered.RegisterVersions(availableVersions)
@@ -49,7 +48,7 @@ func init() {
}
}
if len(externalVersions) == 0 {
- glog.V(4).Infof("No version is registered for group %v", api.GroupName)
+ glog.V(4).Infof("No version is registered for group %v", federation.GroupName)
return
}
@@ -86,59 +85,36 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
return nil
}
-// userResources is a group of resources mostly used by a kubectl user
-var userResources = []string{"rc", "svc", "pods", "pvc"}
-
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
rootScoped := sets.NewString(
- "Node",
- "Namespace",
- "PersistentVolume",
- "ComponentStatus",
+ "Cluster",
)
- // these kinds should be excluded from the list of resources
- ignoredKinds := sets.NewString(
- "ListOptions",
- "DeleteOptions",
- "Status",
- "PodLogOptions",
- "PodExecOptions",
- "PodAttachOptions",
- "PodProxyOptions",
- "NodeProxyOptions",
- "ServiceProxyOptions",
- "ThirdPartyResource",
- "ThirdPartyResourceData",
- "ThirdPartyResourceList")
-
- mapper := api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
- // setup aliases for groups of resources
- mapper.AddResourceAlias("all", userResources...)
-
- return mapper
+ ignoredKinds := sets.NewString()
+
+ return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
}
-// InterfacesFor returns the default Codec and ResourceVersioner for a given version
+// interfacesFor returns the default Codec and ResourceVersioner for a given version
// string, or an error if the version is not known.
func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
switch version {
- case v1.SchemeGroupVersion:
+ case v1beta1.SchemeGroupVersion:
return &meta.VersionInterfaces{
ObjectConvertor: api.Scheme,
MetadataAccessor: accessor,
}, nil
default:
- g, _ := registered.Group(api.GroupName)
+ g, _ := registered.Group(federation.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
}
}
func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
// add the internal version to Scheme
- api.AddToScheme(api.Scheme)
+ federation.AddToScheme(api.Scheme)
// add the enabled external versions to Scheme
for _, v := range externalVersions {
if !registered.IsEnabledVersion(v) {
@@ -146,8 +122,8 @@ func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
continue
}
switch v {
- case v1.SchemeGroupVersion:
- v1.AddToScheme(api.Scheme)
+ case v1beta1.SchemeGroupVersion:
+ v1beta1.AddToScheme(api.Scheme)
}
}
}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/register.go b/vendor/k8s.io/kubernetes/federation/apis/federation/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..2cc7f1f0e2543e0908b9969ab2712cc2686928d2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/register.go
@@ -0,0 +1,56 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 federation
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "federation"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+// Adds the list of known types to api.Scheme.
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+}
+
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Cluster{},
+ &ClusterList{},
+ &api.ListOptions{},
+ &api.DeleteOptions{},
+ )
+}
+
+func (obj *Cluster) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
+func (obj *ClusterList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/types.generated.go b/vendor/k8s.io/kubernetes/federation/apis/federation/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..95ebc5994b6d9567b27140d6e6e357af69c36a14
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/types.generated.go
@@ -0,0 +1,2333 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package federation
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg1_api "k8s.io/kubernetes/pkg/api"
+ pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg1_api.LocalObjectReference
+ var v1 pkg2_unversioned.Time
+ var v2 pkg3_types.UID
+ var v3 time.Time
+ _, _, _, _ = v0, v1, v2, v3
+ }
+}
+
+func (x *ServerAddressByClientCIDR) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClientCIDR))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("clientCIDR"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClientCIDR))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServerAddress))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serverAddress"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServerAddress))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ServerAddressByClientCIDR) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ServerAddressByClientCIDR) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "clientCIDR":
+ if r.TryDecodeAsNil() {
+ x.ClientCIDR = ""
+ } else {
+ x.ClientCIDR = string(r.DecodeString())
+ }
+ case "serverAddress":
+ if r.TryDecodeAsNil() {
+ x.ServerAddress = ""
+ } else {
+ x.ServerAddress = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ServerAddressByClientCIDR) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ClientCIDR = ""
+ } else {
+ x.ClientCIDR = string(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServerAddress = ""
+ } else {
+ x.ServerAddress = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.SecretRef != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.ServerAddressByClientCIDRs == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceServerAddressByClientCIDR(([]ServerAddressByClientCIDR)(x.ServerAddressByClientCIDRs), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serverAddressByClientCIDRs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ServerAddressByClientCIDRs == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceServerAddressByClientCIDR(([]ServerAddressByClientCIDR)(x.ServerAddressByClientCIDRs), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "serverAddressByClientCIDRs":
+ if r.TryDecodeAsNil() {
+ x.ServerAddressByClientCIDRs = nil
+ } else {
+ yyv4 := &x.ServerAddressByClientCIDRs
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceServerAddressByClientCIDR((*[]ServerAddressByClientCIDR)(yyv4), d)
+ }
+ }
+ case "secretRef":
+ if r.TryDecodeAsNil() {
+ if x.SecretRef != nil {
+ x.SecretRef = nil
+ }
+ } else {
+ if x.SecretRef == nil {
+ x.SecretRef = new(pkg1_api.LocalObjectReference)
+ }
+ x.SecretRef.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServerAddressByClientCIDRs = nil
+ } else {
+ yyv8 := &x.ServerAddressByClientCIDRs
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decSliceServerAddressByClientCIDR((*[]ServerAddressByClientCIDR)(yyv8), d)
+ }
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.SecretRef != nil {
+ x.SecretRef = nil
+ }
+ } else {
+ if x.SecretRef == nil {
+ x.SecretRef = new(pkg1_api.LocalObjectReference)
+ }
+ x.SecretRef.CodecDecodeSelf(d)
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x ClusterConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *ClusterConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *ClusterCondition) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = true
+ yyq2[3] = true
+ yyq2[4] = x.Reason != ""
+ yyq2[5] = x.Message != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Type.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Type.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yysf7 := &x.Status
+ yysf7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yysf8 := &x.Status
+ yysf8.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy10 := &x.LastProbeTime
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if yym11 {
+ z.EncBinaryMarshal(yy10)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
+ } else {
+ z.EncFallback(yy10)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.LastProbeTime
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if yym13 {
+ z.EncBinaryMarshal(yy12)
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
+ } else {
+ z.EncFallback(yy12)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yy15 := &x.LastTransitionTime
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy15) {
+ } else if yym16 {
+ z.EncBinaryMarshal(yy15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy15)
+ } else {
+ z.EncFallback(yy15)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy17 := &x.LastTransitionTime
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy17) {
+ } else if yym18 {
+ z.EncBinaryMarshal(yy17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy17)
+ } else {
+ z.EncFallback(yy17)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("message"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym24 := z.EncBinary()
+ _ = yym24
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterCondition) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "type":
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = ClusterConditionType(r.DecodeString())
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg1_api.ConditionStatus(r.DecodeString())
+ }
+ case "lastProbeTime":
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg2_unversioned.Time{}
+ } else {
+ yyv6 := &x.LastProbeTime
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(yyv6)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
+ }
+ case "lastTransitionTime":
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg2_unversioned.Time{}
+ } else {
+ yyv8 := &x.LastTransitionTime
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv8) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(yyv8)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv8)
+ } else {
+ z.DecFallback(yyv8, false)
+ }
+ }
+ case "reason":
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ case "message":
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = ClusterConditionType(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg1_api.ConditionStatus(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg2_unversioned.Time{}
+ } else {
+ yyv15 := &x.LastProbeTime
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv15) {
+ } else if yym16 {
+ z.DecBinaryUnmarshal(yyv15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv15)
+ } else {
+ z.DecFallback(yyv15, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg2_unversioned.Time{}
+ } else {
+ yyv17 := &x.LastTransitionTime
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv17) {
+ } else if yym18 {
+ z.DecBinaryUnmarshal(yyv17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv17)
+ } else {
+ z.DecFallback(yyv17, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Conditions) != 0
+ yyq2[1] = len(x.Zones) != 0
+ yyq2[2] = x.Region != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceClusterCondition(([]ClusterCondition)(x.Conditions), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("conditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceClusterCondition(([]ClusterCondition)(x.Conditions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Zones == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Zones, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("zones"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Zones == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Zones, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Region))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("region"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Region))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "conditions":
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv4 := &x.Conditions
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceClusterCondition((*[]ClusterCondition)(yyv4), d)
+ }
+ }
+ case "zones":
+ if r.TryDecodeAsNil() {
+ x.Zones = nil
+ } else {
+ yyv6 := &x.Zones
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "region":
+ if r.TryDecodeAsNil() {
+ x.Region = ""
+ } else {
+ x.Region = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv10 := &x.Conditions
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else {
+ h.decSliceClusterCondition((*[]ClusterCondition)(yyv10), d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Zones = nil
+ } else {
+ yyv12 := &x.Zones
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv12, false, d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Region = ""
+ } else {
+ x.Region = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Cluster) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Cluster) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Cluster) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg1_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = ClusterSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ClusterStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Cluster) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg1_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = ClusterSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ClusterStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceCluster(([]Cluster)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceCluster(([]Cluster)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceCluster((*[]Cluster)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceCluster((*[]Cluster)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceServerAddressByClientCIDR(v []ServerAddressByClientCIDR, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceServerAddressByClientCIDR(v *[]ServerAddressByClientCIDR, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ServerAddressByClientCIDR{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ServerAddressByClientCIDR, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ServerAddressByClientCIDR, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ServerAddressByClientCIDR{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ServerAddressByClientCIDR{}) // var yyz1 ServerAddressByClientCIDR
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ServerAddressByClientCIDR{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceClusterCondition(v []ClusterCondition, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceClusterCondition(v *[]ClusterCondition, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ClusterCondition{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ClusterCondition, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ClusterCondition, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ClusterCondition{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ClusterCondition{}) // var yyz1 ClusterCondition
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ClusterCondition{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceCluster(v []Cluster, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCluster(v *[]Cluster, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Cluster{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 336)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Cluster, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Cluster, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Cluster{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Cluster{}) // var yyz1 Cluster
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Cluster{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/types.go b/vendor/k8s.io/kubernetes/federation/apis/federation/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..10a9d8beeecd3570a78211530d90ca132ec7daa9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/types.go
@@ -0,0 +1,109 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 federation
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+)
+
+// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
+type ServerAddressByClientCIDR struct {
+ // The CIDR with which clients can match their IP to figure out the server address that they should use.
+ ClientCIDR string `json:"clientCIDR" protobuf:"bytes,1,opt,name=clientCIDR"`
+ // Address of this server, suitable for a client that matches the above CIDR.
+ // This can be a hostname, hostname:port, IP or IP:port.
+ ServerAddress string `json:"serverAddress" protobuf:"bytes,2,opt,name=serverAddress"`
+}
+
+// ClusterSpec describes the attributes of a kubernetes cluster.
+type ClusterSpec struct {
+ // A map of client CIDR to server address.
+ // 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.
+ ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" patchStrategy:"merge" patchMergeKey:"clientCIDR"`
+ // Name of the secret containing kubeconfig to access this cluster.
+ // The secret is read from the kubernetes cluster that is hosting federation control plane.
+ // Admin needs to ensure that the required secret exists. Secret should be in the same namespace where federation control plane is hosted and it should have kubeconfig in its data with key "kubeconfig".
+ // This will later be changed to a reference to secret in federation control plane when the federation control plane supports secrets.
+ // This can be left empty if the cluster allows insecure access.
+ SecretRef *api.LocalObjectReference `json:"secretRef,omitempty"`
+}
+
+type ClusterConditionType string
+
+// These are valid conditions of a cluster.
+const (
+ // ClusterReady means the cluster is ready to accept workloads.
+ ClusterReady ClusterConditionType = "Ready"
+ // ClusterOffline means the cluster is temporarily down or not reachable
+ ClusterOffline ClusterConditionType = "Offline"
+)
+
+// ClusterCondition describes current state of a cluster.
+type ClusterCondition struct {
+ // Type of cluster condition, Complete or Failed.
+ Type ClusterConditionType `json:"type"`
+ // Status of the condition, one of True, False, Unknown.
+ Status api.ConditionStatus `json:"status"`
+ // Last time the condition was checked.
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
+ // Last time the condition transit from one status to another.
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ // (brief) reason for the condition's last transition.
+ Reason string `json:"reason,omitempty"`
+ // Human readable message indicating details about last transition.
+ Message string `json:"message,omitempty"`
+}
+
+// ClusterStatus is information about the current status of a cluster updated by cluster controller peridocally.
+type ClusterStatus struct {
+ // Conditions is an array of current cluster conditions.
+ Conditions []ClusterCondition `json:"conditions,omitempty"`
+ // Zones is the list of avaliability zones in which the nodes of the cluster exist, e.g. 'us-east1-a'.
+ // These will always be in the same region.
+ Zones []string `json:"zones,omitempty"`
+ // Region is the name of the region in which all of the nodes in the cluster exist. e.g. 'us-east1'.
+ Region string `json:"region,omitempty"`
+}
+
+// +genclient=true,nonNamespaced=true
+
+// Information about a registered cluster in a federated kubernetes setup. Clusters are not namespaced and have unique names in the federation.
+type Cluster struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Spec defines the behavior of the Cluster.
+ Spec ClusterSpec `json:"spec,omitempty"`
+ // Status describes the current status of a Cluster
+ Status ClusterStatus `json:"status,omitempty"`
+}
+
+// A list of all the kubernetes clusters registered to the federation
+type ClusterList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty"`
+
+ // List of Cluster objects.
+ Items []Cluster `json:"items"`
+}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion.go
new file mode 100644
index 0000000000000000000000000000000000000000..f8d396e86d45c5e43ccfba8b60217d2a621c7044
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion.go
@@ -0,0 +1,40 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addConversionFuncs(scheme *runtime.Scheme) {
+ err := api.Scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.String(), "Cluster",
+ func(label, value string) (string, string, error) {
+ switch label {
+ case "metadata.name":
+ return label, value, nil
+ default:
+ return "", "", fmt.Errorf("field label not supported: %s", label)
+ }
+ })
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion_generated.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..5877d00828a7fbd67332d9a8bf05da22c3dd34e2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/conversion_generated.go
@@ -0,0 +1,296 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ federation "k8s.io/kubernetes/federation/apis/federation"
+ api "k8s.io/kubernetes/pkg/api"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1beta1_Cluster_To_federation_Cluster,
+ Convert_federation_Cluster_To_v1beta1_Cluster,
+ Convert_v1beta1_ClusterCondition_To_federation_ClusterCondition,
+ Convert_federation_ClusterCondition_To_v1beta1_ClusterCondition,
+ Convert_v1beta1_ClusterList_To_federation_ClusterList,
+ Convert_federation_ClusterList_To_v1beta1_ClusterList,
+ Convert_v1beta1_ClusterSpec_To_federation_ClusterSpec,
+ Convert_federation_ClusterSpec_To_v1beta1_ClusterSpec,
+ Convert_v1beta1_ClusterStatus_To_federation_ClusterStatus,
+ Convert_federation_ClusterStatus_To_v1beta1_ClusterStatus,
+ Convert_v1beta1_ServerAddressByClientCIDR_To_federation_ServerAddressByClientCIDR,
+ Convert_federation_ServerAddressByClientCIDR_To_v1beta1_ServerAddressByClientCIDR,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1beta1_Cluster_To_federation_Cluster(in *Cluster, out *federation.Cluster, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ClusterSpec_To_federation_ClusterSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ClusterStatus_To_federation_ClusterStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_Cluster_To_federation_Cluster(in *Cluster, out *federation.Cluster, s conversion.Scope) error {
+ return autoConvert_v1beta1_Cluster_To_federation_Cluster(in, out, s)
+}
+
+func autoConvert_federation_Cluster_To_v1beta1_Cluster(in *federation.Cluster, out *Cluster, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_federation_ClusterSpec_To_v1beta1_ClusterSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_federation_ClusterStatus_To_v1beta1_ClusterStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_federation_Cluster_To_v1beta1_Cluster(in *federation.Cluster, out *Cluster, s conversion.Scope) error {
+ return autoConvert_federation_Cluster_To_v1beta1_Cluster(in, out, s)
+}
+
+func autoConvert_v1beta1_ClusterCondition_To_federation_ClusterCondition(in *ClusterCondition, out *federation.ClusterCondition, s conversion.Scope) error {
+ out.Type = federation.ClusterConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v1beta1_ClusterCondition_To_federation_ClusterCondition(in *ClusterCondition, out *federation.ClusterCondition, s conversion.Scope) error {
+ return autoConvert_v1beta1_ClusterCondition_To_federation_ClusterCondition(in, out, s)
+}
+
+func autoConvert_federation_ClusterCondition_To_v1beta1_ClusterCondition(in *federation.ClusterCondition, out *ClusterCondition, s conversion.Scope) error {
+ out.Type = ClusterConditionType(in.Type)
+ out.Status = v1.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_federation_ClusterCondition_To_v1beta1_ClusterCondition(in *federation.ClusterCondition, out *ClusterCondition, s conversion.Scope) error {
+ return autoConvert_federation_ClusterCondition_To_v1beta1_ClusterCondition(in, out, s)
+}
+
+func autoConvert_v1beta1_ClusterList_To_federation_ClusterList(in *ClusterList, out *federation.ClusterList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]federation.Cluster, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_Cluster_To_federation_Cluster(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ClusterList_To_federation_ClusterList(in *ClusterList, out *federation.ClusterList, s conversion.Scope) error {
+ return autoConvert_v1beta1_ClusterList_To_federation_ClusterList(in, out, s)
+}
+
+func autoConvert_federation_ClusterList_To_v1beta1_ClusterList(in *federation.ClusterList, out *ClusterList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Cluster, len(*in))
+ for i := range *in {
+ if err := Convert_federation_Cluster_To_v1beta1_Cluster(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_federation_ClusterList_To_v1beta1_ClusterList(in *federation.ClusterList, out *ClusterList, s conversion.Scope) error {
+ return autoConvert_federation_ClusterList_To_v1beta1_ClusterList(in, out, s)
+}
+
+func autoConvert_v1beta1_ClusterSpec_To_federation_ClusterSpec(in *ClusterSpec, out *federation.ClusterSpec, s conversion.Scope) error {
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := &in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]federation.ServerAddressByClientCIDR, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_ServerAddressByClientCIDR_To_federation_ServerAddressByClientCIDR(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ if in.SecretRef != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(api.LocalObjectReference)
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ClusterSpec_To_federation_ClusterSpec(in *ClusterSpec, out *federation.ClusterSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_ClusterSpec_To_federation_ClusterSpec(in, out, s)
+}
+
+func autoConvert_federation_ClusterSpec_To_v1beta1_ClusterSpec(in *federation.ClusterSpec, out *ClusterSpec, s conversion.Scope) error {
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := &in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]ServerAddressByClientCIDR, len(*in))
+ for i := range *in {
+ if err := Convert_federation_ServerAddressByClientCIDR_To_v1beta1_ServerAddressByClientCIDR(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ if in.SecretRef != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(v1.LocalObjectReference)
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ return nil
+}
+
+func Convert_federation_ClusterSpec_To_v1beta1_ClusterSpec(in *federation.ClusterSpec, out *ClusterSpec, s conversion.Scope) error {
+ return autoConvert_federation_ClusterSpec_To_v1beta1_ClusterSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_ClusterStatus_To_federation_ClusterStatus(in *ClusterStatus, out *federation.ClusterStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]federation.ClusterCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_ClusterCondition_To_federation_ClusterCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.Zones = in.Zones
+ out.Region = in.Region
+ return nil
+}
+
+func Convert_v1beta1_ClusterStatus_To_federation_ClusterStatus(in *ClusterStatus, out *federation.ClusterStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_ClusterStatus_To_federation_ClusterStatus(in, out, s)
+}
+
+func autoConvert_federation_ClusterStatus_To_v1beta1_ClusterStatus(in *federation.ClusterStatus, out *ClusterStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]ClusterCondition, len(*in))
+ for i := range *in {
+ if err := Convert_federation_ClusterCondition_To_v1beta1_ClusterCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.Zones = in.Zones
+ out.Region = in.Region
+ return nil
+}
+
+func Convert_federation_ClusterStatus_To_v1beta1_ClusterStatus(in *federation.ClusterStatus, out *ClusterStatus, s conversion.Scope) error {
+ return autoConvert_federation_ClusterStatus_To_v1beta1_ClusterStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_ServerAddressByClientCIDR_To_federation_ServerAddressByClientCIDR(in *ServerAddressByClientCIDR, out *federation.ServerAddressByClientCIDR, s conversion.Scope) error {
+ out.ClientCIDR = in.ClientCIDR
+ out.ServerAddress = in.ServerAddress
+ return nil
+}
+
+func Convert_v1beta1_ServerAddressByClientCIDR_To_federation_ServerAddressByClientCIDR(in *ServerAddressByClientCIDR, out *federation.ServerAddressByClientCIDR, s conversion.Scope) error {
+ return autoConvert_v1beta1_ServerAddressByClientCIDR_To_federation_ServerAddressByClientCIDR(in, out, s)
+}
+
+func autoConvert_federation_ServerAddressByClientCIDR_To_v1beta1_ServerAddressByClientCIDR(in *federation.ServerAddressByClientCIDR, out *ServerAddressByClientCIDR, s conversion.Scope) error {
+ out.ClientCIDR = in.ClientCIDR
+ out.ServerAddress = in.ServerAddress
+ return nil
+}
+
+func Convert_federation_ServerAddressByClientCIDR_To_v1beta1_ServerAddressByClientCIDR(in *federation.ServerAddressByClientCIDR, out *ServerAddressByClientCIDR, s conversion.Scope) error {
+ return autoConvert_federation_ServerAddressByClientCIDR_To_v1beta1_ServerAddressByClientCIDR(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d53b4a6a9d6a3780b140797f2598e82b2b4a7d6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/deep_copy_generated.go
@@ -0,0 +1,146 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1beta1_Cluster,
+ DeepCopy_v1beta1_ClusterCondition,
+ DeepCopy_v1beta1_ClusterList,
+ DeepCopy_v1beta1_ClusterSpec,
+ DeepCopy_v1beta1_ClusterStatus,
+ DeepCopy_v1beta1_ServerAddressByClientCIDR,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1beta1_Cluster(in Cluster, out *Cluster, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ClusterSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ClusterStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ClusterCondition(in ClusterCondition, out *ClusterCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1beta1_ClusterList(in ClusterList, out *ClusterList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Cluster, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_Cluster(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ClusterSpec(in ClusterSpec, out *ClusterSpec, c *conversion.Cloner) error {
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]ServerAddressByClientCIDR, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_ServerAddressByClientCIDR(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ if in.SecretRef != nil {
+ in, out := in.SecretRef, &out.SecretRef
+ *out = new(v1.LocalObjectReference)
+ if err := v1.DeepCopy_v1_LocalObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ClusterStatus(in ClusterStatus, out *ClusterStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]ClusterCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_ClusterCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.Zones != nil {
+ in, out := in.Zones, &out.Zones
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Zones = nil
+ }
+ out.Region = in.Region
+ return nil
+}
+
+func DeepCopy_v1beta1_ServerAddressByClientCIDR(in ServerAddressByClientCIDR, out *ServerAddressByClientCIDR, c *conversion.Cloner) error {
+ out.ClientCIDR = in.ClientCIDR
+ out.ServerAddress = in.ServerAddress
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/defaults.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go
rename to vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/defaults.go
index 2b5173dcd2d01dbea3689cda6a63fd924452d8fd..b096ce2fda8d18fa00d27c4baebe5f1a205bd4b3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/defaults.go
@@ -14,19 +14,11 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package v1
+package v1beta1
import (
"k8s.io/kubernetes/pkg/runtime"
)
func addDefaultingFuncs(scheme *runtime.Scheme) {
- scheme.AddDefaultingFuncs(
- func(obj *HorizontalPodAutoscaler) {
- if obj.Spec.MinReplicas == nil {
- minReplicas := int32(1)
- obj.Spec.MinReplicas = &minReplicas
- }
- },
- )
}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/doc.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfdb87c53d848bec83a37e7fca7492be7790d03e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1beta1
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.pb.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..e9193b6089765ce6483c273fc5b6953c7280f07b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.pb.go
@@ -0,0 +1,1398 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1beta1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.proto
+
+ It has these top-level messages:
+ Cluster
+ ClusterCondition
+ ClusterList
+ ClusterSpec
+ ClusterStatus
+ ServerAddressByClientCIDR
+*/
+package v1beta1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *Cluster) Reset() { *m = Cluster{} }
+func (m *Cluster) String() string { return proto.CompactTextString(m) }
+func (*Cluster) ProtoMessage() {}
+
+func (m *ClusterCondition) Reset() { *m = ClusterCondition{} }
+func (m *ClusterCondition) String() string { return proto.CompactTextString(m) }
+func (*ClusterCondition) ProtoMessage() {}
+
+func (m *ClusterList) Reset() { *m = ClusterList{} }
+func (m *ClusterList) String() string { return proto.CompactTextString(m) }
+func (*ClusterList) ProtoMessage() {}
+
+func (m *ClusterSpec) Reset() { *m = ClusterSpec{} }
+func (m *ClusterSpec) String() string { return proto.CompactTextString(m) }
+func (*ClusterSpec) ProtoMessage() {}
+
+func (m *ClusterStatus) Reset() { *m = ClusterStatus{} }
+func (m *ClusterStatus) String() string { return proto.CompactTextString(m) }
+func (*ClusterStatus) ProtoMessage() {}
+
+func (m *ServerAddressByClientCIDR) Reset() { *m = ServerAddressByClientCIDR{} }
+func (m *ServerAddressByClientCIDR) String() string { return proto.CompactTextString(m) }
+func (*ServerAddressByClientCIDR) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*Cluster)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.Cluster")
+ proto.RegisterType((*ClusterCondition)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.ClusterCondition")
+ proto.RegisterType((*ClusterList)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.ClusterList")
+ proto.RegisterType((*ClusterSpec)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.ClusterSpec")
+ proto.RegisterType((*ClusterStatus)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.ClusterStatus")
+ proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.kubernetes.federation.apis.federation.v1beta1.ServerAddressByClientCIDR")
+}
+func (m *Cluster) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Cluster) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *ClusterCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
+ n4, err := m.LastProbeTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n5, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *ClusterList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n6, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ClusterSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, msg := range m.ServerAddressByClientCIDRs {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.SecretRef != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecretRef.Size()))
+ n7, err := m.SecretRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ }
+ return i, nil
+}
+
+func (m *ClusterStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Zones) > 0 {
+ for _, s := range m.Zones {
+ data[i] = 0x2a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Region)))
+ i += copy(data[i:], m.Region)
+ return i, nil
+}
+
+func (m *ServerAddressByClientCIDR) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServerAddressByClientCIDR) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ClientCIDR)))
+ i += copy(data[i:], m.ClientCIDR)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ServerAddress)))
+ i += copy(data[i:], m.ServerAddress)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *Cluster) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ClusterCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastProbeTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ClusterList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ClusterSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, e := range m.ServerAddressByClientCIDRs {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.SecretRef != nil {
+ l = m.SecretRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ClusterStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Zones) > 0 {
+ for _, s := range m.Zones {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.Region)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ServerAddressByClientCIDR) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.ClientCIDR)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ServerAddress)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Cluster) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Cluster: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = ClusterConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = k8s_io_kubernetes_pkg_api_v1.ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Cluster{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
+ if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecretRef == nil {
+ m.SecretRef = &k8s_io_kubernetes_pkg_api_v1.LocalObjectReference{}
+ }
+ if err := m.SecretRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, ClusterCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Zones", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Zones = append(m.Zones, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Region = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServerAddressByClientCIDR) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServerAddressByClientCIDR: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ClientCIDR = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServerAddress = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.proto b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..811f40f43475c913d4479f919a2dadd0f8b79bcd
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/generated.proto
@@ -0,0 +1,114 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.federation.apis.federation.v1beta1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1beta1";
+
+// Information about a registered cluster in a federated kubernetes setup. Clusters are not namespaced and have unique names in the federation.
+message Cluster {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec defines the behavior of the Cluster.
+ optional ClusterSpec spec = 2;
+
+ // Status describes the current status of a Cluster
+ optional ClusterStatus status = 3;
+}
+
+// ClusterCondition describes current state of a cluster.
+message ClusterCondition {
+ // Type of cluster condition, Complete or Failed.
+ optional string type = 1;
+
+ // Status of the condition, one of True, False, Unknown.
+ optional string status = 2;
+
+ // Last time the condition was checked.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastProbeTime = 3;
+
+ // Last time the condition transit from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // (brief) reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// A list of all the kubernetes clusters registered to the federation
+message ClusterList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of Cluster objects.
+ repeated Cluster items = 2;
+}
+
+// ClusterSpec describes the attributes of a kubernetes cluster.
+message ClusterSpec {
+ // A map of client CIDR to server address.
+ // 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.
+ repeated ServerAddressByClientCIDR serverAddressByClientCIDRs = 1;
+
+ // Name of the secret containing kubeconfig to access this cluster.
+ // The secret is read from the kubernetes cluster that is hosting federation control plane.
+ // Admin needs to ensure that the required secret exists. Secret should be in the same namespace where federation control plane is hosted and it should have kubeconfig in its data with key "kubeconfig".
+ // This will later be changed to a reference to secret in federation control plane when the federation control plane supports secrets.
+ // This can be left empty if the cluster allows insecure access.
+ optional k8s.io.kubernetes.pkg.api.v1.LocalObjectReference secretRef = 2;
+}
+
+// ClusterStatus is information about the current status of a cluster updated by cluster controller peridocally.
+message ClusterStatus {
+ // Conditions is an array of current cluster conditions.
+ repeated ClusterCondition conditions = 1;
+
+ // Zones is the list of avaliability zones in which the nodes of the cluster exist, e.g. 'us-east1-a'.
+ // These will always be in the same region.
+ repeated string zones = 5;
+
+ // Region is the name of the region in which all of the nodes in the cluster exist. e.g. 'us-east1'.
+ optional string region = 6;
+}
+
+// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
+message ServerAddressByClientCIDR {
+ // The CIDR with which clients can match their IP to figure out the server address that they should use.
+ optional string clientCIDR = 1;
+
+ // Address of this server, suitable for a client that matches the above CIDR.
+ // This can be a hostname, hostname:port, IP or IP:port.
+ optional string serverAddress = 2;
+}
+
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/register.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..46dc3f10b7a0f1bf6d2a647ee3a8c3b199bfe465
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/register.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "federation"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1beta1"}
+
+// Adds the list of known types to api.Scheme.
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+}
+
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Cluster{},
+ &ClusterList{},
+ &v1.ListOptions{},
+ &v1.DeleteOptions{},
+ )
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
+
+func (obj *Cluster) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
+func (obj *ClusterList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.generated.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..e4d7246f244c1fb3eb7ae9b7b9d28d6df88ab6c8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.generated.go
@@ -0,0 +1,2333 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v1beta1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg1_v1 "k8s.io/kubernetes/pkg/api/v1"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_unversioned.Time
+ var v1 pkg1_v1.LocalObjectReference
+ var v2 pkg3_types.UID
+ var v3 time.Time
+ _, _, _, _ = v0, v1, v2, v3
+ }
+}
+
+func (x *ServerAddressByClientCIDR) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClientCIDR))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("clientCIDR"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClientCIDR))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServerAddress))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serverAddress"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServerAddress))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ServerAddressByClientCIDR) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ServerAddressByClientCIDR) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "clientCIDR":
+ if r.TryDecodeAsNil() {
+ x.ClientCIDR = ""
+ } else {
+ x.ClientCIDR = string(r.DecodeString())
+ }
+ case "serverAddress":
+ if r.TryDecodeAsNil() {
+ x.ServerAddress = ""
+ } else {
+ x.ServerAddress = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ServerAddressByClientCIDR) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ClientCIDR = ""
+ } else {
+ x.ClientCIDR = string(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServerAddress = ""
+ } else {
+ x.ServerAddress = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.SecretRef != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.ServerAddressByClientCIDRs == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceServerAddressByClientCIDR(([]ServerAddressByClientCIDR)(x.ServerAddressByClientCIDRs), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serverAddressByClientCIDRs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ServerAddressByClientCIDRs == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceServerAddressByClientCIDR(([]ServerAddressByClientCIDR)(x.ServerAddressByClientCIDRs), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "serverAddressByClientCIDRs":
+ if r.TryDecodeAsNil() {
+ x.ServerAddressByClientCIDRs = nil
+ } else {
+ yyv4 := &x.ServerAddressByClientCIDRs
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceServerAddressByClientCIDR((*[]ServerAddressByClientCIDR)(yyv4), d)
+ }
+ }
+ case "secretRef":
+ if r.TryDecodeAsNil() {
+ if x.SecretRef != nil {
+ x.SecretRef = nil
+ }
+ } else {
+ if x.SecretRef == nil {
+ x.SecretRef = new(pkg1_v1.LocalObjectReference)
+ }
+ x.SecretRef.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServerAddressByClientCIDRs = nil
+ } else {
+ yyv8 := &x.ServerAddressByClientCIDRs
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decSliceServerAddressByClientCIDR((*[]ServerAddressByClientCIDR)(yyv8), d)
+ }
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.SecretRef != nil {
+ x.SecretRef = nil
+ }
+ } else {
+ if x.SecretRef == nil {
+ x.SecretRef = new(pkg1_v1.LocalObjectReference)
+ }
+ x.SecretRef.CodecDecodeSelf(d)
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x ClusterConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *ClusterConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *ClusterCondition) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = true
+ yyq2[3] = true
+ yyq2[4] = x.Reason != ""
+ yyq2[5] = x.Message != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Type.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Type.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yysf7 := &x.Status
+ yysf7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yysf8 := &x.Status
+ yysf8.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy10 := &x.LastProbeTime
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if yym11 {
+ z.EncBinaryMarshal(yy10)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
+ } else {
+ z.EncFallback(yy10)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.LastProbeTime
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if yym13 {
+ z.EncBinaryMarshal(yy12)
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
+ } else {
+ z.EncFallback(yy12)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yy15 := &x.LastTransitionTime
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy15) {
+ } else if yym16 {
+ z.EncBinaryMarshal(yy15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy15)
+ } else {
+ z.EncFallback(yy15)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy17 := &x.LastTransitionTime
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy17) {
+ } else if yym18 {
+ z.EncBinaryMarshal(yy17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy17)
+ } else {
+ z.EncFallback(yy17)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("message"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym24 := z.EncBinary()
+ _ = yym24
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterCondition) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "type":
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = ClusterConditionType(r.DecodeString())
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg1_v1.ConditionStatus(r.DecodeString())
+ }
+ case "lastProbeTime":
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg2_unversioned.Time{}
+ } else {
+ yyv6 := &x.LastProbeTime
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(yyv6)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
+ }
+ case "lastTransitionTime":
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg2_unversioned.Time{}
+ } else {
+ yyv8 := &x.LastTransitionTime
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv8) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(yyv8)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv8)
+ } else {
+ z.DecFallback(yyv8, false)
+ }
+ }
+ case "reason":
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ case "message":
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = ClusterConditionType(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg1_v1.ConditionStatus(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg2_unversioned.Time{}
+ } else {
+ yyv15 := &x.LastProbeTime
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv15) {
+ } else if yym16 {
+ z.DecBinaryUnmarshal(yyv15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv15)
+ } else {
+ z.DecFallback(yyv15, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg2_unversioned.Time{}
+ } else {
+ yyv17 := &x.LastTransitionTime
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv17) {
+ } else if yym18 {
+ z.DecBinaryUnmarshal(yyv17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv17)
+ } else {
+ z.DecFallback(yyv17, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Conditions) != 0
+ yyq2[1] = len(x.Zones) != 0
+ yyq2[2] = x.Region != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceClusterCondition(([]ClusterCondition)(x.Conditions), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("conditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceClusterCondition(([]ClusterCondition)(x.Conditions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Zones == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Zones, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("zones"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Zones == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Zones, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Region))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("region"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Region))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "conditions":
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv4 := &x.Conditions
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceClusterCondition((*[]ClusterCondition)(yyv4), d)
+ }
+ }
+ case "zones":
+ if r.TryDecodeAsNil() {
+ x.Zones = nil
+ } else {
+ yyv6 := &x.Zones
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "region":
+ if r.TryDecodeAsNil() {
+ x.Region = ""
+ } else {
+ x.Region = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv10 := &x.Conditions
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else {
+ h.decSliceClusterCondition((*[]ClusterCondition)(yyv10), d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Zones = nil
+ } else {
+ yyv12 := &x.Zones
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv12, false, d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Region = ""
+ } else {
+ x.Region = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Cluster) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Cluster) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Cluster) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg1_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = ClusterSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ClusterStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Cluster) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg1_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = ClusterSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ClusterStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceCluster(([]Cluster)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceCluster(([]Cluster)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceCluster((*[]Cluster)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceCluster((*[]Cluster)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceServerAddressByClientCIDR(v []ServerAddressByClientCIDR, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceServerAddressByClientCIDR(v *[]ServerAddressByClientCIDR, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ServerAddressByClientCIDR{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ServerAddressByClientCIDR, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ServerAddressByClientCIDR, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ServerAddressByClientCIDR{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ServerAddressByClientCIDR{}) // var yyz1 ServerAddressByClientCIDR
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ServerAddressByClientCIDR{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ServerAddressByClientCIDR{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceClusterCondition(v []ClusterCondition, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceClusterCondition(v *[]ClusterCondition, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ClusterCondition{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ClusterCondition, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ClusterCondition, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ClusterCondition{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ClusterCondition{}) // var yyz1 ClusterCondition
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterCondition{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ClusterCondition{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceCluster(v []Cluster, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCluster(v *[]Cluster, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Cluster{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 336)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Cluster, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Cluster, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Cluster{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Cluster{}) // var yyz1 Cluster
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Cluster{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Cluster{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.go b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..f15988e2f88a0ecddea05f6fb9455f54c9fa29f9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/apis/federation/v1beta1/types.go
@@ -0,0 +1,109 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+)
+
+// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
+type ServerAddressByClientCIDR struct {
+ // The CIDR with which clients can match their IP to figure out the server address that they should use.
+ ClientCIDR string `json:"clientCIDR" protobuf:"bytes,1,opt,name=clientCIDR"`
+ // Address of this server, suitable for a client that matches the above CIDR.
+ // This can be a hostname, hostname:port, IP or IP:port.
+ ServerAddress string `json:"serverAddress" protobuf:"bytes,2,opt,name=serverAddress"`
+}
+
+// ClusterSpec describes the attributes of a kubernetes cluster.
+type ClusterSpec struct {
+ // A map of client CIDR to server address.
+ // 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.
+ ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" patchStrategy:"merge" patchMergeKey:"clientCIDR" protobuf:"bytes,1,rep,name=serverAddressByClientCIDRs"`
+ // Name of the secret containing kubeconfig to access this cluster.
+ // The secret is read from the kubernetes cluster that is hosting federation control plane.
+ // Admin needs to ensure that the required secret exists. Secret should be in the same namespace where federation control plane is hosted and it should have kubeconfig in its data with key "kubeconfig".
+ // This will later be changed to a reference to secret in federation control plane when the federation control plane supports secrets.
+ // This can be left empty if the cluster allows insecure access.
+ SecretRef *v1.LocalObjectReference `json:"secretRef,omitempty" protobuf:"bytes,2,opt,name=secretRef"`
+}
+
+type ClusterConditionType string
+
+// These are valid conditions of a cluster.
+const (
+ // ClusterReady means the cluster is ready to accept workloads.
+ ClusterReady ClusterConditionType = "Ready"
+ // ClusterOffline means the cluster is temporarily down or not reachable
+ ClusterOffline ClusterConditionType = "Offline"
+)
+
+// ClusterCondition describes current state of a cluster.
+type ClusterCondition struct {
+ // Type of cluster condition, Complete or Failed.
+ Type ClusterConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=ClusterConditionType"`
+ // Status of the condition, one of True, False, Unknown.
+ Status v1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/kubernetes/pkg/api/v1.ConditionStatus"`
+ // Last time the condition was checked.
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty" protobuf:"bytes,3,opt,name=lastProbeTime"`
+ // Last time the condition transit from one status to another.
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
+ // (brief) reason for the condition's last transition.
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
+ // Human readable message indicating details about last transition.
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
+}
+
+// ClusterStatus is information about the current status of a cluster updated by cluster controller peridocally.
+type ClusterStatus struct {
+ // Conditions is an array of current cluster conditions.
+ Conditions []ClusterCondition `json:"conditions,omitempty" protobuf:"bytes,1,rep,name=conditions"`
+ // Zones is the list of avaliability zones in which the nodes of the cluster exist, e.g. 'us-east1-a'.
+ // These will always be in the same region.
+ Zones []string `json:"zones,omitempty" protobuf:"bytes,5,rep,name=zones"`
+ // Region is the name of the region in which all of the nodes in the cluster exist. e.g. 'us-east1'.
+ Region string `json:"region,omitempty" protobuf:"bytes,6,opt,name=region"`
+}
+
+// +genclient=true,nonNamespaced=true
+
+// Information about a registered cluster in a federated kubernetes setup. Clusters are not namespaced and have unique names in the federation.
+type Cluster struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Spec defines the behavior of the Cluster.
+ Spec ClusterSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+ // Status describes the current status of a Cluster
+ Status ClusterStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// A list of all the kubernetes clusters registered to the federation
+type ClusterList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // List of Cluster objects.
+ Items []Cluster `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/clientset.go
similarity index 64%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go
rename to vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/clientset.go
index 599a0c40b296997cc697cea87ce64a4465a64c9a..f8163ef8355c21325d615b8891455dbbf63dbd23 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/clientset.go
@@ -14,40 +14,47 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package internalclientset
+package federation_internalclientset
import (
"github.com/golang/glog"
+ unversionedcore "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned"
+ unversionedfederation "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned"
restclient "k8s.io/kubernetes/pkg/client/restclient"
discovery "k8s.io/kubernetes/pkg/client/typed/discovery"
- unversionedcore "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
- unversionedextensions "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
)
type Interface interface {
Discovery() discovery.DiscoveryInterface
+ Federation() unversionedfederation.FederationInterface
Core() unversionedcore.CoreInterface
- Extensions() unversionedextensions.ExtensionsInterface
}
// Clientset contains the clients for groups. Each group has exactly one
// version included in a Clientset.
type Clientset struct {
*discovery.DiscoveryClient
+ *unversionedfederation.FederationClient
*unversionedcore.CoreClient
- *unversionedextensions.ExtensionsClient
+}
+
+// Federation retrieves the FederationClient
+func (c *Clientset) Federation() unversionedfederation.FederationInterface {
+ if c == nil {
+ return nil
+ }
+ return c.FederationClient
}
// Core retrieves the CoreClient
func (c *Clientset) Core() unversionedcore.CoreInterface {
+ if c == nil {
+ return nil
+ }
return c.CoreClient
}
-// Extensions retrieves the ExtensionsClient
-func (c *Clientset) Extensions() unversionedextensions.ExtensionsInterface {
- return c.ExtensionsClient
-}
-
// Discovery retrieves the DiscoveryClient
func (c *Clientset) Discovery() discovery.DiscoveryInterface {
return c.DiscoveryClient
@@ -55,30 +62,35 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface {
// NewForConfig creates a new Clientset for the given config.
func NewForConfig(c *restclient.Config) (*Clientset, error) {
+ configShallowCopy := *c
+ if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+ configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+ }
var clientset Clientset
var err error
- clientset.CoreClient, err = unversionedcore.NewForConfig(c)
+ clientset.FederationClient, err = unversionedfederation.NewForConfig(&configShallowCopy)
if err != nil {
- return &clientset, err
+ return nil, err
}
- clientset.ExtensionsClient, err = unversionedextensions.NewForConfig(c)
+ clientset.CoreClient, err = unversionedcore.NewForConfig(&configShallowCopy)
if err != nil {
- return &clientset, err
+ return nil, err
}
- clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(c)
+ clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
if err != nil {
glog.Errorf("failed to create the DiscoveryClient: %v", err)
+ return nil, err
}
- return &clientset, err
+ return &clientset, nil
}
// NewForConfigOrDie creates a new Clientset for the given config and
// panics if there is an error in the config.
func NewForConfigOrDie(c *restclient.Config) *Clientset {
var clientset Clientset
+ clientset.FederationClient = unversionedfederation.NewForConfigOrDie(c)
clientset.CoreClient = unversionedcore.NewForConfigOrDie(c)
- clientset.ExtensionsClient = unversionedextensions.NewForConfigOrDie(c)
clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &clientset
@@ -87,8 +99,8 @@ func NewForConfigOrDie(c *restclient.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c *restclient.RESTClient) *Clientset {
var clientset Clientset
+ clientset.FederationClient = unversionedfederation.New(c)
clientset.CoreClient = unversionedcore.New(c)
- clientset.ExtensionsClient = unversionedextensions.New(c)
clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &clientset
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/doc.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..40d4acceae9de50cd837e230caa9ee850dea6a8c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=federation_internalclientset --clientset-path=k8s.io/kubernetes/federation/client/clientset_generated --included-types-overrides=[api/Service] --input=[../../federation/apis/federation/,api/]
+
+// This package has the automatically generated clientset.
+package federation_internalclientset
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/import_known_versions.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/import_known_versions.go
new file mode 100644
index 0000000000000000000000000000000000000000..af8c2e7436f8bf06c199cb6b55f7cf74bb94e37c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/import_known_versions.go
@@ -0,0 +1,25 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 federation_internalclientset
+
+// These imports are the API groups the client will support.
+import (
+ _ "k8s.io/kubernetes/federation/apis/federation/install"
+)
+
+func init() {
+}
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/core_client.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/core_client.go
new file mode 100644
index 0000000000000000000000000000000000000000..d308d0fe1ea91d9ba6b6175e3ab02fc37b54f69b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/core_client.go
@@ -0,0 +1,101 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type CoreInterface interface {
+ GetRESTClient() *restclient.RESTClient
+ ServicesGetter
+}
+
+// CoreClient is used to interact with features provided by the Core group.
+type CoreClient struct {
+ *restclient.RESTClient
+}
+
+func (c *CoreClient) Services(namespace string) ServiceInterface {
+ return newServices(c, namespace)
+}
+
+// NewForConfig creates a new CoreClient for the given config.
+func NewForConfig(c *restclient.Config) (*CoreClient, error) {
+ config := *c
+ if err := setConfigDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &CoreClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new CoreClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *CoreClient {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new CoreClient for the given RESTClient.
+func New(c *restclient.RESTClient) *CoreClient {
+ return &CoreClient{c}
+}
+
+func setConfigDefaults(config *restclient.Config) error {
+ // if core group is not registered, return an error
+ g, err := registered.Group("")
+ if err != nil {
+ return err
+ }
+ config.APIPath = "/api"
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.NegotiatedSerializer = api.Codecs
+
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *CoreClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/doc.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..30cff08b9486c7537e97ac660a0c922f0e1ec264
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=federation_internalclientset --clientset-path=k8s.io/kubernetes/federation/client/clientset_generated --included-types-overrides=[api/Service] --input=[../../federation/apis/federation/,api/]
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/doc.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/generated_expansion.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/doc.go
rename to vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/generated_expansion.go
index 9300170400fedab412162298a0a33b45d727317b..65df6665a9c533f04f0dea2871ebf4456027889f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/doc.go
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/generated_expansion.go
@@ -14,5 +14,6 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package unversioned has the automatically generated clients for unversioned resources.
package unversioned
+
+type ServiceExpansion interface{}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/service.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/service.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/service.go
rename to vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/core/unversioned/service.go
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/cluster.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/cluster.go
new file mode 100644
index 0000000000000000000000000000000000000000..e270951455c97ee061e0e8d57511edba4506f198
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/cluster.go
@@ -0,0 +1,140 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ federation "k8s.io/kubernetes/federation/apis/federation"
+ api "k8s.io/kubernetes/pkg/api"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ClustersGetter has a method to return a ClusterInterface.
+// A group's client should implement this interface.
+type ClustersGetter interface {
+ Clusters() ClusterInterface
+}
+
+// ClusterInterface has methods to work with Cluster resources.
+type ClusterInterface interface {
+ Create(*federation.Cluster) (*federation.Cluster, error)
+ Update(*federation.Cluster) (*federation.Cluster, error)
+ UpdateStatus(*federation.Cluster) (*federation.Cluster, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*federation.Cluster, error)
+ List(opts api.ListOptions) (*federation.ClusterList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ ClusterExpansion
+}
+
+// clusters implements ClusterInterface
+type clusters struct {
+ client *FederationClient
+}
+
+// newClusters returns a Clusters
+func newClusters(c *FederationClient) *clusters {
+ return &clusters{
+ client: c,
+ }
+}
+
+// Create takes the representation of a cluster and creates it. Returns the server's representation of the cluster, and an error, if there is any.
+func (c *clusters) Create(cluster *federation.Cluster) (result *federation.Cluster, err error) {
+ result = &federation.Cluster{}
+ err = c.client.Post().
+ Resource("clusters").
+ Body(cluster).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a cluster and updates it. Returns the server's representation of the cluster, and an error, if there is any.
+func (c *clusters) Update(cluster *federation.Cluster) (result *federation.Cluster, err error) {
+ result = &federation.Cluster{}
+ err = c.client.Put().
+ Resource("clusters").
+ Name(cluster.Name).
+ Body(cluster).
+ Do().
+ Into(result)
+ return
+}
+
+func (c *clusters) UpdateStatus(cluster *federation.Cluster) (result *federation.Cluster, err error) {
+ result = &federation.Cluster{}
+ err = c.client.Put().
+ Resource("clusters").
+ Name(cluster.Name).
+ SubResource("status").
+ Body(cluster).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the cluster and deletes it. Returns an error if one occurs.
+func (c *clusters) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Resource("clusters").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *clusters) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Resource("clusters").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the cluster, and returns the corresponding cluster object, and an error if there is any.
+func (c *clusters) Get(name string) (result *federation.Cluster, err error) {
+ result = &federation.Cluster{}
+ err = c.client.Get().
+ Resource("clusters").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of Clusters that match those selectors.
+func (c *clusters) List(opts api.ListOptions) (result *federation.ClusterList, err error) {
+ result = &federation.ClusterList{}
+ err = c.client.Get().
+ Resource("clusters").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested clusters.
+func (c *clusters) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("clusters").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/doc.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..30cff08b9486c7537e97ac660a0c922f0e1ec264
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=federation_internalclientset --clientset-path=k8s.io/kubernetes/federation/client/clientset_generated --included-types-overrides=[api/Service] --input=[../../federation/apis/federation/,api/]
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/federation_client.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/federation_client.go
new file mode 100644
index 0000000000000000000000000000000000000000..be2a8a153c139a430871c85ee307b22931f754f0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/federation_client.go
@@ -0,0 +1,101 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type FederationInterface interface {
+ GetRESTClient() *restclient.RESTClient
+ ClustersGetter
+}
+
+// FederationClient is used to interact with features provided by the Federation group.
+type FederationClient struct {
+ *restclient.RESTClient
+}
+
+func (c *FederationClient) Clusters() ClusterInterface {
+ return newClusters(c)
+}
+
+// NewForConfig creates a new FederationClient for the given config.
+func NewForConfig(c *restclient.Config) (*FederationClient, error) {
+ config := *c
+ if err := setConfigDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &FederationClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new FederationClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *FederationClient {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new FederationClient for the given RESTClient.
+func New(c *restclient.RESTClient) *FederationClient {
+ return &FederationClient{c}
+}
+
+func setConfigDefaults(config *restclient.Config) error {
+ // if federation group is not registered, return an error
+ g, err := registered.Group("federation")
+ if err != nil {
+ return err
+ }
+ config.APIPath = "/apis"
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.NegotiatedSerializer = api.Codecs
+
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FederationClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/doc.go b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/generated_expansion.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/doc.go
rename to vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/generated_expansion.go
index 9300170400fedab412162298a0a33b45d727317b..8888bf9bd497df9a0b40ae399f45e22c6754f334 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/doc.go
+++ b/vendor/k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/typed/federation/unversioned/generated_expansion.go
@@ -14,5 +14,6 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package unversioned has the automatically generated clients for unversioned resources.
package unversioned
+
+type ClusterExpansion interface{}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/OWNERS b/vendor/k8s.io/kubernetes/pkg/api/OWNERS
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/api/OWNERS
diff --git a/vendor/k8s.io/kubernetes/pkg/api/annotations/annotations.go b/vendor/k8s.io/kubernetes/pkg/api/annotations/annotations.go
new file mode 100644
index 0000000000000000000000000000000000000000..dbdf11cbabcf8cf23c39848d7f7af9b060a0f56d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/annotations/annotations.go
@@ -0,0 +1,23 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 annotations
+
+const kubectlPrefix = "kubectl.kubernetes.io/"
+
+// LastAppliedConfigAnnotation is the annotation used to store the previous
+// configuration of a resource for use in a three way diff by UpdateApplyAnnotation.
+const LastAppliedConfigAnnotation = kubectlPrefix + "last-applied-configuration"
diff --git a/vendor/k8s.io/kubernetes/pkg/api/annotations/doc.go b/vendor/k8s.io/kubernetes/pkg/api/annotations/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..6a422ea4f414221e8e9125e205f95b90e43d8a7e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/annotations/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 annotations defines annotation keys that shared between server and client
+package annotations
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/context.go b/vendor/k8s.io/kubernetes/pkg/api/context.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/context.go
rename to vendor/k8s.io/kubernetes/pkg/api/context.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/conversion.go b/vendor/k8s.io/kubernetes/pkg/api/conversion.go
similarity index 84%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/conversion.go
rename to vendor/k8s.io/kubernetes/pkg/api/conversion.go
index e0605fa098e7801090ad2d8c231a4b90000f1d01..7ae1e0184e3955215dfa5e44f4f59e538f1ec6b6 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/conversion.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/conversion.go
@@ -41,20 +41,20 @@ func init() {
Convert_unversioned_ListMeta_To_unversioned_ListMeta,
Convert_intstr_IntOrString_To_intstr_IntOrString,
Convert_unversioned_Time_To_unversioned_Time,
- Convert_string_slice_To_unversioned_Time,
+ Convert_Slice_string_To_unversioned_Time,
Convert_string_To_labels_Selector,
Convert_string_To_fields_Selector,
- Convert_bool_ref_To_bool,
- Convert_bool_To_bool_ref,
- Convert_string_ref_To_string,
- Convert_string_To_string_ref,
+ Convert_Pointer_bool_To_bool,
+ Convert_bool_To_Pointer_bool,
+ Convert_Pointer_string_To_string,
+ Convert_string_To_Pointer_string,
Convert_labels_Selector_To_string,
Convert_fields_Selector_To_string,
Convert_resource_Quantity_To_resource_Quantity,
)
}
-func Convert_string_ref_To_string(in **string, out *string, s conversion.Scope) error {
+func Convert_Pointer_string_To_string(in **string, out *string, s conversion.Scope) error {
if *in == nil {
*out = ""
return nil
@@ -63,7 +63,7 @@ func Convert_string_ref_To_string(in **string, out *string, s conversion.Scope)
return nil
}
-func Convert_string_To_string_ref(in *string, out **string, s conversion.Scope) error {
+func Convert_string_To_Pointer_string(in *string, out **string, s conversion.Scope) error {
if in == nil {
stringVar := ""
*out = &stringVar
@@ -73,7 +73,7 @@ func Convert_string_To_string_ref(in *string, out **string, s conversion.Scope)
return nil
}
-func Convert_bool_ref_To_bool(in **bool, out *bool, s conversion.Scope) error {
+func Convert_Pointer_bool_To_bool(in **bool, out *bool, s conversion.Scope) error {
if *in == nil {
*out = false
return nil
@@ -82,7 +82,7 @@ func Convert_bool_ref_To_bool(in **bool, out *bool, s conversion.Scope) error {
return nil
}
-func Convert_bool_To_bool_ref(in *bool, out **bool, s conversion.Scope) error {
+func Convert_bool_To_Pointer_bool(in *bool, out **bool, s conversion.Scope) error {
if in == nil {
boolVar := false
*out = &boolVar
@@ -118,8 +118,8 @@ func Convert_unversioned_Time_To_unversioned_Time(in *unversioned.Time, out *unv
return nil
}
-// Convert_string_slice_To_unversioned_Time allows converting a URL query parameter value
-func Convert_string_slice_To_unversioned_Time(input *[]string, out *unversioned.Time, s conversion.Scope) error {
+// Convert_Slice_string_To_unversioned_Time allows converting a URL query parameter value
+func Convert_Slice_string_To_unversioned_Time(input *[]string, out *unversioned.Time, s conversion.Scope) error {
str := ""
if len(*input) > 0 {
str = (*input)[0]
@@ -158,7 +158,6 @@ func Convert_fields_Selector_To_string(in *fields.Selector, out *string, s conve
return nil
}
func Convert_resource_Quantity_To_resource_Quantity(in *resource.Quantity, out *resource.Quantity, s conversion.Scope) error {
- // Cannot deep copy these, because inf.Dec has unexported fields.
- *out = *in.Copy()
+ *out = *in
return nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/api/deep_copy_generated.go
similarity index 78%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/deep_copy_generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/deep_copy_generated.go
index aa2712e1025b57996c6321957ace310cab6a968b..f3181b8a730dfaff0b9de7c3554f5da5c95336da 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/deep_copy_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/deep_copy_generated.go
@@ -1,3 +1,5 @@
+// +build !ignore_autogenerated
+
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
@@ -25,14 +27,15 @@ import (
fields "k8s.io/kubernetes/pkg/fields"
labels "k8s.io/kubernetes/pkg/labels"
runtime "k8s.io/kubernetes/pkg/runtime"
+ types "k8s.io/kubernetes/pkg/types"
intstr "k8s.io/kubernetes/pkg/util/intstr"
- sets "k8s.io/kubernetes/pkg/util/sets"
)
func init() {
if err := Scheme.AddGeneratedDeepCopyFuncs(
DeepCopy_api_AWSElasticBlockStoreVolumeSource,
DeepCopy_api_Affinity,
+ DeepCopy_api_AttachedVolume,
DeepCopy_api_AzureFileVolumeSource,
DeepCopy_api_Binding,
DeepCopy_api_Capabilities,
@@ -115,6 +118,7 @@ func init() {
DeepCopy_api_ObjectFieldSelector,
DeepCopy_api_ObjectMeta,
DeepCopy_api_ObjectReference,
+ DeepCopy_api_OwnerReference,
DeepCopy_api_PersistentVolume,
DeepCopy_api_PersistentVolumeClaim,
DeepCopy_api_PersistentVolumeClaimList,
@@ -126,6 +130,9 @@ func init() {
DeepCopy_api_PersistentVolumeSpec,
DeepCopy_api_PersistentVolumeStatus,
DeepCopy_api_Pod,
+ DeepCopy_api_PodAffinity,
+ DeepCopy_api_PodAffinityTerm,
+ DeepCopy_api_PodAntiAffinity,
DeepCopy_api_PodAttachOptions,
DeepCopy_api_PodCondition,
DeepCopy_api_PodExecOptions,
@@ -139,6 +146,7 @@ func init() {
DeepCopy_api_PodTemplate,
DeepCopy_api_PodTemplateList,
DeepCopy_api_PodTemplateSpec,
+ DeepCopy_api_Preconditions,
DeepCopy_api_PreferredSchedulingTerm,
DeepCopy_api_Probe,
DeepCopy_api_RBDVolumeSource,
@@ -147,6 +155,7 @@ func init() {
DeepCopy_api_ReplicationControllerList,
DeepCopy_api_ReplicationControllerSpec,
DeepCopy_api_ReplicationControllerStatus,
+ DeepCopy_api_ResourceFieldSelector,
DeepCopy_api_ResourceQuota,
DeepCopy_api_ResourceQuotaList,
DeepCopy_api_ResourceQuotaSpec,
@@ -168,19 +177,13 @@ func init() {
DeepCopy_api_ServiceSpec,
DeepCopy_api_ServiceStatus,
DeepCopy_api_TCPSocketAction,
+ DeepCopy_api_Taint,
+ DeepCopy_api_Toleration,
DeepCopy_api_Volume,
DeepCopy_api_VolumeMount,
DeepCopy_api_VolumeSource,
- DeepCopy_conversion_Meta,
- DeepCopy_intstr_IntOrString,
- DeepCopy_sets_Empty,
- DeepCopy_unversioned_GroupKind,
- DeepCopy_unversioned_GroupResource,
- DeepCopy_unversioned_GroupVersion,
- DeepCopy_unversioned_GroupVersionKind,
- DeepCopy_unversioned_GroupVersionResource,
- DeepCopy_unversioned_ListMeta,
- DeepCopy_unversioned_TypeMeta,
+ DeepCopy_api_VsphereVirtualDiskVolumeSource,
+ DeepCopy_api_WeightedPodAffinityTerm,
); err != nil {
// if one of the deep copy functions is malformed, detect it immediately.
panic(err)
@@ -205,6 +208,30 @@ func DeepCopy_api_Affinity(in Affinity, out *Affinity, c *conversion.Cloner) err
} else {
out.NodeAffinity = nil
}
+ if in.PodAffinity != nil {
+ in, out := in.PodAffinity, &out.PodAffinity
+ *out = new(PodAffinity)
+ if err := DeepCopy_api_PodAffinity(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodAffinity = nil
+ }
+ if in.PodAntiAffinity != nil {
+ in, out := in.PodAntiAffinity, &out.PodAntiAffinity
+ *out = new(PodAntiAffinity)
+ if err := DeepCopy_api_PodAntiAffinity(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodAntiAffinity = nil
+ }
+ return nil
+}
+
+func DeepCopy_api_AttachedVolume(in AttachedVolume, out *AttachedVolume, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.DevicePath = in.DevicePath
return nil
}
@@ -216,7 +243,7 @@ func DeepCopy_api_AzureFileVolumeSource(in AzureFileVolumeSource, out *AzureFile
}
func DeepCopy_api_Binding(in Binding, out *Binding, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -290,7 +317,7 @@ func DeepCopy_api_ComponentCondition(in ComponentCondition, out *ComponentCondit
}
func DeepCopy_api_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -311,10 +338,10 @@ func DeepCopy_api_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *c
}
func DeepCopy_api_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -332,7 +359,7 @@ func DeepCopy_api_ComponentStatusList(in ComponentStatusList, out *ComponentStat
}
func DeepCopy_api_ConfigMap(in ConfigMap, out *ConfigMap, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -359,10 +386,10 @@ func DeepCopy_api_ConfigMapKeySelector(in ConfigMapKeySelector, out *ConfigMapKe
}
func DeepCopy_api_ConfigMapList(in ConfigMapList, out *ConfigMapList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -548,10 +575,8 @@ func DeepCopy_api_ContainerState(in ContainerState, out *ContainerState, c *conv
}
func DeepCopy_api_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.StartedAt); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
return err
- } else {
- out.StartedAt = newVal.(unversioned.Time)
}
return nil
}
@@ -561,15 +586,11 @@ func DeepCopy_api_ContainerStateTerminated(in ContainerStateTerminated, out *Con
out.Signal = in.Signal
out.Reason = in.Reason
out.Message = in.Message
- if newVal, err := c.DeepCopy(in.StartedAt); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
return err
- } else {
- out.StartedAt = newVal.(unversioned.Time)
}
- if newVal, err := c.DeepCopy(in.FinishedAt); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.FinishedAt, &out.FinishedAt, c); err != nil {
return err
- } else {
- out.FinishedAt = newVal.(unversioned.Time)
}
out.ContainerID = in.ContainerID
return nil
@@ -598,12 +619,16 @@ func DeepCopy_api_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *c
}
func DeepCopy_api_ConversionError(in ConversionError, out *ConversionError, c *conversion.Cloner) error {
- if newVal, err := c.DeepCopy(in.In); err != nil {
+ if in.In == nil {
+ out.In = nil
+ } else if newVal, err := c.DeepCopy(in.In); err != nil {
return err
} else {
out.In = newVal.(interface{})
}
- if newVal, err := c.DeepCopy(in.Out); err != nil {
+ if in.Out == nil {
+ out.Out = nil
+ } else if newVal, err := c.DeepCopy(in.Out); err != nil {
return err
} else {
out.Out = newVal.(interface{})
@@ -618,7 +643,7 @@ func DeepCopy_api_DaemonEndpoint(in DaemonEndpoint, out *DaemonEndpoint, c *conv
}
func DeepCopy_api_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if in.GracePeriodSeconds != nil {
@@ -628,13 +653,44 @@ func DeepCopy_api_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *convers
} else {
out.GracePeriodSeconds = nil
}
+ if in.Preconditions != nil {
+ in, out := in.Preconditions, &out.Preconditions
+ *out = new(Preconditions)
+ if err := DeepCopy_api_Preconditions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Preconditions = nil
+ }
+ if in.OrphanDependents != nil {
+ in, out := in.OrphanDependents, &out.OrphanDependents
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.OrphanDependents = nil
+ }
return nil
}
func DeepCopy_api_DownwardAPIVolumeFile(in DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, c *conversion.Cloner) error {
out.Path = in.Path
- if err := DeepCopy_api_ObjectFieldSelector(in.FieldRef, &out.FieldRef, c); err != nil {
- return err
+ if in.FieldRef != nil {
+ in, out := in.FieldRef, &out.FieldRef
+ *out = new(ObjectFieldSelector)
+ if err := DeepCopy_api_ObjectFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
+ }
+ if in.ResourceFieldRef != nil {
+ in, out := in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := DeepCopy_api_ResourceFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
}
return nil
}
@@ -661,6 +717,7 @@ func DeepCopy_api_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVol
func DeepCopy_api_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error {
out.IP = in.IP
+ out.Hostname = in.Hostname
if in.TargetRef != nil {
in, out := in.TargetRef, &out.TargetRef
*out = new(ObjectReference)
@@ -718,7 +775,7 @@ func DeepCopy_api_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conv
}
func DeepCopy_api_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -739,10 +796,10 @@ func DeepCopy_api_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner)
}
func DeepCopy_api_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -784,6 +841,15 @@ func DeepCopy_api_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion
} else {
out.FieldRef = nil
}
+ if in.ResourceFieldRef != nil {
+ in, out := in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := DeepCopy_api_ResourceFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
if in.ConfigMapKeyRef != nil {
in, out := in.ConfigMapKeyRef, &out.ConfigMapKeyRef
*out = new(ConfigMapKeySelector)
@@ -806,7 +872,7 @@ func DeepCopy_api_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion
}
func DeepCopy_api_Event(in Event, out *Event, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -820,15 +886,11 @@ func DeepCopy_api_Event(in Event, out *Event, c *conversion.Cloner) error {
if err := DeepCopy_api_EventSource(in.Source, &out.Source, c); err != nil {
return err
}
- if newVal, err := c.DeepCopy(in.FirstTimestamp); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil {
return err
- } else {
- out.FirstTimestamp = newVal.(unversioned.Time)
}
- if newVal, err := c.DeepCopy(in.LastTimestamp); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil {
return err
- } else {
- out.LastTimestamp = newVal.(unversioned.Time)
}
out.Count = in.Count
out.Type = in.Type
@@ -836,10 +898,10 @@ func DeepCopy_api_Event(in Event, out *Event, c *conversion.Cloner) error {
}
func DeepCopy_api_EventList(in EventList, out *EventList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -874,7 +936,7 @@ func DeepCopy_api_ExecAction(in ExecAction, out *ExecAction, c *conversion.Clone
}
func DeepCopy_api_ExportOptions(in ExportOptions, out *ExportOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Export = in.Export
@@ -892,7 +954,7 @@ func DeepCopy_api_FCVolumeSource(in FCVolumeSource, out *FCVolumeSource, c *conv
}
if in.Lun != nil {
in, out := in.Lun, &out.Lun
- *out = new(int)
+ *out = new(int32)
**out = *in
} else {
out.Lun = nil
@@ -956,7 +1018,7 @@ func DeepCopy_api_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *Glusterfs
func DeepCopy_api_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error {
out.Path = in.Path
- if err := DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
return err
}
out.Host = in.Host
@@ -1056,7 +1118,7 @@ func DeepCopy_api_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner)
}
func DeepCopy_api_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1074,11 +1136,11 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
in, out := in.Max, &out.Max
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Max = nil
@@ -1087,11 +1149,11 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
in, out := in.Min, &out.Min
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Min = nil
@@ -1100,11 +1162,11 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
in, out := in.Default, &out.Default
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Default = nil
@@ -1113,11 +1175,11 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
in, out := in.DefaultRequest, &out.DefaultRequest
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.DefaultRequest = nil
@@ -1126,11 +1188,11 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
in, out := in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.MaxLimitRequestRatio = nil
@@ -1139,10 +1201,10 @@ func DeepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conv
}
func DeepCopy_api_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1175,10 +1237,10 @@ func DeepCopy_api_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conv
}
func DeepCopy_api_List(in List, out *List, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1198,15 +1260,19 @@ func DeepCopy_api_List(in List, out *List, c *conversion.Cloner) error {
}
func DeepCopy_api_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if newVal, err := c.DeepCopy(in.LabelSelector); err != nil {
+ if in.LabelSelector == nil {
+ out.LabelSelector = nil
+ } else if newVal, err := c.DeepCopy(in.LabelSelector); err != nil {
return err
} else {
out.LabelSelector = newVal.(labels.Selector)
}
- if newVal, err := c.DeepCopy(in.FieldSelector); err != nil {
+ if in.FieldSelector == nil {
+ out.FieldSelector = nil
+ } else if newVal, err := c.DeepCopy(in.FieldSelector); err != nil {
return err
} else {
out.FieldSelector = newVal.(fields.Selector)
@@ -1257,7 +1323,7 @@ func DeepCopy_api_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *c
}
func DeepCopy_api_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1273,10 +1339,10 @@ func DeepCopy_api_Namespace(in Namespace, out *Namespace, c *conversion.Cloner)
}
func DeepCopy_api_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1312,7 +1378,7 @@ func DeepCopy_api_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *c
}
func DeepCopy_api_Node(in Node, out *Node, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1360,15 +1426,11 @@ func DeepCopy_api_NodeAffinity(in NodeAffinity, out *NodeAffinity, c *conversion
func DeepCopy_api_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error {
out.Type = in.Type
out.Status = in.Status
- if newVal, err := c.DeepCopy(in.LastHeartbeatTime); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil {
return err
- } else {
- out.LastHeartbeatTime = newVal.(unversioned.Time)
}
- if newVal, err := c.DeepCopy(in.LastTransitionTime); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
return err
- } else {
- out.LastTransitionTime = newVal.(unversioned.Time)
}
out.Reason = in.Reason
out.Message = in.Message
@@ -1383,10 +1445,10 @@ func DeepCopy_api_NodeDaemonEndpoints(in NodeDaemonEndpoints, out *NodeDaemonEnd
}
func DeepCopy_api_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1404,7 +1466,7 @@ func DeepCopy_api_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) err
}
func DeepCopy_api_NodeProxyOptions(in NodeProxyOptions, out *NodeProxyOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Path = in.Path
@@ -1416,11 +1478,11 @@ func DeepCopy_api_NodeResources(in NodeResources, out *NodeResources, c *convers
in, out := in.Capacity, &out.Capacity
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Capacity = nil
@@ -1484,11 +1546,11 @@ func DeepCopy_api_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Clone
in, out := in.Capacity, &out.Capacity
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Capacity = nil
@@ -1497,11 +1559,11 @@ func DeepCopy_api_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Clone
in, out := in.Allocatable, &out.Allocatable
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Allocatable = nil
@@ -1546,6 +1608,26 @@ func DeepCopy_api_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Clone
} else {
out.Images = nil
}
+ if in.VolumesInUse != nil {
+ in, out := in.VolumesInUse, &out.VolumesInUse
+ *out = make([]UniqueVolumeName, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.VolumesInUse = nil
+ }
+ if in.VolumesAttached != nil {
+ in, out := in.VolumesAttached, &out.VolumesAttached
+ *out = make([]AttachedVolume, len(in))
+ for i := range in {
+ if err := DeepCopy_api_AttachedVolume(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumesAttached = nil
+ }
return nil
}
@@ -1558,6 +1640,8 @@ func DeepCopy_api_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conv
out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
out.KubeletVersion = in.KubeletVersion
out.KubeProxyVersion = in.KubeProxyVersion
+ out.OperatingSystem = in.OperatingSystem
+ out.Architecture = in.Architecture
return nil
}
@@ -1575,18 +1659,14 @@ func DeepCopy_api_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Clone
out.UID = in.UID
out.ResourceVersion = in.ResourceVersion
out.Generation = in.Generation
- if newVal, err := c.DeepCopy(in.CreationTimestamp); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
return err
- } else {
- out.CreationTimestamp = newVal.(unversioned.Time)
}
if in.DeletionTimestamp != nil {
in, out := in.DeletionTimestamp, &out.DeletionTimestamp
*out = new(unversioned.Time)
- if newVal, err := c.DeepCopy(*in); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
return err
- } else {
- **out = newVal.(unversioned.Time)
}
} else {
out.DeletionTimestamp = nil
@@ -1616,6 +1696,24 @@ func DeepCopy_api_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Clone
} else {
out.Annotations = nil
}
+ if in.OwnerReferences != nil {
+ in, out := in.OwnerReferences, &out.OwnerReferences
+ *out = make([]OwnerReference, len(in))
+ for i := range in {
+ if err := DeepCopy_api_OwnerReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.OwnerReferences = nil
+ }
+ if in.Finalizers != nil {
+ in, out := in.Finalizers, &out.Finalizers
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Finalizers = nil
+ }
return nil
}
@@ -1630,8 +1728,23 @@ func DeepCopy_api_ObjectReference(in ObjectReference, out *ObjectReference, c *c
return nil
}
+func DeepCopy_api_OwnerReference(in OwnerReference, out *OwnerReference, c *conversion.Cloner) error {
+ out.APIVersion = in.APIVersion
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.UID = in.UID
+ if in.Controller != nil {
+ in, out := in.Controller, &out.Controller
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.Controller = nil
+ }
+ return nil
+}
+
func DeepCopy_api_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1647,7 +1760,7 @@ func DeepCopy_api_PersistentVolume(in PersistentVolume, out *PersistentVolume, c
}
func DeepCopy_api_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1663,10 +1776,10 @@ func DeepCopy_api_PersistentVolumeClaim(in PersistentVolumeClaim, out *Persisten
}
func DeepCopy_api_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1693,6 +1806,15 @@ func DeepCopy_api_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *P
} else {
out.AccessModes = nil
}
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
if err := DeepCopy_api_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
return err
}
@@ -1715,11 +1837,11 @@ func DeepCopy_api_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, ou
in, out := in.Capacity, &out.Capacity
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Capacity = nil
@@ -1734,10 +1856,10 @@ func DeepCopy_api_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolu
}
func DeepCopy_api_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -1872,6 +1994,15 @@ func DeepCopy_api_PersistentVolumeSource(in PersistentVolumeSource, out *Persist
} else {
out.AzureFile = nil
}
+ if in.VsphereVolume != nil {
+ in, out := in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := DeepCopy_api_VsphereVirtualDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
return nil
}
@@ -1880,11 +2011,11 @@ func DeepCopy_api_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentV
in, out := in.Capacity, &out.Capacity
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Capacity = nil
@@ -1922,7 +2053,7 @@ func DeepCopy_api_PersistentVolumeStatus(in PersistentVolumeStatus, out *Persist
}
func DeepCopy_api_Pod(in Pod, out *Pod, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -1937,8 +2068,81 @@ func DeepCopy_api_Pod(in Pod, out *Pod, c *conversion.Cloner) error {
return nil
}
+func DeepCopy_api_PodAffinity(in PodAffinity, out *PodAffinity, c *conversion.Cloner) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_api_PodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_api_WeightedPodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func DeepCopy_api_PodAffinityTerm(in PodAffinityTerm, out *PodAffinityTerm, c *conversion.Cloner) error {
+ if in.LabelSelector != nil {
+ in, out := in.LabelSelector, &out.LabelSelector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LabelSelector = nil
+ }
+ if in.Namespaces != nil {
+ in, out := in.Namespaces, &out.Namespaces
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Namespaces = nil
+ }
+ out.TopologyKey = in.TopologyKey
+ return nil
+}
+
+func DeepCopy_api_PodAntiAffinity(in PodAntiAffinity, out *PodAntiAffinity, c *conversion.Cloner) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_api_PodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_api_WeightedPodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
func DeepCopy_api_PodAttachOptions(in PodAttachOptions, out *PodAttachOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Stdin = in.Stdin
@@ -1952,15 +2156,11 @@ func DeepCopy_api_PodAttachOptions(in PodAttachOptions, out *PodAttachOptions, c
func DeepCopy_api_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error {
out.Type = in.Type
out.Status = in.Status
- if newVal, err := c.DeepCopy(in.LastProbeTime); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
return err
- } else {
- out.LastProbeTime = newVal.(unversioned.Time)
}
- if newVal, err := c.DeepCopy(in.LastTransitionTime); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
return err
- } else {
- out.LastTransitionTime = newVal.(unversioned.Time)
}
out.Reason = in.Reason
out.Message = in.Message
@@ -1968,7 +2168,7 @@ func DeepCopy_api_PodCondition(in PodCondition, out *PodCondition, c *conversion
}
func DeepCopy_api_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Stdin = in.Stdin
@@ -1987,10 +2187,10 @@ func DeepCopy_api_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conv
}
func DeepCopy_api_PodList(in PodList, out *PodList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2008,7 +2208,7 @@ func DeepCopy_api_PodList(in PodList, out *PodList, c *conversion.Cloner) error
}
func DeepCopy_api_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Container = in.Container
@@ -2024,10 +2224,8 @@ func DeepCopy_api_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *convers
if in.SinceTime != nil {
in, out := in.SinceTime, &out.SinceTime
*out = new(unversioned.Time)
- if newVal, err := c.DeepCopy(*in); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
return err
- } else {
- **out = newVal.(unversioned.Time)
}
} else {
out.SinceTime = nil
@@ -2051,7 +2249,7 @@ func DeepCopy_api_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *convers
}
func DeepCopy_api_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Path = in.Path
@@ -2114,6 +2312,17 @@ func DeepCopy_api_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error
} else {
out.Volumes = nil
}
+ if in.InitContainers != nil {
+ in, out := in.InitContainers, &out.InitContainers
+ *out = make([]Container, len(in))
+ for i := range in {
+ if err := DeepCopy_api_Container(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainers = nil
+ }
if in.Containers != nil {
in, out := in.Containers, &out.Containers
*out = make([]Container, len(in))
@@ -2172,6 +2381,8 @@ func DeepCopy_api_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error
} else {
out.ImagePullSecrets = nil
}
+ out.Hostname = in.Hostname
+ out.Subdomain = in.Subdomain
return nil
}
@@ -2195,14 +2406,23 @@ func DeepCopy_api_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner)
if in.StartTime != nil {
in, out := in.StartTime, &out.StartTime
*out = new(unversioned.Time)
- if newVal, err := c.DeepCopy(*in); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
return err
- } else {
- **out = newVal.(unversioned.Time)
}
} else {
out.StartTime = nil
}
+ if in.InitContainerStatuses != nil {
+ in, out := in.InitContainerStatuses, &out.InitContainerStatuses
+ *out = make([]ContainerStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_api_ContainerStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainerStatuses = nil
+ }
if in.ContainerStatuses != nil {
in, out := in.ContainerStatuses, &out.ContainerStatuses
*out = make([]ContainerStatus, len(in))
@@ -2218,7 +2438,7 @@ func DeepCopy_api_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner)
}
func DeepCopy_api_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2231,7 +2451,7 @@ func DeepCopy_api_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *c
}
func DeepCopy_api_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2244,10 +2464,10 @@ func DeepCopy_api_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cl
}
func DeepCopy_api_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2274,6 +2494,17 @@ func DeepCopy_api_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *c
return nil
}
+func DeepCopy_api_Preconditions(in Preconditions, out *Preconditions, c *conversion.Cloner) error {
+ if in.UID != nil {
+ in, out := in.UID, &out.UID
+ *out = new(types.UID)
+ **out = *in
+ } else {
+ out.UID = nil
+ }
+ return nil
+}
+
func DeepCopy_api_PreferredSchedulingTerm(in PreferredSchedulingTerm, out *PreferredSchedulingTerm, c *conversion.Cloner) error {
out.Weight = in.Weight
if err := DeepCopy_api_NodeSelectorTerm(in.Preference, &out.Preference, c); err != nil {
@@ -2321,7 +2552,7 @@ func DeepCopy_api_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *c
}
func DeepCopy_api_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2339,7 +2570,7 @@ func DeepCopy_api_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *c
}
func DeepCopy_api_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2355,10 +2586,10 @@ func DeepCopy_api_ReplicationController(in ReplicationController, out *Replicati
}
func DeepCopy_api_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2405,8 +2636,17 @@ func DeepCopy_api_ReplicationControllerStatus(in ReplicationControllerStatus, ou
return nil
}
+func DeepCopy_api_ResourceFieldSelector(in ResourceFieldSelector, out *ResourceFieldSelector, c *conversion.Cloner) error {
+ out.ContainerName = in.ContainerName
+ out.Resource = in.Resource
+ if err := resource.DeepCopy_resource_Quantity(in.Divisor, &out.Divisor, c); err != nil {
+ return err
+ }
+ return nil
+}
+
func DeepCopy_api_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2422,10 +2662,10 @@ func DeepCopy_api_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *convers
}
func DeepCopy_api_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2447,11 +2687,11 @@ func DeepCopy_api_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec
in, out := in.Hard, &out.Hard
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Hard = nil
@@ -2473,11 +2713,11 @@ func DeepCopy_api_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuota
in, out := in.Hard, &out.Hard
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Hard = nil
@@ -2486,11 +2726,11 @@ func DeepCopy_api_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuota
in, out := in.Used, &out.Used
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Used = nil
@@ -2503,11 +2743,11 @@ func DeepCopy_api_ResourceRequirements(in ResourceRequirements, out *ResourceReq
in, out := in.Limits, &out.Limits
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Limits = nil
@@ -2516,11 +2756,11 @@ func DeepCopy_api_ResourceRequirements(in ResourceRequirements, out *ResourceReq
in, out := in.Requests, &out.Requests
*out = make(ResourceList)
for key, val := range in {
- if newVal, err := c.DeepCopy(val); err != nil {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
return err
- } else {
- (*out)[key] = newVal.(resource.Quantity)
}
+ (*out)[key] = *newVal
}
} else {
out.Requests = nil
@@ -2537,7 +2777,7 @@ func DeepCopy_api_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conv
}
func DeepCopy_api_Secret(in Secret, out *Secret, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2569,10 +2809,10 @@ func DeepCopy_api_SecretKeySelector(in SecretKeySelector, out *SecretKeySelector
}
func DeepCopy_api_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2591,6 +2831,17 @@ func DeepCopy_api_SecretList(in SecretList, out *SecretList, c *conversion.Clone
func DeepCopy_api_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error {
out.SecretName = in.SecretName
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]KeyToPath, len(in))
+ for i := range in {
+ if err := DeepCopy_api_KeyToPath(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
return nil
}
@@ -2645,7 +2896,7 @@ func DeepCopy_api_SecurityContext(in SecurityContext, out *SecurityContext, c *c
}
func DeepCopy_api_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectReference(in.Reference, &out.Reference, c); err != nil {
@@ -2655,7 +2906,7 @@ func DeepCopy_api_SerializedReference(in SerializedReference, out *SerializedRef
}
func DeepCopy_api_Service(in Service, out *Service, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2671,7 +2922,7 @@ func DeepCopy_api_Service(in Service, out *Service, c *conversion.Cloner) error
}
func DeepCopy_api_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
if err := DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
@@ -2703,10 +2954,10 @@ func DeepCopy_api_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conv
}
func DeepCopy_api_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2724,10 +2975,10 @@ func DeepCopy_api_ServiceAccountList(in ServiceAccountList, out *ServiceAccountL
}
func DeepCopy_api_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
- if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
return err
}
if in.Items != nil {
@@ -2748,7 +2999,7 @@ func DeepCopy_api_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cl
out.Name = in.Name
out.Protocol = in.Protocol
out.Port = in.Port
- if err := DeepCopy_intstr_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil {
return err
}
out.NodePort = in.NodePort
@@ -2756,7 +3007,7 @@ func DeepCopy_api_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cl
}
func DeepCopy_api_ServiceProxyOptions(in ServiceProxyOptions, out *ServiceProxyOptions, c *conversion.Cloner) error {
- if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Path = in.Path
@@ -2795,6 +3046,13 @@ func DeepCopy_api_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cl
}
out.LoadBalancerIP = in.LoadBalancerIP
out.SessionAffinity = in.SessionAffinity
+ if in.LoadBalancerSourceRanges != nil {
+ in, out := in.LoadBalancerSourceRanges, &out.LoadBalancerSourceRanges
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.LoadBalancerSourceRanges = nil
+ }
return nil
}
@@ -2806,12 +3064,27 @@ func DeepCopy_api_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *convers
}
func DeepCopy_api_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error {
- if err := DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
return err
}
return nil
}
+func DeepCopy_api_Taint(in Taint, out *Taint, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Value = in.Value
+ out.Effect = in.Effect
+ return nil
+}
+
+func DeepCopy_api_Toleration(in Toleration, out *Toleration, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ out.Value = in.Value
+ out.Effect = in.Effect
+ return nil
+}
+
func DeepCopy_api_Volume(in Volume, out *Volume, c *conversion.Cloner) error {
out.Name = in.Name
if err := DeepCopy_api_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
@@ -2824,6 +3097,7 @@ func DeepCopy_api_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cl
out.Name = in.Name
out.ReadOnly = in.ReadOnly
out.MountPath = in.MountPath
+ out.SubPath = in.SubPath
return nil
}
@@ -2999,71 +3273,28 @@ func DeepCopy_api_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion
} else {
out.ConfigMap = nil
}
- return nil
-}
-
-func DeepCopy_conversion_Meta(in conversion.Meta, out *conversion.Meta, c *conversion.Cloner) error {
- out.SrcVersion = in.SrcVersion
- out.DestVersion = in.DestVersion
- if newVal, err := c.DeepCopy(in.KeyNameMapping); err != nil {
- return err
+ if in.VsphereVolume != nil {
+ in, out := in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := DeepCopy_api_VsphereVirtualDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
} else {
- out.KeyNameMapping = newVal.(conversion.FieldMappingFunc)
+ out.VsphereVolume = nil
}
return nil
}
-func DeepCopy_intstr_IntOrString(in intstr.IntOrString, out *intstr.IntOrString, c *conversion.Cloner) error {
- out.Type = in.Type
- out.IntVal = in.IntVal
- out.StrVal = in.StrVal
- return nil
-}
-
-func DeepCopy_sets_Empty(in sets.Empty, out *sets.Empty, c *conversion.Cloner) error {
- return nil
-}
-
-func DeepCopy_unversioned_GroupKind(in unversioned.GroupKind, out *unversioned.GroupKind, c *conversion.Cloner) error {
- out.Group = in.Group
- out.Kind = in.Kind
- return nil
-}
-
-func DeepCopy_unversioned_GroupResource(in unversioned.GroupResource, out *unversioned.GroupResource, c *conversion.Cloner) error {
- out.Group = in.Group
- out.Resource = in.Resource
- return nil
-}
-
-func DeepCopy_unversioned_GroupVersion(in unversioned.GroupVersion, out *unversioned.GroupVersion, c *conversion.Cloner) error {
- out.Group = in.Group
- out.Version = in.Version
- return nil
-}
-
-func DeepCopy_unversioned_GroupVersionKind(in unversioned.GroupVersionKind, out *unversioned.GroupVersionKind, c *conversion.Cloner) error {
- out.Group = in.Group
- out.Version = in.Version
- out.Kind = in.Kind
- return nil
-}
-
-func DeepCopy_unversioned_GroupVersionResource(in unversioned.GroupVersionResource, out *unversioned.GroupVersionResource, c *conversion.Cloner) error {
- out.Group = in.Group
- out.Version = in.Version
- out.Resource = in.Resource
- return nil
-}
-
-func DeepCopy_unversioned_ListMeta(in unversioned.ListMeta, out *unversioned.ListMeta, c *conversion.Cloner) error {
- out.SelfLink = in.SelfLink
- out.ResourceVersion = in.ResourceVersion
+func DeepCopy_api_VsphereVirtualDiskVolumeSource(in VsphereVirtualDiskVolumeSource, out *VsphereVirtualDiskVolumeSource, c *conversion.Cloner) error {
+ out.VolumePath = in.VolumePath
+ out.FSType = in.FSType
return nil
}
-func DeepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
+func DeepCopy_api_WeightedPodAffinityTerm(in WeightedPodAffinityTerm, out *WeightedPodAffinityTerm, c *conversion.Cloner) error {
+ out.Weight = in.Weight
+ if err := DeepCopy_api_PodAffinityTerm(in.PodAffinityTerm, &out.PodAffinityTerm, c); err != nil {
+ return err
+ }
return nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/doc.go b/vendor/k8s.io/kubernetes/pkg/api/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/endpoints/util.go b/vendor/k8s.io/kubernetes/pkg/api/endpoints/util.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/endpoints/util.go
rename to vendor/k8s.io/kubernetes/pkg/api/endpoints/util.go
index 7758434a19d2c138c092189223d4ec8bf5e255ac..501d58f285382e226c484cd450dca981f739bb41 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/endpoints/util.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/endpoints/util.go
@@ -29,11 +29,13 @@ import (
)
const (
+ // TODO: to be deleted after v1.3 is released
// Its value is the json representation of map[string(IP)][HostRecord]
// example: '{"10.245.1.6":{"HostName":"my-webserver"}}'
PodHostnamesAnnotation = "endpoints.beta.kubernetes.io/hostnames-map"
)
+// TODO: to be deleted after v1.3 is released
type HostRecord struct {
HostName string
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/doc.go b/vendor/k8s.io/kubernetes/pkg/api/errors/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/errors/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/errors.go b/vendor/k8s.io/kubernetes/pkg/api/errors/errors.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/errors.go
rename to vendor/k8s.io/kubernetes/pkg/api/errors/errors.go
index a78b7bc240e94c92ce04af1545c8311de4861f7e..89e83c2e3a6c0c5ece9a4756611cfed191070dd9 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/errors.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/errors/errors.go
@@ -93,7 +93,7 @@ func FromObject(obj runtime.Object) error {
}
// NewNotFound returns a new error which indicates that the resource of the kind and the name was not found.
-func NewNotFound(qualifiedResource unversioned.GroupResource, name string) error {
+func NewNotFound(qualifiedResource unversioned.GroupResource, name string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusNotFound,
@@ -108,7 +108,7 @@ func NewNotFound(qualifiedResource unversioned.GroupResource, name string) error
}
// NewAlreadyExists returns an error indicating the item requested exists by that identifier.
-func NewAlreadyExists(qualifiedResource unversioned.GroupResource, name string) error {
+func NewAlreadyExists(qualifiedResource unversioned.GroupResource, name string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusConflict,
@@ -124,7 +124,7 @@ func NewAlreadyExists(qualifiedResource unversioned.GroupResource, name string)
// NewUnauthorized returns an error indicating the client is not authorized to perform the requested
// action.
-func NewUnauthorized(reason string) error {
+func NewUnauthorized(reason string) *StatusError {
message := reason
if len(message) == 0 {
message = "not authorized"
@@ -138,7 +138,7 @@ func NewUnauthorized(reason string) error {
}
// NewForbidden returns an error indicating the requested action was forbidden
-func NewForbidden(qualifiedResource unversioned.GroupResource, name string, err error) error {
+func NewForbidden(qualifiedResource unversioned.GroupResource, name string, err error) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusForbidden,
@@ -153,7 +153,7 @@ func NewForbidden(qualifiedResource unversioned.GroupResource, name string, err
}
// NewConflict returns an error indicating the item can't be updated as provided.
-func NewConflict(qualifiedResource unversioned.GroupResource, name string, err error) error {
+func NewConflict(qualifiedResource unversioned.GroupResource, name string, err error) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusConflict,
@@ -163,12 +163,12 @@ func NewConflict(qualifiedResource unversioned.GroupResource, name string, err e
Kind: qualifiedResource.Resource,
Name: name,
},
- Message: fmt.Sprintf("%s %q cannot be updated: %v", qualifiedResource.String(), name, err),
+ Message: fmt.Sprintf("Operation cannot be fulfilled on %s %q: %v", qualifiedResource.String(), name, err),
}}
}
// NewGone returns an error indicating the item no longer available at the server and no forwarding address is known.
-func NewGone(message string) error {
+func NewGone(message string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusGone,
@@ -178,7 +178,7 @@ func NewGone(message string) error {
}
// NewInvalid returns an error indicating the item is invalid and cannot be processed.
-func NewInvalid(qualifiedKind unversioned.GroupKind, name string, errs field.ErrorList) error {
+func NewInvalid(qualifiedKind unversioned.GroupKind, name string, errs field.ErrorList) *StatusError {
causes := make([]unversioned.StatusCause, 0, len(errs))
for i := range errs {
err := errs[i]
@@ -203,7 +203,7 @@ func NewInvalid(qualifiedKind unversioned.GroupKind, name string, errs field.Err
}
// NewBadRequest creates an error that indicates that the request is invalid and can not be processed.
-func NewBadRequest(reason string) error {
+func NewBadRequest(reason string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusBadRequest,
@@ -213,7 +213,7 @@ func NewBadRequest(reason string) error {
}
// NewServiceUnavailable creates an error that indicates that the requested service is unavailable.
-func NewServiceUnavailable(reason string) error {
+func NewServiceUnavailable(reason string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusServiceUnavailable,
@@ -223,7 +223,7 @@ func NewServiceUnavailable(reason string) error {
}
// NewMethodNotSupported returns an error indicating the requested action is not supported on this kind.
-func NewMethodNotSupported(qualifiedResource unversioned.GroupResource, action string) error {
+func NewMethodNotSupported(qualifiedResource unversioned.GroupResource, action string) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusMethodNotAllowed,
@@ -238,7 +238,7 @@ func NewMethodNotSupported(qualifiedResource unversioned.GroupResource, action s
// NewServerTimeout returns an error indicating the requested action could not be completed due to a
// transient error, and the client should try again.
-func NewServerTimeout(qualifiedResource unversioned.GroupResource, operation string, retryAfterSeconds int) error {
+func NewServerTimeout(qualifiedResource unversioned.GroupResource, operation string, retryAfterSeconds int) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusInternalServerError,
@@ -255,12 +255,12 @@ func NewServerTimeout(qualifiedResource unversioned.GroupResource, operation str
// NewServerTimeoutForKind should not exist. Server timeouts happen when accessing resources, the Kind is just what we
// happened to be looking at when the request failed. This delegates to keep code sane, but we should work towards removing this.
-func NewServerTimeoutForKind(qualifiedKind unversioned.GroupKind, operation string, retryAfterSeconds int) error {
+func NewServerTimeoutForKind(qualifiedKind unversioned.GroupKind, operation string, retryAfterSeconds int) *StatusError {
return NewServerTimeout(unversioned.GroupResource{Group: qualifiedKind.Group, Resource: qualifiedKind.Kind}, operation, retryAfterSeconds)
}
// NewInternalError returns an error indicating the item is invalid and cannot be processed.
-func NewInternalError(err error) error {
+func NewInternalError(err error) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: http.StatusInternalServerError,
@@ -274,7 +274,7 @@ func NewInternalError(err error) error {
// NewTimeoutError returns an error indicating that a timeout occurred before the request
// could be completed. Clients may retry, but the operation may still complete.
-func NewTimeoutError(message string, retryAfterSeconds int) error {
+func NewTimeoutError(message string, retryAfterSeconds int) *StatusError {
return &StatusError{unversioned.Status{
Status: unversioned.StatusFailure,
Code: StatusServerTimeout,
@@ -287,7 +287,7 @@ func NewTimeoutError(message string, retryAfterSeconds int) error {
}
// NewGenericServerResponse returns a new error for server responses that are not in a recognizable form.
-func NewGenericServerResponse(code int, verb string, qualifiedResource unversioned.GroupResource, name, serverMessage string, retryAfterSeconds int, isUnexpectedResponse bool) error {
+func NewGenericServerResponse(code int, verb string, qualifiedResource unversioned.GroupResource, name, serverMessage string, retryAfterSeconds int, isUnexpectedResponse bool) *StatusError {
reason := unversioned.StatusReasonUnknown
message := fmt.Sprintf("the server responded with the status code %d but did not return more information", code)
switch code {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/field_constants.go b/vendor/k8s.io/kubernetes/pkg/api/field_constants.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/field_constants.go
rename to vendor/k8s.io/kubernetes/pkg/api/field_constants.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/generate.go b/vendor/k8s.io/kubernetes/pkg/api/generate.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/generate.go
rename to vendor/k8s.io/kubernetes/pkg/api/generate.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/helpers.go b/vendor/k8s.io/kubernetes/pkg/api/helpers.go
similarity index 74%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/helpers.go
rename to vendor/k8s.io/kubernetes/pkg/api/helpers.go
index aed3c5a7aa3ef81e05165ff65b5f8668eb5bc983..1349ef62b0bbfa788cb41ebb854e3507f91e410b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/helpers.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/helpers.go
@@ -30,6 +30,7 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/types"
"k8s.io/kubernetes/pkg/util/sets"
"github.com/davecgh/go-spew/spew"
@@ -57,16 +58,7 @@ var Semantic = conversion.EqualitiesOrDie(
// TODO: if we decide it's important, it should be safe to start comparing the format.
//
// Uninitialized quantities are equivalent to 0 quantities.
- if a.Amount == nil && b.MilliValue() == 0 {
- return true
- }
- if b.Amount == nil && a.MilliValue() == 0 {
- return true
- }
- if a.Amount == nil || b.Amount == nil {
- return false
- }
- return a.Amount.Cmp(b.Amount) == 0
+ return a.Cmp(b) == 0
},
func(a, b unversioned.Time) bool {
return a.UTC() == b.UTC()
@@ -151,6 +143,8 @@ var standardQuotaResources = sets.NewString(
string(ResourceSecrets),
string(ResourcePersistentVolumeClaims),
string(ResourceConfigMaps),
+ string(ResourceServicesNodePorts),
+ string(ResourceServicesLoadBalancers),
)
// IsStandardQuotaResourceName returns true if the resource is known to
@@ -189,6 +183,8 @@ var integerResources = sets.NewString(
string(ResourceSecrets),
string(ResourceConfigMaps),
string(ResourcePersistentVolumeClaims),
+ string(ResourceServicesNodePorts),
+ string(ResourceServicesLoadBalancers),
)
// IsIntegerResourceName returns true if the resource is measured in integer values
@@ -204,6 +200,19 @@ func NewDeleteOptions(grace int64) *DeleteOptions {
return &DeleteOptions{GracePeriodSeconds: &grace}
}
+// NewPreconditionDeleteOptions returns a DeleteOptions with a UID precondition set.
+func NewPreconditionDeleteOptions(uid string) *DeleteOptions {
+ u := types.UID(uid)
+ p := Preconditions{UID: &u}
+ return &DeleteOptions{Preconditions: &p}
+}
+
+// NewUIDPreconditions returns a Preconditions with UID set.
+func NewUIDPreconditions(uid string) *Preconditions {
+ u := types.UID(uid)
+ return &Preconditions{UID: &u}
+}
+
// this function aims to check if the service's ClusterIP is set or not
// the objective is not to perform validation here
func IsServiceIPSet(service *Service) bool {
@@ -216,12 +225,22 @@ func IsServiceIPRequested(service *Service) bool {
}
var standardFinalizers = sets.NewString(
- string(FinalizerKubernetes))
+ string(FinalizerKubernetes),
+ FinalizerOrphan,
+)
func IsStandardFinalizerName(str string) bool {
return standardFinalizers.Has(str)
}
+// SingleObject returns a ListOptions for watching a single object.
+func SingleObject(meta ObjectMeta) ListOptions {
+ return ListOptions{
+ FieldSelector: fields.OneTermEqualSelector("metadata.name", meta.Name),
+ ResourceVersion: meta.ResourceVersion,
+ }
+}
+
// AddToNodeAddresses appends the NodeAddresses to the passed-by-pointer slice,
// only if they do not already exist
func AddToNodeAddresses(addresses *[]NodeAddress, addAddresses ...NodeAddress) {
@@ -342,13 +361,13 @@ func containsAccessMode(modes []PersistentVolumeAccessMode, mode PersistentVolum
// ParseRFC3339 parses an RFC3339 date in either RFC3339Nano or RFC3339 format.
func ParseRFC3339(s string, nowFn func() unversioned.Time) (unversioned.Time, error) {
if t, timeErr := time.Parse(time.RFC3339Nano, s); timeErr == nil {
- return unversioned.Time{t}, nil
+ return unversioned.Time{Time: t}, nil
}
t, err := time.Parse(time.RFC3339, s)
if err != nil {
return unversioned.Time{}, err
}
- return unversioned.Time{t}, nil
+ return unversioned.Time{Time: t}, nil
}
// NodeSelectorRequirementsAsSelector converts the []NodeSelectorRequirement api type into a struct that implements
@@ -385,9 +404,27 @@ func NodeSelectorRequirementsAsSelector(nsm []NodeSelectorRequirement) (labels.S
return selector, nil
}
-// AffinityAnnotationKey represents the key of affinity data (json serialized)
-// in the Annotations of a Pod.
-const AffinityAnnotationKey string = "scheduler.alpha.kubernetes.io/affinity"
+const (
+ // AffinityAnnotationKey represents the key of affinity data (json serialized)
+ // in the Annotations of a Pod.
+ AffinityAnnotationKey string = "scheduler.alpha.kubernetes.io/affinity"
+
+ // TolerationsAnnotationKey represents the key of tolerations data (json serialized)
+ // in the Annotations of a Pod.
+ TolerationsAnnotationKey string = "scheduler.alpha.kubernetes.io/tolerations"
+
+ // TaintsAnnotationKey represents the key of taints data (json serialized)
+ // in the Annotations of a Node.
+ TaintsAnnotationKey string = "scheduler.alpha.kubernetes.io/taints"
+
+ // SeccompPodAnnotationKey represents the key of a seccomp profile applied
+ // to all containers of a pod.
+ SeccompPodAnnotationKey string = "seccomp.security.alpha.kubernetes.io/pod"
+
+ // SeccompContainerAnnotationKeyPrefix represents the key of a seccomp profile applied
+ // to one container of a pod.
+ SeccompContainerAnnotationKeyPrefix string = "container.seccomp.security.alpha.kubernetes.io/"
+)
// GetAffinityFromPod gets the json serialized affinity data from Pod.Annotations
// and converts it to the Affinity type in api.
@@ -401,3 +438,61 @@ func GetAffinityFromPodAnnotations(annotations map[string]string) (Affinity, err
}
return affinity, nil
}
+
+// GetTolerationsFromPodAnnotations gets the json serialized tolerations data from Pod.Annotations
+// and converts it to the []Toleration type in api.
+func GetTolerationsFromPodAnnotations(annotations map[string]string) ([]Toleration, error) {
+ var tolerations []Toleration
+ if len(annotations) > 0 && annotations[TolerationsAnnotationKey] != "" {
+ err := json.Unmarshal([]byte(annotations[TolerationsAnnotationKey]), &tolerations)
+ if err != nil {
+ return tolerations, err
+ }
+ }
+ return tolerations, nil
+}
+
+// GetTaintsFromNodeAnnotations gets the json serialized taints data from Pod.Annotations
+// and converts it to the []Taint type in api.
+func GetTaintsFromNodeAnnotations(annotations map[string]string) ([]Taint, error) {
+ var taints []Taint
+ if len(annotations) > 0 && annotations[TaintsAnnotationKey] != "" {
+ err := json.Unmarshal([]byte(annotations[TaintsAnnotationKey]), &taints)
+ if err != nil {
+ return []Taint{}, err
+ }
+ }
+ return taints, nil
+}
+
+// TolerationToleratesTaint checks if the toleration tolerates the taint.
+func TolerationToleratesTaint(toleration Toleration, taint Taint) bool {
+ if len(toleration.Effect) != 0 && toleration.Effect != taint.Effect {
+ return false
+ }
+
+ if toleration.Key != taint.Key {
+ return false
+ }
+ // TODO: Use proper defaulting when Toleration becomes a field of PodSpec
+ if (len(toleration.Operator) == 0 || toleration.Operator == TolerationOpEqual) && toleration.Value == taint.Value {
+ return true
+ }
+ if toleration.Operator == TolerationOpExists {
+ return true
+ }
+ return false
+
+}
+
+// TaintToleratedByTolerations checks if taint is tolerated by any of the tolerations.
+func TaintToleratedByTolerations(taint Taint, tolerations []Toleration) bool {
+ tolerated := false
+ for _, toleration := range tolerations {
+ if TolerationToleratesTaint(toleration, taint) {
+ tolerated = true
+ break
+ }
+ }
+ return tolerated
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/install/install.go b/vendor/k8s.io/kubernetes/pkg/api/install/install.go
new file mode 100644
index 0000000000000000000000000000000000000000..bed5f0791abf0cfd675d700a7de0e8ffdff7574b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/install/install.go
@@ -0,0 +1,251 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 install installs the v1 monolithic api, making it available as an
+// option to all of the API encoding/decoding machinery.
+package install
+
+import (
+ "fmt"
+
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apimachinery"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/sets"
+ "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+const importPrefix = "k8s.io/kubernetes/pkg/api"
+
+var accessor = meta.NewAccessor()
+
+// availableVersions lists all known external versions for this group from most preferred to least preferred
+var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
+
+func init() {
+ registered.RegisterVersions(availableVersions)
+ externalVersions := []unversioned.GroupVersion{}
+ for _, v := range availableVersions {
+ if registered.IsAllowedVersion(v) {
+ externalVersions = append(externalVersions, v)
+ }
+ }
+ if len(externalVersions) == 0 {
+ glog.V(4).Infof("No version is registered for group %v", api.GroupName)
+ return
+ }
+
+ if err := registered.EnableVersions(externalVersions...); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+ if err := enableVersions(externalVersions); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+}
+
+// TODO: enableVersions should be centralized rather than spread in each API
+// group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+ addVersionsToScheme(externalVersions...)
+ preferredExternalVersion := externalVersions[0]
+
+ groupMeta := apimachinery.GroupMeta{
+ GroupVersion: preferredExternalVersion,
+ GroupVersions: externalVersions,
+ RESTMapper: newRESTMapper(externalVersions),
+ SelfLinker: runtime.SelfLinker(accessor),
+ InterfacesFor: interfacesFor,
+ }
+
+ if err := registered.RegisterGroup(groupMeta); err != nil {
+ return err
+ }
+ api.RegisterRESTMapper(groupMeta.RESTMapper)
+ return nil
+}
+
+// userResources is a group of resources mostly used by a kubectl user
+var userResources = []string{"rc", "svc", "pods", "pvc"}
+
+func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
+ // the list of kinds that are scoped at the root of the api hierarchy
+ // if a kind is not enumerated here, it is assumed to have a namespace scope
+ rootScoped := sets.NewString(
+ "Node",
+ "Namespace",
+ "PersistentVolume",
+ "ComponentStatus",
+ )
+
+ // these kinds should be excluded from the list of resources
+ ignoredKinds := sets.NewString(
+ "ListOptions",
+ "DeleteOptions",
+ "Status",
+ "PodLogOptions",
+ "PodExecOptions",
+ "PodAttachOptions",
+ "PodProxyOptions",
+ "NodeProxyOptions",
+ "ServiceProxyOptions",
+ "ThirdPartyResource",
+ "ThirdPartyResourceData",
+ "ThirdPartyResourceList")
+
+ mapper := api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
+ // setup aliases for groups of resources
+ mapper.AddResourceAlias("all", userResources...)
+
+ return mapper
+}
+
+// InterfacesFor returns the default Codec and ResourceVersioner for a given version
+// string, or an error if the version is not known.
+func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+ switch version {
+ case v1.SchemeGroupVersion:
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: accessor,
+ }, nil
+ default:
+ g, _ := registered.Group(api.GroupName)
+ return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+ }
+}
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+ // add the internal version to Scheme
+ api.AddToScheme(api.Scheme)
+ // add the enabled external versions to Scheme
+ for _, v := range externalVersions {
+ if !registered.IsEnabledVersion(v) {
+ glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+ continue
+ }
+ switch v {
+ case v1.SchemeGroupVersion:
+ v1.AddToScheme(api.Scheme)
+ }
+ }
+
+ // This is a "fast-path" that avoids reflection for common types. It focuses on the objects that are
+ // converted the most in the cluster.
+ // TODO: generate one of these for every external API group - this is to prove the impact
+ api.Scheme.AddGenericConversionFunc(func(objA, objB interface{}, s conversion.Scope) (bool, error) {
+ switch a := objA.(type) {
+ case *v1.Pod:
+ switch b := objB.(type) {
+ case *api.Pod:
+ return true, v1.Convert_v1_Pod_To_api_Pod(a, b, s)
+ }
+ case *api.Pod:
+ switch b := objB.(type) {
+ case *v1.Pod:
+ return true, v1.Convert_api_Pod_To_v1_Pod(a, b, s)
+ }
+
+ case *v1.Event:
+ switch b := objB.(type) {
+ case *api.Event:
+ return true, v1.Convert_v1_Event_To_api_Event(a, b, s)
+ }
+ case *api.Event:
+ switch b := objB.(type) {
+ case *v1.Event:
+ return true, v1.Convert_api_Event_To_v1_Event(a, b, s)
+ }
+
+ case *v1.ReplicationController:
+ switch b := objB.(type) {
+ case *api.ReplicationController:
+ return true, v1.Convert_v1_ReplicationController_To_api_ReplicationController(a, b, s)
+ }
+ case *api.ReplicationController:
+ switch b := objB.(type) {
+ case *v1.ReplicationController:
+ return true, v1.Convert_api_ReplicationController_To_v1_ReplicationController(a, b, s)
+ }
+
+ case *v1.Node:
+ switch b := objB.(type) {
+ case *api.Node:
+ return true, v1.Convert_v1_Node_To_api_Node(a, b, s)
+ }
+ case *api.Node:
+ switch b := objB.(type) {
+ case *v1.Node:
+ return true, v1.Convert_api_Node_To_v1_Node(a, b, s)
+ }
+
+ case *v1.Namespace:
+ switch b := objB.(type) {
+ case *api.Namespace:
+ return true, v1.Convert_v1_Namespace_To_api_Namespace(a, b, s)
+ }
+ case *api.Namespace:
+ switch b := objB.(type) {
+ case *v1.Namespace:
+ return true, v1.Convert_api_Namespace_To_v1_Namespace(a, b, s)
+ }
+
+ case *v1.Service:
+ switch b := objB.(type) {
+ case *api.Service:
+ return true, v1.Convert_v1_Service_To_api_Service(a, b, s)
+ }
+ case *api.Service:
+ switch b := objB.(type) {
+ case *v1.Service:
+ return true, v1.Convert_api_Service_To_v1_Service(a, b, s)
+ }
+
+ case *v1.Endpoints:
+ switch b := objB.(type) {
+ case *api.Endpoints:
+ return true, v1.Convert_v1_Endpoints_To_api_Endpoints(a, b, s)
+ }
+ case *api.Endpoints:
+ switch b := objB.(type) {
+ case *v1.Endpoints:
+ return true, v1.Convert_api_Endpoints_To_v1_Endpoints(a, b, s)
+ }
+
+ case *versioned.Event:
+ switch b := objB.(type) {
+ case *versioned.InternalEvent:
+ return true, versioned.Convert_versioned_Event_to_versioned_InternalEvent(a, b, s)
+ }
+ case *versioned.InternalEvent:
+ switch b := objB.(type) {
+ case *versioned.Event:
+ return true, versioned.Convert_versioned_InternalEvent_to_versioned_Event(a, b, s)
+ }
+ }
+ return false, nil
+ })
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/mapper.go b/vendor/k8s.io/kubernetes/pkg/api/mapper.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/mapper.go
rename to vendor/k8s.io/kubernetes/pkg/api/mapper.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta.go b/vendor/k8s.io/kubernetes/pkg/api/meta.go
similarity index 59%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta.go
index ec84c3c8a92faecbff1d610dbd85746b1521ad5b..9d5dae2c595159e1e4a1be655999f4f5bc34eeb4 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta.go
@@ -17,6 +17,8 @@ limitations under the License.
package api
import (
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/meta/metatypes"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime"
@@ -39,6 +41,7 @@ func HasObjectMetaSystemFieldValues(meta *ObjectMeta) bool {
// ObjectMetaFor returns a pointer to a provided object's ObjectMeta.
// TODO: allow runtime.Unknown to extract this object
+// TODO: Remove this function and use meta.Accessor() instead.
func ObjectMetaFor(obj runtime.Object) (*ObjectMeta, error) {
v, err := conversion.EnforcePtr(obj)
if err != nil {
@@ -62,21 +65,65 @@ func ListMetaFor(obj runtime.Object) (*unversioned.ListMeta, error) {
return meta, err
}
+func (obj *ObjectMeta) GetObjectMeta() meta.Object { return obj }
+
+func (obj *ObjectReference) GetObjectKind() unversioned.ObjectKind { return obj }
+
// Namespace implements meta.Object for any object with an ObjectMeta typed field. Allows
// fast, direct access to metadata fields for API objects.
-func (meta *ObjectMeta) GetNamespace() string { return meta.Namespace }
-func (meta *ObjectMeta) SetNamespace(namespace string) { meta.Namespace = namespace }
-func (meta *ObjectMeta) GetName() string { return meta.Name }
-func (meta *ObjectMeta) SetName(name string) { meta.Name = name }
-func (meta *ObjectMeta) GetGenerateName() string { return meta.GenerateName }
-func (meta *ObjectMeta) SetGenerateName(generateName string) { meta.GenerateName = generateName }
-func (meta *ObjectMeta) GetUID() types.UID { return meta.UID }
-func (meta *ObjectMeta) SetUID(uid types.UID) { meta.UID = uid }
-func (meta *ObjectMeta) GetResourceVersion() string { return meta.ResourceVersion }
-func (meta *ObjectMeta) SetResourceVersion(version string) { meta.ResourceVersion = version }
-func (meta *ObjectMeta) GetSelfLink() string { return meta.SelfLink }
-func (meta *ObjectMeta) SetSelfLink(selfLink string) { meta.SelfLink = selfLink }
+func (meta *ObjectMeta) GetNamespace() string { return meta.Namespace }
+func (meta *ObjectMeta) SetNamespace(namespace string) { meta.Namespace = namespace }
+func (meta *ObjectMeta) GetName() string { return meta.Name }
+func (meta *ObjectMeta) SetName(name string) { meta.Name = name }
+func (meta *ObjectMeta) GetGenerateName() string { return meta.GenerateName }
+func (meta *ObjectMeta) SetGenerateName(generateName string) { meta.GenerateName = generateName }
+func (meta *ObjectMeta) GetUID() types.UID { return meta.UID }
+func (meta *ObjectMeta) SetUID(uid types.UID) { meta.UID = uid }
+func (meta *ObjectMeta) GetResourceVersion() string { return meta.ResourceVersion }
+func (meta *ObjectMeta) SetResourceVersion(version string) { meta.ResourceVersion = version }
+func (meta *ObjectMeta) GetSelfLink() string { return meta.SelfLink }
+func (meta *ObjectMeta) SetSelfLink(selfLink string) { meta.SelfLink = selfLink }
+func (meta *ObjectMeta) GetCreationTimestamp() unversioned.Time { return meta.CreationTimestamp }
+func (meta *ObjectMeta) SetCreationTimestamp(creationTimestamp unversioned.Time) {
+ meta.CreationTimestamp = creationTimestamp
+}
+func (meta *ObjectMeta) GetDeletionTimestamp() *unversioned.Time { return meta.DeletionTimestamp }
+func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *unversioned.Time) {
+ meta.DeletionTimestamp = deletionTimestamp
+}
func (meta *ObjectMeta) GetLabels() map[string]string { return meta.Labels }
func (meta *ObjectMeta) SetLabels(labels map[string]string) { meta.Labels = labels }
func (meta *ObjectMeta) GetAnnotations() map[string]string { return meta.Annotations }
func (meta *ObjectMeta) SetAnnotations(annotations map[string]string) { meta.Annotations = annotations }
+func (meta *ObjectMeta) GetFinalizers() []string { return meta.Finalizers }
+func (meta *ObjectMeta) SetFinalizers(finalizers []string) { meta.Finalizers = finalizers }
+
+func (meta *ObjectMeta) GetOwnerReferences() []metatypes.OwnerReference {
+ ret := make([]metatypes.OwnerReference, len(meta.OwnerReferences))
+ for i := 0; i < len(meta.OwnerReferences); i++ {
+ ret[i].Kind = meta.OwnerReferences[i].Kind
+ ret[i].Name = meta.OwnerReferences[i].Name
+ ret[i].UID = meta.OwnerReferences[i].UID
+ ret[i].APIVersion = meta.OwnerReferences[i].APIVersion
+ if meta.OwnerReferences[i].Controller != nil {
+ value := *meta.OwnerReferences[i].Controller
+ ret[i].Controller = &value
+ }
+ }
+ return ret
+}
+
+func (meta *ObjectMeta) SetOwnerReferences(references []metatypes.OwnerReference) {
+ newReferences := make([]OwnerReference, len(references))
+ for i := 0; i < len(references); i++ {
+ newReferences[i].Kind = references[i].Kind
+ newReferences[i].Name = references[i].Name
+ newReferences[i].UID = references[i].UID
+ newReferences[i].APIVersion = references[i].APIVersion
+ if references[i].Controller != nil {
+ value := *references[i].Controller
+ newReferences[i].Controller = &value
+ }
+ }
+ meta.OwnerReferences = newReferences
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/doc.go b/vendor/k8s.io/kubernetes/pkg/api/meta/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/errors.go b/vendor/k8s.io/kubernetes/pkg/api/meta/errors.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/errors.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/errors.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/help.go b/vendor/k8s.io/kubernetes/pkg/api/meta/help.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/help.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/help.go
index 7d1570bc202fe4f986f7a7b4a4980b2edfc847d7..cdc07930fe8390e977e450495bcf19cb2924d96d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/help.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/help.go
@@ -76,8 +76,9 @@ func ExtractList(obj runtime.Object) ([]runtime.Object, error) {
switch {
case item.Object != nil:
list[i] = item.Object
- case item.RawJSON != nil:
- list[i] = &runtime.Unknown{RawJSON: item.RawJSON}
+ case item.Raw != nil:
+ // TODO: Set ContentEncoding and ContentType correctly.
+ list[i] = &runtime.Unknown{Raw: item.Raw}
default:
list[i] = nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/interfaces.go b/vendor/k8s.io/kubernetes/pkg/api/meta/interfaces.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/interfaces.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/interfaces.go
index f1402e7ad79e3d660834c1fb99884ea8705c7ae9..286bdc0dd732aef4fd3652db92a872d37ff80327 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/interfaces.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/interfaces.go
@@ -17,6 +17,7 @@ limitations under the License.
package meta
import (
+ "k8s.io/kubernetes/pkg/api/meta/metatypes"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/types"
@@ -49,29 +50,33 @@ type Object interface {
SetResourceVersion(version string)
GetSelfLink() string
SetSelfLink(selfLink string)
+ GetCreationTimestamp() unversioned.Time
+ SetCreationTimestamp(timestamp unversioned.Time)
+ GetDeletionTimestamp() *unversioned.Time
+ SetDeletionTimestamp(timestamp *unversioned.Time)
GetLabels() map[string]string
SetLabels(labels map[string]string)
GetAnnotations() map[string]string
SetAnnotations(annotations map[string]string)
+ GetFinalizers() []string
+ SetFinalizers(finalizers []string)
+ GetOwnerReferences() []metatypes.OwnerReference
+ SetOwnerReferences([]metatypes.OwnerReference)
+}
+
+var _ Object = &runtime.Unstructured{}
+
+type ListMetaAccessor interface {
+ GetListMeta() List
}
// List lets you work with list metadata from any of the versioned or
// internal API objects. Attempting to set or retrieve a field on an object that does
// not support that field will be a no-op and return a default value.
-type List interface {
- GetResourceVersion() string
- SetResourceVersion(version string)
- GetSelfLink() string
- SetSelfLink(selfLink string)
-}
+type List unversioned.List
// Type exposes the type and APIVersion of versioned or internal API objects.
-type Type interface {
- GetAPIVersion() string
- SetAPIVersion(version string)
- GetKind() string
- SetKind(kind string)
-}
+type Type unversioned.Type
// MetadataAccessor lets you work with object and list metadata from any of the versioned or
// internal API objects. Attempting to set or retrieve a field on an object that does
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/meta.go b/vendor/k8s.io/kubernetes/pkg/api/meta/meta.go
similarity index 67%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/meta.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/meta.go
index bf11abd18703f714f43419c01bf0002e1a54352f..5f185f39f39556a321164c8e76d1739bf441c76c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/meta.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/meta.go
@@ -20,26 +20,70 @@ import (
"fmt"
"reflect"
+ "k8s.io/kubernetes/pkg/api/meta/metatypes"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/types"
+
+ "github.com/golang/glog"
)
+func ListAccessor(obj interface{}) (List, error) {
+ if listMetaAccessor, ok := obj.(ListMetaAccessor); ok {
+ if om := listMetaAccessor.GetListMeta(); om != nil {
+ return om, nil
+ }
+ }
+ if listMetaAccessor, ok := obj.(unversioned.ListMetaAccessor); ok {
+ if om := listMetaAccessor.GetListMeta(); om != nil {
+ return om, nil
+ }
+ }
+ // we may get passed an object that is directly portable to List
+ if list, ok := obj.(List); ok {
+ return list, nil
+ }
+ glog.V(4).Infof("Calling ListAccessor on non-internal object: %v", reflect.TypeOf(obj))
+ // legacy path for objects that do not implement List and ListMetaAccessor via
+ // reflection - very slow code path.
+ v, err := conversion.EnforcePtr(obj)
+ if err != nil {
+ return nil, err
+ }
+ t := v.Type()
+ if v.Kind() != reflect.Struct {
+ return nil, fmt.Errorf("expected struct, but got %v: %v (%#v)", v.Kind(), t, v.Interface())
+ }
+ a := &genericAccessor{}
+ listMeta := v.FieldByName("ListMeta")
+ if listMeta.IsValid() {
+ // look for the ListMeta fields
+ if err := extractFromListMeta(listMeta, a); err != nil {
+ return nil, fmt.Errorf("unable to find list fields on %#v: %v", listMeta, err)
+ }
+ } else {
+ return nil, fmt.Errorf("unable to find listMeta on %#v", v)
+ }
+ return a, nil
+}
+
// Accessor takes an arbitrary object pointer and returns meta.Interface.
// obj must be a pointer to an API type. An error is returned if the minimum
// required fields are missing. Fields that are not required return the default
// value and are a no-op if set.
func Accessor(obj interface{}) (Object, error) {
- if oi, ok := obj.(ObjectMetaAccessor); ok {
- if om := oi.GetObjectMeta(); om != nil {
+ if objectMetaAccessor, ok := obj.(ObjectMetaAccessor); ok {
+ if om := objectMetaAccessor.GetObjectMeta(); om != nil {
return om, nil
}
}
// we may get passed an object that is directly portable to Object
- if oi, ok := obj.(Object); ok {
- return oi, nil
+ if object, ok := obj.(Object); ok {
+ return object, nil
}
+
+ glog.V(4).Infof("Calling Accessor on non-internal object: %v", reflect.TypeOf(obj))
// legacy path for objects that do not implement Object and ObjectMetaAccessor via
// reflection - very slow code path.
v, err := conversion.EnforcePtr(obj)
@@ -119,33 +163,21 @@ type objectAccessor struct {
}
func (obj objectAccessor) GetKind() string {
- if gvk := obj.GetObjectKind().GroupVersionKind(); gvk != nil {
- return gvk.Kind
- }
- return ""
+ return obj.GetObjectKind().GroupVersionKind().Kind
}
func (obj objectAccessor) SetKind(kind string) {
gvk := obj.GetObjectKind().GroupVersionKind()
- if gvk == nil {
- gvk = &unversioned.GroupVersionKind{}
- }
gvk.Kind = kind
obj.GetObjectKind().SetGroupVersionKind(gvk)
}
func (obj objectAccessor) GetAPIVersion() string {
- if gvk := obj.GetObjectKind().GroupVersionKind(); gvk != nil {
- return gvk.GroupVersion().String()
- }
- return ""
+ return obj.GetObjectKind().GroupVersionKind().GroupVersion().String()
}
func (obj objectAccessor) SetAPIVersion(version string) {
gvk := obj.GetObjectKind().GroupVersionKind()
- if gvk == nil {
- gvk = &unversioned.GroupVersionKind{}
- }
gv, err := unversioned.ParseGroupVersion(version)
if err != nil {
gv = unversioned.GroupVersion{Version: version}
@@ -318,19 +350,71 @@ func (resourceAccessor) SetResourceVersion(obj runtime.Object, version string) e
return nil
}
+// extractFromOwnerReference extracts v to o. v is the OwnerReferences field of an object.
+func extractFromOwnerReference(v reflect.Value, o *metatypes.OwnerReference) error {
+ if err := runtime.Field(v, "APIVersion", &o.APIVersion); err != nil {
+ return err
+ }
+ if err := runtime.Field(v, "Kind", &o.Kind); err != nil {
+ return err
+ }
+ if err := runtime.Field(v, "Name", &o.Name); err != nil {
+ return err
+ }
+ if err := runtime.Field(v, "UID", &o.UID); err != nil {
+ return err
+ }
+ var controllerPtr *bool
+ if err := runtime.Field(v, "Controller", &controllerPtr); err != nil {
+ return err
+ }
+ if controllerPtr != nil {
+ controller := *controllerPtr
+ o.Controller = &controller
+ }
+ return nil
+}
+
+// setOwnerReference sets v to o. v is the OwnerReferences field of an object.
+func setOwnerReference(v reflect.Value, o *metatypes.OwnerReference) error {
+ if err := runtime.SetField(o.APIVersion, v, "APIVersion"); err != nil {
+ return err
+ }
+ if err := runtime.SetField(o.Kind, v, "Kind"); err != nil {
+ return err
+ }
+ if err := runtime.SetField(o.Name, v, "Name"); err != nil {
+ return err
+ }
+ if err := runtime.SetField(o.UID, v, "UID"); err != nil {
+ return err
+ }
+ if o.Controller != nil {
+ controller := *(o.Controller)
+ if err := runtime.SetField(&controller, v, "Controller"); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
// genericAccessor contains pointers to strings that can modify an arbitrary
// struct and implements the Accessor interface.
type genericAccessor struct {
- namespace *string
- name *string
- generateName *string
- uid *types.UID
- apiVersion *string
- kind *string
- resourceVersion *string
- selfLink *string
- labels *map[string]string
- annotations *map[string]string
+ namespace *string
+ name *string
+ generateName *string
+ uid *types.UID
+ apiVersion *string
+ kind *string
+ resourceVersion *string
+ selfLink *string
+ creationTimestamp *unversioned.Time
+ deletionTimestamp **unversioned.Time
+ labels *map[string]string
+ annotations *map[string]string
+ ownerReferences reflect.Value
+ finalizers *[]string
}
func (a genericAccessor) GetNamespace() string {
@@ -421,6 +505,22 @@ func (a genericAccessor) SetSelfLink(selfLink string) {
*a.selfLink = selfLink
}
+func (a genericAccessor) GetCreationTimestamp() unversioned.Time {
+ return *a.creationTimestamp
+}
+
+func (a genericAccessor) SetCreationTimestamp(timestamp unversioned.Time) {
+ *a.creationTimestamp = timestamp
+}
+
+func (a genericAccessor) GetDeletionTimestamp() *unversioned.Time {
+ return *a.deletionTimestamp
+}
+
+func (a genericAccessor) SetDeletionTimestamp(timestamp *unversioned.Time) {
+ *a.deletionTimestamp = timestamp
+}
+
func (a genericAccessor) GetLabels() map[string]string {
if a.labels == nil {
return nil
@@ -447,6 +547,52 @@ func (a genericAccessor) SetAnnotations(annotations map[string]string) {
*a.annotations = annotations
}
+func (a genericAccessor) GetFinalizers() []string {
+ if a.finalizers == nil {
+ return nil
+ }
+ return *a.finalizers
+}
+
+func (a genericAccessor) SetFinalizers(finalizers []string) {
+ *a.finalizers = finalizers
+}
+
+func (a genericAccessor) GetOwnerReferences() []metatypes.OwnerReference {
+ var ret []metatypes.OwnerReference
+ s := a.ownerReferences
+ if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice {
+ glog.Errorf("expect %v to be a pointer to slice", s)
+ return ret
+ }
+ s = s.Elem()
+ // Set the capacity to one element greater to avoid copy if the caller later append an element.
+ ret = make([]metatypes.OwnerReference, s.Len(), s.Len()+1)
+ for i := 0; i < s.Len(); i++ {
+ if err := extractFromOwnerReference(s.Index(i), &ret[i]); err != nil {
+ glog.Errorf("extractFromOwnerReference failed: %v", err)
+ return ret
+ }
+ }
+ return ret
+}
+
+func (a genericAccessor) SetOwnerReferences(references []metatypes.OwnerReference) {
+ s := a.ownerReferences
+ if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice {
+ glog.Errorf("expect %v to be a pointer to slice", s)
+ }
+ s = s.Elem()
+ newReferences := reflect.MakeSlice(s.Type(), len(references), len(references))
+ for i := 0; i < len(references); i++ {
+ if err := setOwnerReference(newReferences.Index(i), &references[i]); err != nil {
+ glog.Errorf("setOwnerReference failed: %v", err)
+ return
+ }
+ }
+ s.Set(newReferences)
+}
+
// extractFromTypeMeta extracts pointers to version and kind fields from an object
func extractFromTypeMeta(v reflect.Value, a *genericAccessor) error {
if err := runtime.FieldPtr(v, "APIVersion", &a.apiVersion); err != nil {
@@ -484,6 +630,17 @@ func extractFromObjectMeta(v reflect.Value, a *genericAccessor) error {
if err := runtime.FieldPtr(v, "Annotations", &a.annotations); err != nil {
return err
}
+ if err := runtime.FieldPtr(v, "Finalizers", &a.finalizers); err != nil {
+ return err
+ }
+ ownerReferences := v.FieldByName("OwnerReferences")
+ if !ownerReferences.IsValid() {
+ return fmt.Errorf("struct %#v lacks OwnerReferences type", v)
+ }
+ if ownerReferences.Kind() != reflect.Slice {
+ return fmt.Errorf("expect %v to be a slice", ownerReferences.Kind())
+ }
+ a.ownerReferences = ownerReferences.Addr()
return nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/api/meta/metatypes/types.go
similarity index 54%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/metatypes/types.go
index 1c45f0c2324a7fc62f2a500fdd9c2abeb81afa59..e7ac3e08d7fded572788733d3ca854232c1ce217 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/metatypes/types.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2014 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,16 +14,17 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package v1alpha1
+// The types defined in this package are used by the meta package to represent
+// the in-memory version of objects. We cannot reuse the __internal version of
+// API objects because it causes import cycle.
+package metatypes
-import "k8s.io/kubernetes/pkg/api/unversioned"
+import "k8s.io/kubernetes/pkg/types"
-// Placeholder top-level node resource metrics.
-type RawNode struct {
- unversioned.TypeMeta `json:",inline"`
-}
-
-// Placeholder top-level pod resource metrics.
-type RawPod struct {
- unversioned.TypeMeta `json:",inline"`
+type OwnerReference struct {
+ APIVersion string
+ Kind string
+ UID types.UID
+ Name string
+ Controller *bool
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go b/vendor/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go
index 3071d45072c681c51e5cebc530c84b10c7c1ec19..b720f8fa2ef343c233d93c36b20901023144d42e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/multirestmapper.go
@@ -22,6 +22,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
utilerrors "k8s.io/kubernetes/pkg/util/errors"
+ "k8s.io/kubernetes/pkg/util/sets"
)
// MultiRESTMapper is a wrapper for multiple RESTMappers.
@@ -169,24 +170,29 @@ func (m MultiRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...strin
if len(allMappings) == 1 {
return allMappings[0], nil
}
+ if len(allMappings) > 1 {
+ return nil, fmt.Errorf("multiple matches found for %v in %v", gk, versions)
+ }
if len(errors) > 0 {
return nil, utilerrors.NewAggregate(errors)
}
- if len(allMappings) == 0 {
- return nil, fmt.Errorf("no match found for %v in %v", gk, versions)
- }
-
- return nil, fmt.Errorf("multiple matches found for %v in %v", gk, versions)
+ return nil, fmt.Errorf("no match found for %v in %v", gk, versions)
}
// AliasesForResource finds the first alias response for the provided mappers.
func (m MultiRESTMapper) AliasesForResource(alias string) ([]string, bool) {
+ seenAliases := sets.NewString()
allAliases := []string{}
handled := false
for _, t := range m {
if currAliases, currOk := t.AliasesForResource(alias); currOk {
- allAliases = append(allAliases, currAliases...)
+ for _, currAlias := range currAliases {
+ if !seenAliases.Has(currAlias) {
+ allAliases = append(allAliases, currAlias)
+ seenAliases.Insert(currAlias)
+ }
+ }
handled = true
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/priority.go b/vendor/k8s.io/kubernetes/pkg/api/meta/priority.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/priority.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/priority.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/restmapper.go b/vendor/k8s.io/kubernetes/pkg/api/meta/restmapper.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/restmapper.go
rename to vendor/k8s.io/kubernetes/pkg/api/meta/restmapper.go
index d56b18cea9a5f442d427466c0cae52e71e30ba91..4e07ab7414e147a2ed7753ba412a3ae6f623eeef 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/meta/restmapper.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/meta/restmapper.go
@@ -69,7 +69,6 @@ var RESTScopeRoot = &restScope{
//
// TODO: Only accept plural for some operations for increased control?
// (`get pod bar` vs `get pods bar`)
-// TODO these maps should be keyed based on GroupVersionKinds
type DefaultRESTMapper struct {
defaultGroupVersions []unversioned.GroupVersion
@@ -80,6 +79,9 @@ type DefaultRESTMapper struct {
pluralToSingular map[unversioned.GroupVersionResource]unversioned.GroupVersionResource
interfacesFunc VersionInterfacesFunc
+
+ // aliasToResource is used for mapping aliases to resources
+ aliasToResource map[string][]string
}
func (m *DefaultRESTMapper) String() string {
@@ -103,6 +105,7 @@ func NewDefaultRESTMapper(defaultGroupVersions []unversioned.GroupVersion, f Ver
kindToScope := make(map[unversioned.GroupVersionKind]RESTScope)
singularToPlural := make(map[unversioned.GroupVersionResource]unversioned.GroupVersionResource)
pluralToSingular := make(map[unversioned.GroupVersionResource]unversioned.GroupVersionResource)
+ aliasToResource := make(map[string][]string)
// TODO: verify name mappings work correctly when versions differ
return &DefaultRESTMapper{
@@ -112,6 +115,7 @@ func NewDefaultRESTMapper(defaultGroupVersions []unversioned.GroupVersion, f Ver
defaultGroupVersions: defaultGroupVersions,
singularToPlural: singularToPlural,
pluralToSingular: pluralToSingular,
+ aliasToResource: aliasToResource,
interfacesFunc: f,
}
}
@@ -138,6 +142,8 @@ var unpluralizedSuffixes = []string{
}
// KindToResource converts Kind to a resource name.
+// Broken. This method only "sort of" works when used outside of this package. It assumes that Kinds and Resources match
+// and they aren't guaranteed to do so.
func KindToResource(kind unversioned.GroupVersionKind) ( /*plural*/ unversioned.GroupVersionResource /*singular*/, unversioned.GroupVersionResource) {
kindName := kind.Kind
if len(kindName) == 0 {
@@ -194,7 +200,19 @@ func (m *DefaultRESTMapper) ResourceSingularizer(resourceType string) (string, e
return singular.Resource, nil
}
-func (m *DefaultRESTMapper) ResourcesFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+// coerceResourceForMatching makes the resource lower case and converts internal versions to unspecified (legacy behavior)
+func coerceResourceForMatching(resource unversioned.GroupVersionResource) unversioned.GroupVersionResource {
+ resource.Resource = strings.ToLower(resource.Resource)
+ if resource.Version == runtime.APIVersionInternal {
+ resource.Version = ""
+ }
+
+ return resource
+}
+
+func (m *DefaultRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+ resource := coerceResourceForMatching(input)
+
hasResource := len(resource.Resource) > 0
hasGroup := len(resource.Group) > 0
hasVersion := len(resource.Version) > 0
@@ -271,10 +289,7 @@ func (m *DefaultRESTMapper) ResourceFor(resource unversioned.GroupVersionResourc
}
func (m *DefaultRESTMapper) KindsFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
- resource := input.GroupVersion().WithResource(strings.ToLower(input.Resource))
- if resource.Version == runtime.APIVersionInternal {
- resource.Version = ""
- }
+ resource := coerceResourceForMatching(input)
hasResource := len(resource.Resource) > 0
hasGroup := len(resource.Group) > 0
@@ -488,20 +503,17 @@ func (m *DefaultRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...st
return retVal, nil
}
-// aliasToResource is used for mapping aliases to resources
-var aliasToResource = map[string][]string{}
-
// AddResourceAlias maps aliases to resources
func (m *DefaultRESTMapper) AddResourceAlias(alias string, resources ...string) {
if len(resources) == 0 {
return
}
- aliasToResource[alias] = resources
+ m.aliasToResource[alias] = resources
}
// AliasesForResource returns whether a resource has an alias or not
func (m *DefaultRESTMapper) AliasesForResource(alias string) ([]string, bool) {
- if res, ok := aliasToResource[alias]; ok {
+ if res, ok := m.aliasToResource[alias]; ok {
return res, true
}
return nil, false
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/node_example.json b/vendor/k8s.io/kubernetes/pkg/api/node_example.json
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/node_example.json
rename to vendor/k8s.io/kubernetes/pkg/api/node_example.json
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/pod/util.go b/vendor/k8s.io/kubernetes/pkg/api/pod/util.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/pod/util.go
rename to vendor/k8s.io/kubernetes/pkg/api/pod/util.go
index 6b00c7e7dfafec4d6f70790514b3664492161cf3..1bdacfe20d683aa677ed3aa259f2f1f9b385bbbd 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/pod/util.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/pod/util.go
@@ -24,9 +24,11 @@ import (
)
const (
+ // TODO: to be de!eted after v1.3 is released. PodSpec has a dedicated Hostname field.
// The annotation value is a string specifying the hostname to be used for the pod e.g 'my-webserver-1'
PodHostnameAnnotation = "pod.beta.kubernetes.io/hostname"
+ // TODO: to be de!eted after v1.3 is released. PodSpec has a dedicated Subdomain field.
// The annotation value is a string specifying the subdomain e.g. "my-web-service"
// If specified, on the the pod itself, "<hostname>.my-web-service.<namespace>.svc.<cluster domain>" would resolve to
// the pod's IP.
@@ -47,7 +49,7 @@ func FindPort(pod *api.Pod, svcPort *api.ServicePort) (int, error) {
for _, container := range pod.Spec.Containers {
for _, port := range container.Ports {
if port.Name == name && port.Protocol == svcPort.Protocol {
- return port.ContainerPort, nil
+ return int(port.ContainerPort), nil
}
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/pod_example.json b/vendor/k8s.io/kubernetes/pkg/api/pod_example.json
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/pod_example.json
rename to vendor/k8s.io/kubernetes/pkg/api/pod_example.json
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/ref.go b/vendor/k8s.io/kubernetes/pkg/api/ref.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/ref.go
rename to vendor/k8s.io/kubernetes/pkg/api/ref.go
index 95690b821ada637b497aef4fe21187d82d10c5df..08dede0711f88c7199f3acae6b9591ff9ed4284d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/ref.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/ref.go
@@ -54,24 +54,18 @@ func GetReference(obj runtime.Object) (*ObjectReference, error) {
// if the object referenced is actually persisted, we can just get kind from meta
// if we are building an object reference to something not yet persisted, we should fallback to scheme
- var kind string
- if gvk != nil {
- kind = gvk.Kind
- }
+ kind := gvk.Kind
if len(kind) == 0 {
// TODO: this is wrong
- gvk, err := Scheme.ObjectKind(obj)
+ gvks, _, err := Scheme.ObjectKinds(obj)
if err != nil {
return nil, err
}
- kind = gvk.Kind
+ kind = gvks[0].Kind
}
// if the object referenced is actually persisted, we can also get version from meta
- var version string
- if gvk != nil {
- version = gvk.GroupVersion().String()
- }
+ version := gvk.GroupVersion().String()
if len(version) == 0 {
selfLink := meta.GetSelfLink()
if len(selfLink) == 0 {
@@ -111,9 +105,9 @@ func GetPartialReference(obj runtime.Object, fieldPath string) (*ObjectReference
// IsAnAPIObject allows clients to preemptively get a reference to an API object and pass it to places that
// intend only to get a reference to that object. This simplifies the event recording interface.
-func (obj *ObjectReference) SetGroupVersionKind(gvk *unversioned.GroupVersionKind) {
+func (obj *ObjectReference) SetGroupVersionKind(gvk unversioned.GroupVersionKind) {
obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
}
-func (obj *ObjectReference) GroupVersionKind() *unversioned.GroupVersionKind {
+func (obj *ObjectReference) GroupVersionKind() unversioned.GroupVersionKind {
return unversioned.FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/register.go b/vendor/k8s.io/kubernetes/pkg/api/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..631a7f9588203291b4be64457d460dd0694c9597
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/register.go
@@ -0,0 +1,115 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 api
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer"
+)
+
+// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
+var Scheme = runtime.NewScheme()
+
+// Codecs provides access to encoding and decoding for the scheme
+var Codecs = serializer.NewCodecFactory(Scheme)
+
+// GroupName is the group name use in this package
+const GroupName = ""
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Unversiond is group version for unversioned API objects
+// TODO: this should be v1 probably
+var Unversioned = unversioned.GroupVersion{Group: "", Version: "v1"}
+
+// ParameterCodec handles versioning of objects that are converted to query parameters.
+var ParameterCodec = runtime.NewParameterCodec(Scheme)
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ if err := Scheme.AddIgnoredConversionType(&unversioned.TypeMeta{}, &unversioned.TypeMeta{}); err != nil {
+ panic(err)
+ }
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Pod{},
+ &PodList{},
+ &PodStatusResult{},
+ &PodTemplate{},
+ &PodTemplateList{},
+ &ReplicationControllerList{},
+ &ReplicationController{},
+ &ServiceList{},
+ &Service{},
+ &ServiceProxyOptions{},
+ &NodeList{},
+ &Node{},
+ &NodeProxyOptions{},
+ &Endpoints{},
+ &EndpointsList{},
+ &Binding{},
+ &Event{},
+ &EventList{},
+ &List{},
+ &LimitRange{},
+ &LimitRangeList{},
+ &ResourceQuota{},
+ &ResourceQuotaList{},
+ &Namespace{},
+ &NamespaceList{},
+ &ServiceAccount{},
+ &ServiceAccountList{},
+ &Secret{},
+ &SecretList{},
+ &PersistentVolume{},
+ &PersistentVolumeList{},
+ &PersistentVolumeClaim{},
+ &PersistentVolumeClaimList{},
+ &DeleteOptions{},
+ &ListOptions{},
+ &PodAttachOptions{},
+ &PodLogOptions{},
+ &PodExecOptions{},
+ &PodProxyOptions{},
+ &ComponentStatus{},
+ &ComponentStatusList{},
+ &SerializedReference{},
+ &RangeAllocation{},
+ &ConfigMap{},
+ &ConfigMapList{},
+ )
+
+ // Register Unversioned types under their own special group
+ Scheme.AddUnversionedTypes(Unversioned,
+ &unversioned.ExportOptions{},
+ &unversioned.Status{},
+ &unversioned.APIVersions{},
+ &unversioned.APIGroupList{},
+ &unversioned.APIGroup{},
+ &unversioned.APIResourceList{},
+ )
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/replication_controller_example.json b/vendor/k8s.io/kubernetes/pkg/api/replication_controller_example.json
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/replication_controller_example.json
rename to vendor/k8s.io/kubernetes/pkg/api/replication_controller_example.json
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/requestcontext.go b/vendor/k8s.io/kubernetes/pkg/api/requestcontext.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/requestcontext.go
rename to vendor/k8s.io/kubernetes/pkg/api/requestcontext.go
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/amount.go b/vendor/k8s.io/kubernetes/pkg/api/resource/amount.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ae823a0229eba0b9541da53776d460d5fda3e1b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/amount.go
@@ -0,0 +1,298 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 resource
+
+import (
+ "math/big"
+ "strconv"
+
+ inf "gopkg.in/inf.v0"
+)
+
+// Scale is used for getting and setting the base-10 scaled value.
+// Base-2 scales are omitted for mathematical simplicity.
+// See Quantity.ScaledValue for more details.
+type Scale int32
+
+// infScale adapts a Scale value to an inf.Scale value.
+func (s Scale) infScale() inf.Scale {
+ return inf.Scale(-s) // inf.Scale is upside-down
+}
+
+const (
+ Nano Scale = -9
+ Micro Scale = -6
+ Milli Scale = -3
+ Kilo Scale = 3
+ Mega Scale = 6
+ Giga Scale = 9
+ Tera Scale = 12
+ Peta Scale = 15
+ Exa Scale = 18
+)
+
+var (
+ Zero = int64Amount{}
+
+ // Used by quantity strings - treat as read only
+ zeroBytes = []byte("0")
+)
+
+// int64Amount represents a fixed precision numerator and arbitrary scale exponent. It is faster
+// than operations on inf.Dec for values that can be represented as int64.
+type int64Amount struct {
+ value int64
+ scale Scale
+}
+
+// Sign returns 0 if the value is zero, -1 if it is less than 0, or 1 if it is greater than 0.
+func (a int64Amount) Sign() int {
+ switch {
+ case a.value == 0:
+ return 0
+ case a.value > 0:
+ return 1
+ default:
+ return -1
+ }
+}
+
+// AsInt64 returns the current amount as an int64 at scale 0, or false if the value cannot be
+// represented in an int64 OR would result in a loss of precision. This method is intended as
+// an optimization to avoid calling AsDec.
+func (a int64Amount) AsInt64() (int64, bool) {
+ if a.scale == 0 {
+ return a.value, true
+ }
+ if a.scale < 0 {
+ // TODO: attempt to reduce factors, although it is assumed that factors are reduced prior
+ // to the int64Amount being created.
+ return 0, false
+ }
+ return positiveScaleInt64(a.value, a.scale)
+}
+
+// AsScaledInt64 returns an int64 representing the value of this amount at the specified scale,
+// rounding up, or false if that would result in overflow. (1e20).AsScaledInt64(1) would result
+// in overflow because 1e19 is not representable as an int64. Note that setting a scale larger
+// than the current value may result in loss of precision - i.e. (1e-6).AsScaledInt64(0) would
+// return 1, because 0.000001 is rounded up to 1.
+func (a int64Amount) AsScaledInt64(scale Scale) (result int64, ok bool) {
+ if a.scale < scale {
+ result, _ = negativeScaleInt64(a.value, scale-a.scale)
+ return result, true
+ }
+ return positiveScaleInt64(a.value, a.scale-scale)
+}
+
+// AsDec returns an inf.Dec representation of this value.
+func (a int64Amount) AsDec() *inf.Dec {
+ var base inf.Dec
+ base.SetUnscaled(a.value)
+ base.SetScale(inf.Scale(-a.scale))
+ return &base
+}
+
+// Cmp returns 0 if a and b are equal, 1 if a is greater than b, or -1 if a is less than b.
+func (a int64Amount) Cmp(b int64Amount) int {
+ switch {
+ case a.scale == b.scale:
+ // compare only the unscaled portion
+ case a.scale > b.scale:
+ result, remainder, exact := divideByScaleInt64(b.value, a.scale-b.scale)
+ if !exact {
+ return a.AsDec().Cmp(b.AsDec())
+ }
+ if result == a.value {
+ switch {
+ case remainder == 0:
+ return 0
+ case remainder > 0:
+ return -1
+ default:
+ return 1
+ }
+ }
+ b.value = result
+ default:
+ result, remainder, exact := divideByScaleInt64(a.value, b.scale-a.scale)
+ if !exact {
+ return a.AsDec().Cmp(b.AsDec())
+ }
+ if result == b.value {
+ switch {
+ case remainder == 0:
+ return 0
+ case remainder > 0:
+ return 1
+ default:
+ return -1
+ }
+ }
+ a.value = result
+ }
+
+ switch {
+ case a.value == b.value:
+ return 0
+ case a.value < b.value:
+ return -1
+ default:
+ return 1
+ }
+}
+
+// Add adds two int64Amounts together, matching scales. It will return false and not mutate
+// a if overflow or underflow would result.
+func (a *int64Amount) Add(b int64Amount) bool {
+ switch {
+ case b.value == 0:
+ return true
+ case a.value == 0:
+ a.value = b.value
+ a.scale = b.scale
+ return true
+ case a.scale == b.scale:
+ c, ok := int64Add(a.value, b.value)
+ if !ok {
+ return false
+ }
+ a.value = c
+ case a.scale > b.scale:
+ c, ok := positiveScaleInt64(a.value, a.scale-b.scale)
+ if !ok {
+ return false
+ }
+ c, ok = int64Add(c, b.value)
+ if !ok {
+ return false
+ }
+ a.scale = b.scale
+ a.value = c
+ default:
+ c, ok := positiveScaleInt64(b.value, b.scale-a.scale)
+ if !ok {
+ return false
+ }
+ c, ok = int64Add(a.value, c)
+ if !ok {
+ return false
+ }
+ a.value = c
+ }
+ return true
+}
+
+// Sub removes the value of b from the current amount, or returns false if underflow would result.
+func (a *int64Amount) Sub(b int64Amount) bool {
+ return a.Add(int64Amount{value: -b.value, scale: b.scale})
+}
+
+// AsScale adjusts this amount to set a minimum scale, rounding up, and returns true iff no precision
+// was lost. (1.1e5).AsScale(5) would return 1.1e5, but (1.1e5).AsScale(6) would return 1e6.
+func (a int64Amount) AsScale(scale Scale) (int64Amount, bool) {
+ if a.scale >= scale {
+ return a, true
+ }
+ result, exact := negativeScaleInt64(a.value, scale-a.scale)
+ return int64Amount{value: result, scale: scale}, exact
+}
+
+// AsCanonicalBytes accepts a buffer to write the base-10 string value of this field to, and returns
+// either that buffer or a larger buffer and the current exponent of the value. The value is adjusted
+// until the exponent is a multiple of 3 - i.e. 1.1e5 would return "110", 3.
+func (a int64Amount) AsCanonicalBytes(out []byte) (result []byte, exponent int32) {
+ mantissa := a.value
+ exponent = int32(a.scale)
+
+ amount, times := removeInt64Factors(mantissa, 10)
+ exponent += int32(times)
+
+ // make sure exponent is a multiple of 3
+ var ok bool
+ switch exponent % 3 {
+ case 1, -2:
+ amount, ok = int64MultiplyScale10(amount)
+ if !ok {
+ return infDecAmount{a.AsDec()}.AsCanonicalBytes(out)
+ }
+ exponent = exponent - 1
+ case 2, -1:
+ amount, ok = int64MultiplyScale100(amount)
+ if !ok {
+ return infDecAmount{a.AsDec()}.AsCanonicalBytes(out)
+ }
+ exponent = exponent - 2
+ }
+ return strconv.AppendInt(out, amount, 10), exponent
+}
+
+// AsCanonicalBase1024Bytes accepts a buffer to write the base-1024 string value of this field to, and returns
+// either that buffer or a larger buffer and the current exponent of the value. 2048 is 2 * 1024 ^ 1 and would
+// return []byte("2048"), 1.
+func (a int64Amount) AsCanonicalBase1024Bytes(out []byte) (result []byte, exponent int32) {
+ value, ok := a.AsScaledInt64(0)
+ if !ok {
+ return infDecAmount{a.AsDec()}.AsCanonicalBase1024Bytes(out)
+ }
+ amount, exponent := removeInt64Factors(value, 1024)
+ return strconv.AppendInt(out, amount, 10), exponent
+}
+
+// infDecAmount implements common operations over an inf.Dec that are specific to the quantity
+// representation.
+type infDecAmount struct {
+ *inf.Dec
+}
+
+// AsScale adjusts this amount to set a minimum scale, rounding up, and returns true iff no precision
+// was lost. (1.1e5).AsScale(5) would return 1.1e5, but (1.1e5).AsScale(6) would return 1e6.
+func (a infDecAmount) AsScale(scale Scale) (infDecAmount, bool) {
+ tmp := &inf.Dec{}
+ tmp.Round(a.Dec, scale.infScale(), inf.RoundUp)
+ return infDecAmount{tmp}, tmp.Cmp(a.Dec) == 0
+}
+
+// AsCanonicalBytes accepts a buffer to write the base-10 string value of this field to, and returns
+// either that buffer or a larger buffer and the current exponent of the value. The value is adjusted
+// until the exponent is a multiple of 3 - i.e. 1.1e5 would return "110", 3.
+func (a infDecAmount) AsCanonicalBytes(out []byte) (result []byte, exponent int32) {
+ mantissa := a.Dec.UnscaledBig()
+ exponent = int32(-a.Dec.Scale())
+ amount := big.NewInt(0).Set(mantissa)
+ // move all factors of 10 into the exponent for easy reasoning
+ amount, times := removeBigIntFactors(amount, bigTen)
+ exponent += times
+
+ // make sure exponent is a multiple of 3
+ for exponent%3 != 0 {
+ amount.Mul(amount, bigTen)
+ exponent--
+ }
+
+ return append(out, amount.String()...), exponent
+}
+
+// AsCanonicalBase1024Bytes accepts a buffer to write the base-1024 string value of this field to, and returns
+// either that buffer or a larger buffer and the current exponent of the value. 2048 is 2 * 1024 ^ 1 and would
+// return []byte("2048"), 1.
+func (a infDecAmount) AsCanonicalBase1024Bytes(out []byte) (result []byte, exponent int32) {
+ tmp := &inf.Dec{}
+ tmp.Round(a.Dec, 0, inf.RoundUp)
+ amount, exponent := removeBigIntFactors(tmp.UnscaledBig(), big1024)
+ return append(out, amount.String()...), exponent
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/deep_copy.go b/vendor/k8s.io/kubernetes/pkg/api/resource/deep_copy.go
new file mode 100644
index 0000000000000000000000000000000000000000..4efc0406f0d1cf79624c4105575d03e26e7f5a55
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/deep_copy.go
@@ -0,0 +1,32 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 resource
+
+import (
+ inf "gopkg.in/inf.v0"
+
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func DeepCopy_resource_Quantity(in Quantity, out *Quantity, c *conversion.Cloner) error {
+ *out = in
+ if in.d.Dec != nil {
+ tmp := &inf.Dec{}
+ out.d.Dec = tmp.Set(in.d.Dec)
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/api/resource/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..cf9447a321f411afbf1806c30c3a19c01dabd215
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/generated.pb.go
@@ -0,0 +1,46 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/api/resource/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package resource is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/api/resource/generated.proto
+
+ It has these top-level messages:
+ Quantity
+*/
+package resource
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *Quantity) Reset() { *m = Quantity{} }
+func (*Quantity) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*Quantity)(nil), "k8s.io.kubernetes.pkg.api.resource.Quantity")
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/generated.proto b/vendor/k8s.io/kubernetes/pkg/api/resource/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..e1c2a3d608001be5828e93e0595d4e1eaad1956c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/generated.proto
@@ -0,0 +1,94 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.api.resource;
+
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "resource";
+
+// Quantity is a fixed-point representation of a number.
+// It provides convenient marshaling/unmarshaling in JSON and YAML,
+// in addition to String() and Int64() accessors.
+//
+// The serialization format is:
+//
+// <quantity> ::= <signedNumber><suffix>
+// (Note that <suffix> may be empty, from the "" case in <decimalSI>.)
+// <digit> ::= 0 | 1 | ... | 9
+// <digits> ::= <digit> | <digit><digits>
+// <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
+// <sign> ::= "+" | "-"
+// <signedNumber> ::= <number> | <sign><number>
+// <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI>
+// <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei
+// (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)
+// <decimalSI> ::= m | "" | k | M | G | T | P | E
+// (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
+// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
+//
+// 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: We reserve the right to amend this canonical format, perhaps to
+// allow 1.5 to be canonical.
+// TODO: Remove above disclaimer after all bikeshedding about format is over,
+// or after March 2015.
+//
+// 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.
+//
+// +gencopy=false
+// +protobuf=true
+// +protobuf.embed=string
+// +protobuf.options.marshal=false
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message Quantity {
+ optional string string = 1;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/math.go b/vendor/k8s.io/kubernetes/pkg/api/resource/math.go
new file mode 100644
index 0000000000000000000000000000000000000000..163aafa5db6ab116465d9356bf84f9eaf3e69032
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/math.go
@@ -0,0 +1,327 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 resource
+
+import (
+ "math/big"
+
+ inf "gopkg.in/inf.v0"
+)
+
+const (
+ // maxInt64Factors is the highest value that will be checked when removing factors of 10 from an int64.
+ // It is also the maximum decimal digits that can be represented with an int64.
+ maxInt64Factors = 18
+)
+
+var (
+ // Commonly needed big.Int values-- treat as read only!
+ bigTen = big.NewInt(10)
+ bigZero = big.NewInt(0)
+ bigOne = big.NewInt(1)
+ bigThousand = big.NewInt(1000)
+ big1024 = big.NewInt(1024)
+
+ // Commonly needed inf.Dec values-- treat as read only!
+ decZero = inf.NewDec(0, 0)
+ decOne = inf.NewDec(1, 0)
+ decMinusOne = inf.NewDec(-1, 0)
+ decThousand = inf.NewDec(1000, 0)
+ dec1024 = inf.NewDec(1024, 0)
+ decMinus1024 = inf.NewDec(-1024, 0)
+
+ // Largest (in magnitude) number allowed.
+ maxAllowed = infDecAmount{inf.NewDec((1<<63)-1, 0)} // == max int64
+
+ // The maximum value we can represent milli-units for.
+ // Compare with the return value of Quantity.Value() to
+ // see if it's safe to use Quantity.MilliValue().
+ MaxMilliValue = int64(((1 << 63) - 1) / 1000)
+)
+
+const mostNegative = -(mostPositive + 1)
+const mostPositive = 1<<63 - 1
+
+// int64Add returns a+b, or false if that would overflow int64.
+func int64Add(a, b int64) (int64, bool) {
+ c := a + b
+ switch {
+ case a > 0 && b > 0:
+ if c < 0 {
+ return 0, false
+ }
+ case a < 0 && b < 0:
+ if c > 0 {
+ return 0, false
+ }
+ if a == mostNegative && b == mostNegative {
+ return 0, false
+ }
+ }
+ return c, true
+}
+
+// int64Multiply returns a*b, or false if that would overflow or underflow int64.
+func int64Multiply(a, b int64) (int64, bool) {
+ if a == 0 || b == 0 || a == 1 || b == 1 {
+ return a * b, true
+ }
+ if a == mostNegative || b == mostNegative {
+ return 0, false
+ }
+ c := a * b
+ return c, c/b == a
+}
+
+// int64MultiplyScale returns a*b, assuming b is greater than one, or false if that would overflow or underflow int64.
+// Use when b is known to be greater than one.
+func int64MultiplyScale(a int64, b int64) (int64, bool) {
+ if a == 0 || a == 1 {
+ return a * b, true
+ }
+ if a == mostNegative && b != 1 {
+ return 0, false
+ }
+ c := a * b
+ return c, c/b == a
+}
+
+// int64MultiplyScale10 multiplies a by 10, or returns false if that would overflow. This method is faster than
+// int64Multiply(a, 10) because the compiler can optimize constant factor multiplication.
+func int64MultiplyScale10(a int64) (int64, bool) {
+ if a == 0 || a == 1 {
+ return a * 10, true
+ }
+ if a == mostNegative {
+ return 0, false
+ }
+ c := a * 10
+ return c, c/10 == a
+}
+
+// int64MultiplyScale100 multiplies a by 100, or returns false if that would overflow. This method is faster than
+// int64Multiply(a, 100) because the compiler can optimize constant factor multiplication.
+func int64MultiplyScale100(a int64) (int64, bool) {
+ if a == 0 || a == 1 {
+ return a * 100, true
+ }
+ if a == mostNegative {
+ return 0, false
+ }
+ c := a * 100
+ return c, c/100 == a
+}
+
+// int64MultiplyScale1000 multiplies a by 1000, or returns false if that would overflow. This method is faster than
+// int64Multiply(a, 1000) because the compiler can optimize constant factor multiplication.
+func int64MultiplyScale1000(a int64) (int64, bool) {
+ if a == 0 || a == 1 {
+ return a * 1000, true
+ }
+ if a == mostNegative {
+ return 0, false
+ }
+ c := a * 1000
+ return c, c/1000 == a
+}
+
+// positiveScaleInt64 multiplies base by 10^scale, returning false if the
+// value overflows. Passing a negative scale is undefined.
+func positiveScaleInt64(base int64, scale Scale) (int64, bool) {
+ switch scale {
+ case 0:
+ return base, true
+ case 1:
+ return int64MultiplyScale10(base)
+ case 2:
+ return int64MultiplyScale100(base)
+ case 3:
+ return int64MultiplyScale1000(base)
+ case 6:
+ return int64MultiplyScale(base, 1000000)
+ case 9:
+ return int64MultiplyScale(base, 1000000000)
+ default:
+ value := base
+ var ok bool
+ for i := Scale(0); i < scale; i++ {
+ if value, ok = int64MultiplyScale(value, 10); !ok {
+ return 0, false
+ }
+ }
+ return value, true
+ }
+}
+
+// negativeScaleInt64 reduces base by the provided scale, rounding up, until the
+// value is zero or the scale is reached. Passing a negative scale is undefined.
+// The value returned, if not exact, is rounded away from zero.
+func negativeScaleInt64(base int64, scale Scale) (result int64, exact bool) {
+ if scale == 0 {
+ return base, true
+ }
+
+ value := base
+ var fraction bool
+ for i := Scale(0); i < scale; i++ {
+ if !fraction && value%10 != 0 {
+ fraction = true
+ }
+ value = value / 10
+ if value == 0 {
+ if fraction {
+ if base > 0 {
+ return 1, false
+ }
+ return -1, false
+ }
+ return 0, true
+ }
+ }
+ if fraction {
+ if base > 0 {
+ value += 1
+ } else {
+ value += -1
+ }
+ }
+ return value, !fraction
+}
+
+func pow10Int64(b int64) int64 {
+ switch b {
+ case 0:
+ return 1
+ case 1:
+ return 10
+ case 2:
+ return 100
+ case 3:
+ return 1000
+ case 4:
+ return 10000
+ case 5:
+ return 100000
+ case 6:
+ return 1000000
+ case 7:
+ return 10000000
+ case 8:
+ return 100000000
+ case 9:
+ return 1000000000
+ case 10:
+ return 10000000000
+ case 11:
+ return 100000000000
+ case 12:
+ return 1000000000000
+ case 13:
+ return 10000000000000
+ case 14:
+ return 100000000000000
+ case 15:
+ return 1000000000000000
+ case 16:
+ return 10000000000000000
+ case 17:
+ return 100000000000000000
+ case 18:
+ return 1000000000000000000
+ default:
+ return 0
+ }
+}
+
+// powInt64 raises a to the bth power. Is not overflow aware.
+func powInt64(a, b int64) int64 {
+ p := int64(1)
+ for b > 0 {
+ if b&1 != 0 {
+ p *= a
+ }
+ b >>= 1
+ a *= a
+ }
+ return p
+}
+
+// negativeScaleInt64 returns the result of dividing base by scale * 10 and the remainder, or
+// false if no such division is possible. Dividing by negative scales is undefined.
+func divideByScaleInt64(base int64, scale Scale) (result, remainder int64, exact bool) {
+ if scale == 0 {
+ return base, 0, true
+ }
+ // the max scale representable in base 10 in an int64 is 18 decimal places
+ if scale >= 18 {
+ return 0, base, false
+ }
+ divisor := pow10Int64(int64(scale))
+ return base / divisor, base % divisor, true
+}
+
+// removeInt64Factors divides in a loop; the return values have the property that
+// value == result * base ^ scale
+func removeInt64Factors(value int64, base int64) (result int64, times int32) {
+ times = 0
+ result = value
+ negative := result < 0
+ if negative {
+ result = -result
+ }
+ switch base {
+ // allow the compiler to optimize the common cases
+ case 10:
+ for result >= 10 && result%10 == 0 {
+ times++
+ result = result / 10
+ }
+ // allow the compiler to optimize the common cases
+ case 1024:
+ for result >= 1024 && result%1024 == 0 {
+ times++
+ result = result / 1024
+ }
+ default:
+ for result >= base && result%base == 0 {
+ times++
+ result = result / base
+ }
+ }
+ if negative {
+ result = -result
+ }
+ return result, times
+}
+
+// removeBigIntFactors divides in a loop; the return values have the property that
+// d == result * factor ^ times
+// d may be modified in place.
+// If d == 0, then the return values will be (0, 0)
+func removeBigIntFactors(d, factor *big.Int) (result *big.Int, times int32) {
+ q := big.NewInt(0)
+ m := big.NewInt(0)
+ for d.Cmp(bigZero) != 0 {
+ q.DivMod(d, factor, m)
+ if m.Cmp(bigZero) != 0 {
+ break
+ }
+ times++
+ d, q = q, d
+ }
+ return d, times
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/quantity.go b/vendor/k8s.io/kubernetes/pkg/api/resource/quantity.go
new file mode 100644
index 0000000000000000000000000000000000000000..96877b4c946ffcfd427d5933381b0689a0168994
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/quantity.go
@@ -0,0 +1,768 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 resource
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "math/big"
+ "regexp"
+ "strconv"
+ "strings"
+
+ flag "github.com/spf13/pflag"
+
+ inf "gopkg.in/inf.v0"
+)
+
+// Quantity is a fixed-point representation of a number.
+// It provides convenient marshaling/unmarshaling in JSON and YAML,
+// in addition to String() and Int64() accessors.
+//
+// The serialization format is:
+//
+// <quantity> ::= <signedNumber><suffix>
+// (Note that <suffix> may be empty, from the "" case in <decimalSI>.)
+// <digit> ::= 0 | 1 | ... | 9
+// <digits> ::= <digit> | <digit><digits>
+// <number> ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
+// <sign> ::= "+" | "-"
+// <signedNumber> ::= <number> | <sign><number>
+// <suffix> ::= <binarySI> | <decimalExponent> | <decimalSI>
+// <binarySI> ::= Ki | Mi | Gi | Ti | Pi | Ei
+// (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)
+// <decimalSI> ::= m | "" | k | M | G | T | P | E
+// (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
+// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
+//
+// 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: We reserve the right to amend this canonical format, perhaps to
+// allow 1.5 to be canonical.
+// TODO: Remove above disclaimer after all bikeshedding about format is over,
+// or after March 2015.
+//
+// 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.
+//
+// +gencopy=false
+// +protobuf=true
+// +protobuf.embed=string
+// +protobuf.options.marshal=false
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+type Quantity struct {
+ // i is the quantity in int64 scaled form, if d.Dec == nil
+ i int64Amount
+ // d is the quantity in inf.Dec form if d.Dec != nil
+ d infDecAmount
+ // s is the generated value of this quantity to avoid recalculation
+ s string
+
+ // Change Format at will. See the comment for Canonicalize for
+ // more details.
+ Format
+}
+
+// CanonicalValue allows a quantity amount to be converted to a string.
+type CanonicalValue interface {
+ // AsCanonicalBytes returns a byte array representing the string representation
+ // of the value mantissa and an int32 representing its exponent in base-10. Callers may
+ // pass a byte slice to the method to avoid allocations.
+ AsCanonicalBytes(out []byte) ([]byte, int32)
+ // AsCanonicalBase1024Bytes returns a byte array representing the string representation
+ // of the value mantissa and an int32 representing its exponent in base-1024. Callers
+ // may pass a byte slice to the method to avoid allocations.
+ AsCanonicalBase1024Bytes(out []byte) ([]byte, int32)
+}
+
+// Format lists the three possible formattings of a quantity.
+type Format string
+
+const (
+ DecimalExponent = Format("DecimalExponent") // e.g., 12e6
+ BinarySI = Format("BinarySI") // e.g., 12Mi (12 * 2^20)
+ DecimalSI = Format("DecimalSI") // e.g., 12M (12 * 10^6)
+)
+
+// MustParse turns the given string into a quantity or panics; for tests
+// or others cases where you know the string is valid.
+func MustParse(str string) Quantity {
+ q, err := ParseQuantity(str)
+ if err != nil {
+ panic(fmt.Errorf("cannot parse '%v': %v", str, err))
+ }
+ return q
+}
+
+const (
+ // splitREString is used to separate a number from its suffix; as such,
+ // this is overly permissive, but that's OK-- it will be checked later.
+ splitREString = "^([+-]?[0-9.]+)([eEinumkKMGTP]*[-+]?[0-9]*)$"
+)
+
+var (
+ // splitRE is used to get the various parts of a number.
+ splitRE = regexp.MustCompile(splitREString)
+
+ // Errors that could happen while parsing a string.
+ ErrFormatWrong = errors.New("quantities must match the regular expression '" + splitREString + "'")
+ ErrNumeric = errors.New("unable to parse numeric part of quantity")
+ ErrSuffix = errors.New("unable to parse quantity's suffix")
+)
+
+// parseQuantityString is a fast scanner for quantity values.
+func parseQuantityString(str string) (positive bool, value, num, denom, suffix string, err error) {
+ positive = true
+ pos := 0
+ end := len(str)
+
+ // handle leading sign
+ if pos < end {
+ switch str[0] {
+ case '-':
+ positive = false
+ pos++
+ case '+':
+ pos++
+ }
+ }
+
+ // strip leading zeros
+Zeroes:
+ for i := pos; ; i++ {
+ if i >= end {
+ num = "0"
+ value = num
+ return
+ }
+ switch str[i] {
+ case '0':
+ pos++
+ default:
+ break Zeroes
+ }
+ }
+
+ // extract the numerator
+Num:
+ for i := pos; ; i++ {
+ if i >= end {
+ num = str[pos:end]
+ value = str[0:end]
+ return
+ }
+ switch str[i] {
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ default:
+ num = str[pos:i]
+ pos = i
+ break Num
+ }
+ }
+
+ // if we stripped all numerator positions, always return 0
+ if len(num) == 0 {
+ num = "0"
+ }
+
+ // handle a denominator
+ if pos < end && str[pos] == '.' {
+ pos++
+ Denom:
+ for i := pos; ; i++ {
+ if i >= end {
+ denom = str[pos:end]
+ value = str[0:end]
+ return
+ }
+ switch str[i] {
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ default:
+ denom = str[pos:i]
+ pos = i
+ break Denom
+ }
+ }
+ // TODO: we currently allow 1.G, but we may not want to in the future.
+ // if len(denom) == 0 {
+ // err = ErrFormatWrong
+ // return
+ // }
+ }
+ value = str[0:pos]
+
+ // grab the elements of the suffix
+ suffixStart := pos
+ for i := pos; ; i++ {
+ if i >= end {
+ suffix = str[suffixStart:end]
+ return
+ }
+ if !strings.ContainsAny(str[i:i+1], "eEinumkKMGTP") {
+ pos = i
+ break
+ }
+ }
+ if pos < end {
+ switch str[pos] {
+ case '-', '+':
+ pos++
+ }
+ }
+Suffix:
+ for i := pos; ; i++ {
+ if i >= end {
+ suffix = str[suffixStart:end]
+ return
+ }
+ switch str[i] {
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ default:
+ break Suffix
+ }
+ }
+ // we encountered a non decimal in the Suffix loop, but the last character
+ // was not a valid exponent
+ err = ErrFormatWrong
+ return
+}
+
+// ParseQuantity turns str into a Quantity, or returns an error.
+func ParseQuantity(str string) (Quantity, error) {
+ if len(str) == 0 {
+ return Quantity{}, ErrFormatWrong
+ }
+ if str == "0" {
+ return Quantity{Format: DecimalSI, s: str}, nil
+ }
+
+ positive, value, num, denom, suf, err := parseQuantityString(str)
+ if err != nil {
+ return Quantity{}, err
+ }
+
+ base, exponent, format, ok := quantitySuffixer.interpret(suffix(suf))
+ if !ok {
+ return Quantity{}, ErrSuffix
+ }
+
+ precision := int32(0)
+ scale := int32(0)
+ mantissa := int64(1)
+ switch format {
+ case DecimalExponent, DecimalSI:
+ scale = exponent
+ precision = maxInt64Factors - int32(len(num)+len(denom))
+ case BinarySI:
+ scale = 0
+ switch {
+ case exponent >= 0 && len(denom) == 0:
+ // only handle positive binary numbers with the fast path
+ mantissa = int64(int64(mantissa) << uint64(exponent))
+ // 1Mi (2^20) has ~6 digits of decimal precision, so exponent*3/10 -1 is roughly the precision
+ precision = 15 - int32(len(num)) - int32(float32(exponent)*3/10) - 1
+ default:
+ precision = -1
+ }
+ }
+
+ if precision >= 0 {
+ // if we have a denominator, shift the entire value to the left by the number of places in the
+ // denominator
+ scale -= int32(len(denom))
+ if scale >= int32(Nano) {
+ shifted := num + denom
+
+ var value int64
+ value, err := strconv.ParseInt(shifted, 10, 64)
+ if err != nil {
+ return Quantity{}, ErrNumeric
+ }
+ if result, ok := int64Multiply(value, int64(mantissa)); ok {
+ if !positive {
+ result = -result
+ }
+ // if the number is in canonical form, reuse the string
+ switch format {
+ case BinarySI:
+ if exponent%10 == 0 && (value&0x07 != 0) {
+ return Quantity{i: int64Amount{value: result, scale: Scale(scale)}, Format: format, s: str}, nil
+ }
+ default:
+ if scale%3 == 0 && !strings.HasSuffix(shifted, "000") && shifted[0] != '0' {
+ return Quantity{i: int64Amount{value: result, scale: Scale(scale)}, Format: format, s: str}, nil
+ }
+ }
+ return Quantity{i: int64Amount{value: result, scale: Scale(scale)}, Format: format}, nil
+ }
+ }
+ }
+
+ amount := new(inf.Dec)
+ if _, ok := amount.SetString(value); !ok {
+ return Quantity{}, ErrNumeric
+ }
+
+ // So that no one but us has to think about suffixes, remove it.
+ if base == 10 {
+ amount.SetScale(amount.Scale() + Scale(exponent).infScale())
+ } else if base == 2 {
+ // numericSuffix = 2 ** exponent
+ numericSuffix := big.NewInt(1).Lsh(bigOne, uint(exponent))
+ ub := amount.UnscaledBig()
+ amount.SetUnscaledBig(ub.Mul(ub, numericSuffix))
+ }
+
+ // Cap at min/max bounds.
+ sign := amount.Sign()
+ if sign == -1 {
+ amount.Neg(amount)
+ }
+
+ // This rounds non-zero values up to the minimum representable value, under the theory that
+ // if you want some resources, you should get some resources, even if you asked for way too small
+ // of an amount. Arguably, this should be inf.RoundHalfUp (normal rounding), but that would have
+ // the side effect of rounding values < .5n to zero.
+ if v, ok := amount.Unscaled(); v != int64(0) || !ok {
+ amount.Round(amount, Nano.infScale(), inf.RoundUp)
+ }
+
+ // The max is just a simple cap.
+ // TODO: this prevents accumulating quantities greater than int64, for instance quota across a cluster
+ if format == BinarySI && amount.Cmp(maxAllowed.Dec) > 0 {
+ amount.Set(maxAllowed.Dec)
+ }
+
+ if format == BinarySI && amount.Cmp(decOne) < 0 && amount.Cmp(decZero) > 0 {
+ // This avoids rounding and hopefully confusion, too.
+ format = DecimalSI
+ }
+ if sign == -1 {
+ amount.Neg(amount)
+ }
+
+ return Quantity{d: infDecAmount{amount}, Format: format}, nil
+}
+
+// CanonicalizeBytes returns the canonical form of q and its suffix (see comment on Quantity).
+//
+// Note about BinarySI:
+// * If q.Format is set to BinarySI and q.Amount represents a non-zero value between
+// -1 and +1, it will be emitted as if q.Format were DecimalSI.
+// * Otherwise, if q.Format is set to BinarySI, frational parts of q.Amount will be
+// rounded up. (1.1i becomes 2i.)
+func (q *Quantity) CanonicalizeBytes(out []byte) (result, suffix []byte) {
+ if q.IsZero() {
+ return zeroBytes, nil
+ }
+
+ var rounded CanonicalValue
+ format := q.Format
+ switch format {
+ case DecimalExponent, DecimalSI:
+ case BinarySI:
+ if q.CmpInt64(-1024) > 0 && q.CmpInt64(1024) < 0 {
+ // This avoids rounding and hopefully confusion, too.
+ format = DecimalSI
+ } else {
+ var exact bool
+ if rounded, exact = q.AsScale(0); !exact {
+ // Don't lose precision-- show as DecimalSI
+ format = DecimalSI
+ }
+ }
+ default:
+ format = DecimalExponent
+ }
+
+ // TODO: If BinarySI formatting is requested but would cause rounding, upgrade to
+ // one of the other formats.
+ switch format {
+ case DecimalExponent, DecimalSI:
+ number, exponent := q.AsCanonicalBytes(out)
+ suffix, _ := quantitySuffixer.constructBytes(10, exponent, format)
+ return number, suffix
+ default:
+ // format must be BinarySI
+ number, exponent := rounded.AsCanonicalBase1024Bytes(out)
+ suffix, _ := quantitySuffixer.constructBytes(2, exponent*10, format)
+ return number, suffix
+ }
+}
+
+// AsInt64 returns a representation of the current value as an int64 if a fast conversion
+// is possible. If false is returned, callers must use the inf.Dec form of this quantity.
+func (q *Quantity) AsInt64() (int64, bool) {
+ if q.d.Dec != nil {
+ return 0, false
+ }
+ return q.i.AsInt64()
+}
+
+// ToDec promotes the quantity in place to use an inf.Dec representation and returns itself.
+func (q *Quantity) ToDec() *Quantity {
+ if q.d.Dec == nil {
+ q.d.Dec = q.i.AsDec()
+ q.i = int64Amount{}
+ }
+ return q
+}
+
+// AsDec returns the quantity as represented by a scaled inf.Dec.
+func (q *Quantity) AsDec() *inf.Dec {
+ if q.d.Dec != nil {
+ return q.d.Dec
+ }
+ q.d.Dec = q.i.AsDec()
+ q.i = int64Amount{}
+ return q.d.Dec
+}
+
+// AsCanonicalBytes returns the canonical byte representation of this quantity as a mantissa
+// and base 10 exponent. The out byte slice may be passed to the method to avoid an extra
+// allocation.
+func (q *Quantity) AsCanonicalBytes(out []byte) (result []byte, exponent int32) {
+ if q.d.Dec != nil {
+ return q.d.AsCanonicalBytes(out)
+ }
+ return q.i.AsCanonicalBytes(out)
+}
+
+// IsZero returns true if the quantity is equal to zero.
+func (q *Quantity) IsZero() bool {
+ if q.d.Dec != nil {
+ return q.d.Dec.Sign() == 0
+ }
+ return q.i.value == 0
+}
+
+// Sign returns 0 if the quantity is zero, -1 if the quantity is less than zero, or 1 if the
+// quantity is greater than zero.
+func (q *Quantity) Sign() int {
+ if q.d.Dec != nil {
+ return q.d.Dec.Sign()
+ }
+ return q.i.Sign()
+}
+
+// AsScaled returns the current value, rounded up to the provided scale, and returns
+// false if the scale resulted in a loss of precision.
+func (q *Quantity) AsScale(scale Scale) (CanonicalValue, bool) {
+ if q.d.Dec != nil {
+ return q.d.AsScale(scale)
+ }
+ return q.i.AsScale(scale)
+}
+
+// RoundUp updates the quantity to the provided scale, ensuring that the value is at
+// least 1. False is returned if the rounding operation resulted in a loss of precision.
+// Negative numbers are rounded away from zero (-9 scale 1 rounds to -10).
+func (q *Quantity) RoundUp(scale Scale) bool {
+ if q.d.Dec != nil {
+ q.s = ""
+ d, exact := q.d.AsScale(scale)
+ q.d = d
+ return exact
+ }
+ // avoid clearing the string value if we have already calculated it
+ if q.i.scale >= scale {
+ return true
+ }
+ q.s = ""
+ i, exact := q.i.AsScale(scale)
+ q.i = i
+ return exact
+}
+
+// Add adds the provide y quantity to the current value. If the current value is zero,
+// the format of the quantity will be updated to the format of y.
+func (q *Quantity) Add(y Quantity) {
+ q.s = ""
+ if q.d.Dec == nil && y.d.Dec == nil {
+ if q.i.value == 0 {
+ q.Format = y.Format
+ }
+ if q.i.Add(y.i) {
+ return
+ }
+ } else if q.IsZero() {
+ q.Format = y.Format
+ }
+ q.ToDec().d.Dec.Add(q.d.Dec, y.AsDec())
+}
+
+// Sub subtracts the provided quantity from the current value in place. If the current
+// value is zero, the format of the quantity will be updated to the format of y.
+func (q *Quantity) Sub(y Quantity) {
+ q.s = ""
+ if q.IsZero() {
+ q.Format = y.Format
+ }
+ if q.d.Dec == nil && y.d.Dec == nil && q.i.Sub(y.i) {
+ return
+ }
+ q.ToDec().d.Dec.Sub(q.d.Dec, y.AsDec())
+}
+
+// Cmp returns 0 if the quantity is equal to y, -1 if the quantity is less than y, or 1 if the
+// quantity is greater than y.
+func (q *Quantity) Cmp(y Quantity) int {
+ if q.d.Dec == nil && y.d.Dec == nil {
+ return q.i.Cmp(y.i)
+ }
+ return q.AsDec().Cmp(y.AsDec())
+}
+
+// CmpInt64 returns 0 if the quantity is equal to y, -1 if the quantity is less than y, or 1 if the
+// quantity is greater than y.
+func (q *Quantity) CmpInt64(y int64) int {
+ if q.d.Dec != nil {
+ return q.d.Dec.Cmp(inf.NewDec(y, inf.Scale(0)))
+ }
+ return q.i.Cmp(int64Amount{value: y})
+}
+
+// Neg sets quantity to be the negative value of itself.
+func (q *Quantity) Neg() {
+ q.s = ""
+ if q.d.Dec == nil {
+ q.i.value = -q.i.value
+ return
+ }
+ q.d.Dec.Neg(q.d.Dec)
+}
+
+// int64QuantityExpectedBytes is the expected width in bytes of the canonical string representation
+// of most Quantity values.
+const int64QuantityExpectedBytes = 18
+
+// String formats the Quantity as a string, caching the result if not calculated.
+// String is an expensive operation and caching this result significantly reduces the cost of
+// normal parse / marshal operations on Quantity.
+func (q *Quantity) String() string {
+ if len(q.s) == 0 {
+ result := make([]byte, 0, int64QuantityExpectedBytes)
+ number, suffix := q.CanonicalizeBytes(result)
+ number = append(number, suffix...)
+ q.s = string(number)
+ }
+ return q.s
+}
+
+// MarshalJSON implements the json.Marshaller interface.
+func (q Quantity) MarshalJSON() ([]byte, error) {
+ if len(q.s) > 0 {
+ out := make([]byte, len(q.s)+2)
+ out[0], out[len(out)-1] = '"', '"'
+ copy(out[1:], q.s)
+ return out, nil
+ }
+ result := make([]byte, int64QuantityExpectedBytes, int64QuantityExpectedBytes)
+ result[0] = '"'
+ number, suffix := q.CanonicalizeBytes(result[1:1])
+ // if the same slice was returned to us that we passed in, avoid another allocation by copying number into
+ // the source slice and returning that
+ if len(number) > 0 && &number[0] == &result[1] && (len(number)+len(suffix)+2) <= int64QuantityExpectedBytes {
+ number = append(number, suffix...)
+ number = append(number, '"')
+ return result[:1+len(number)], nil
+ }
+ // if CanonicalizeBytes needed more space than our slice provided, we may need to allocate again so use
+ // append
+ result = result[:1]
+ result = append(result, number...)
+ result = append(result, suffix...)
+ result = append(result, '"')
+ return result, nil
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface.
+// TODO: Remove support for leading/trailing whitespace
+func (q *Quantity) UnmarshalJSON(value []byte) error {
+ l := len(value)
+ if l == 4 && bytes.Equal(value, []byte("null")) {
+ q.d.Dec = nil
+ q.i = int64Amount{}
+ return nil
+ }
+ if l >= 2 && value[0] == '"' && value[l-1] == '"' {
+ value = value[1 : l-1]
+ }
+
+ parsed, err := ParseQuantity(strings.TrimSpace(string(value)))
+ if err != nil {
+ return err
+ }
+
+ // This copy is safe because parsed will not be referred to again.
+ *q = parsed
+ return nil
+}
+
+// NewQuantity returns a new Quantity representing the given
+// value in the given format.
+func NewQuantity(value int64, format Format) *Quantity {
+ return &Quantity{
+ i: int64Amount{value: value},
+ Format: format,
+ }
+}
+
+// NewMilliQuantity returns a new Quantity representing the given
+// value * 1/1000 in the given format. Note that BinarySI formatting
+// will round fractional values, and will be changed to DecimalSI for
+// values x where (-1 < x < 1) && (x != 0).
+func NewMilliQuantity(value int64, format Format) *Quantity {
+ return &Quantity{
+ i: int64Amount{value: value, scale: -3},
+ Format: format,
+ }
+}
+
+// NewScaledQuantity returns a new Quantity representing the given
+// value * 10^scale in DecimalSI format.
+func NewScaledQuantity(value int64, scale Scale) *Quantity {
+ return &Quantity{
+ i: int64Amount{value: value, scale: scale},
+ Format: DecimalSI,
+ }
+}
+
+// Value returns the value of q; any fractional part will be lost.
+func (q *Quantity) Value() int64 {
+ return q.ScaledValue(0)
+}
+
+// MilliValue returns the value of ceil(q * 1000); this could overflow an int64;
+// if that's a concern, call Value() first to verify the number is small enough.
+func (q *Quantity) MilliValue() int64 {
+ return q.ScaledValue(Milli)
+}
+
+// ScaledValue returns the value of ceil(q * 10^scale); this could overflow an int64.
+// To detect overflow, call Value() first and verify the expected magnitude.
+func (q *Quantity) ScaledValue(scale Scale) int64 {
+ if q.d.Dec == nil {
+ i, _ := q.i.AsScaledInt64(scale)
+ return i
+ }
+ dec := q.d.Dec
+ return scaledValue(dec.UnscaledBig(), int(dec.Scale()), int(scale.infScale()))
+}
+
+// Set sets q's value to be value.
+func (q *Quantity) Set(value int64) {
+ q.SetScaled(value, 0)
+}
+
+// SetMilli sets q's value to be value * 1/1000.
+func (q *Quantity) SetMilli(value int64) {
+ q.SetScaled(value, Milli)
+}
+
+// SetScaled sets q's value to be value * 10^scale
+func (q *Quantity) SetScaled(value int64, scale Scale) {
+ q.s = ""
+ q.d.Dec = nil
+ q.i = int64Amount{value: value, scale: scale}
+}
+
+// Copy is a convenience function that makes a deep copy for you. Non-deep
+// copies of quantities share pointers and you will regret that.
+func (q *Quantity) Copy() *Quantity {
+ if q.d.Dec == nil {
+ return &Quantity{
+ s: q.s,
+ i: q.i,
+ Format: q.Format,
+ }
+ }
+ tmp := &inf.Dec{}
+ return &Quantity{
+ s: q.s,
+ d: infDecAmount{tmp.Set(q.d.Dec)},
+ Format: q.Format,
+ }
+}
+
+// qFlag is a helper type for the Flag function
+type qFlag struct {
+ dest *Quantity
+}
+
+// Sets the value of the internal Quantity. (used by flag & pflag)
+func (qf qFlag) Set(val string) error {
+ q, err := ParseQuantity(val)
+ if err != nil {
+ return err
+ }
+ // This copy is OK because q will not be referenced again.
+ *qf.dest = q
+ return nil
+}
+
+// Converts the value of the internal Quantity to a string. (used by flag & pflag)
+func (qf qFlag) String() string {
+ return qf.dest.String()
+}
+
+// States the type of flag this is (Quantity). (used by pflag)
+func (qf qFlag) Type() string {
+ return "quantity"
+}
+
+// QuantityFlag is a helper that makes a quantity flag (using standard flag package).
+// Will panic if defaultValue is not a valid quantity.
+func QuantityFlag(flagName, defaultValue, description string) *Quantity {
+ q := MustParse(defaultValue)
+ flag.Var(NewQuantityFlagValue(&q), flagName, description)
+ return &q
+}
+
+// NewQuantityFlagValue returns an object that can be used to back a flag,
+// pointing at the given Quantity variable.
+func NewQuantityFlagValue(q *Quantity) flag.Value {
+ return qFlag{q}
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go b/vendor/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go
new file mode 100644
index 0000000000000000000000000000000000000000..240294682cff7f4abcac4264b5ab07fbe2df630f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/quantity_proto.go
@@ -0,0 +1,284 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 resource
+
+import (
+ "fmt"
+ "io"
+
+ "github.com/gogo/protobuf/proto"
+)
+
+var _ proto.Sizer = &Quantity{}
+
+func (m *Quantity) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+// MarshalTo is a customized version of the generated Protobuf unmarshaler for a struct
+// with a single string field.
+func (m *Quantity) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+
+ data[i] = 0xa
+ i++
+ // BEGIN CUSTOM MARSHAL
+ out := m.String()
+ i = encodeVarintGenerated(data, i, uint64(len(out)))
+ i += copy(data[i:], out)
+ // END CUSTOM MARSHAL
+
+ return i, nil
+}
+
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+
+func (m *Quantity) Size() (n int) {
+ var l int
+ _ = l
+
+ // BEGIN CUSTOM SIZE
+ l = len(m.String())
+ // END CUSTOM SIZE
+
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+
+// Unmarshal is a customized version of the generated Protobuf unmarshaler for a struct
+// with a single string field.
+func (m *Quantity) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Quantity: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Quantity: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ s := string(data[iNdEx:postIndex])
+
+ // BEGIN CUSTOM DECODE
+ p, err := ParseQuantity(s)
+ if err != nil {
+ return err
+ }
+ *m = p
+ // END CUSTOM DECODE
+
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/scale_int.go b/vendor/k8s.io/kubernetes/pkg/api/resource/scale_int.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/scale_int.go
rename to vendor/k8s.io/kubernetes/pkg/api/resource/scale_int.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/suffix.go b/vendor/k8s.io/kubernetes/pkg/api/resource/suffix.go
similarity index 59%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/suffix.go
rename to vendor/k8s.io/kubernetes/pkg/api/resource/suffix.go
index 529712365d78105a9fc81e8dd36397d474d9ce2c..0aa2ce2bf60ec5b892d9f408c1390ba51ddb2430 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource/suffix.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource/suffix.go
@@ -24,8 +24,9 @@ type suffix string
// suffixer can interpret and construct suffixes.
type suffixer interface {
- interpret(suffix) (base, exponent int, fmt Format, ok bool)
- construct(base, exponent int, fmt Format) (s suffix, ok bool)
+ interpret(suffix) (base, exponent int32, fmt Format, ok bool)
+ construct(base, exponent int32, fmt Format) (s suffix, ok bool)
+ constructBytes(base, exponent int32, fmt Format) (s []byte, ok bool)
}
// quantitySuffixer handles suffixes for all three formats that quantity
@@ -33,12 +34,13 @@ type suffixer interface {
var quantitySuffixer = newSuffixer()
type bePair struct {
- base, exponent int
+ base, exponent int32
}
type listSuffixer struct {
- suffixToBE map[suffix]bePair
- beToSuffix map[bePair]suffix
+ suffixToBE map[suffix]bePair
+ beToSuffix map[bePair]suffix
+ beToSuffixBytes map[bePair][]byte
}
func (ls *listSuffixer) addSuffix(s suffix, pair bePair) {
@@ -48,11 +50,15 @@ func (ls *listSuffixer) addSuffix(s suffix, pair bePair) {
if ls.beToSuffix == nil {
ls.beToSuffix = map[bePair]suffix{}
}
+ if ls.beToSuffixBytes == nil {
+ ls.beToSuffixBytes = map[bePair][]byte{}
+ }
ls.suffixToBE[s] = pair
ls.beToSuffix[pair] = s
+ ls.beToSuffixBytes[pair] = []byte(s)
}
-func (ls *listSuffixer) lookup(s suffix) (base, exponent int, ok bool) {
+func (ls *listSuffixer) lookup(s suffix) (base, exponent int32, ok bool) {
pair, ok := ls.suffixToBE[s]
if !ok {
return 0, 0, false
@@ -60,19 +66,50 @@ func (ls *listSuffixer) lookup(s suffix) (base, exponent int, ok bool) {
return pair.base, pair.exponent, true
}
-func (ls *listSuffixer) construct(base, exponent int) (s suffix, ok bool) {
+func (ls *listSuffixer) construct(base, exponent int32) (s suffix, ok bool) {
s, ok = ls.beToSuffix[bePair{base, exponent}]
return
}
+func (ls *listSuffixer) constructBytes(base, exponent int32) (s []byte, ok bool) {
+ s, ok = ls.beToSuffixBytes[bePair{base, exponent}]
+ return
+}
+
type suffixHandler struct {
decSuffixes listSuffixer
binSuffixes listSuffixer
}
+type fastLookup struct {
+ *suffixHandler
+}
+
+func (l fastLookup) interpret(s suffix) (base, exponent int32, format Format, ok bool) {
+ switch s {
+ case "":
+ return 10, 0, DecimalSI, true
+ case "n":
+ return 10, -9, DecimalSI, true
+ case "u":
+ return 10, -6, DecimalSI, true
+ case "m":
+ return 10, -3, DecimalSI, true
+ case "k":
+ return 10, 3, DecimalSI, true
+ case "M":
+ return 10, 6, DecimalSI, true
+ case "G":
+ return 10, 9, DecimalSI, true
+ }
+ return l.suffixHandler.interpret(s)
+}
+
func newSuffixer() suffixer {
sh := &suffixHandler{}
+ // IMPORTANT: if you change this section you must change fastLookup
+
sh.binSuffixes.addSuffix("Ki", bePair{2, 10})
sh.binSuffixes.addSuffix("Mi", bePair{2, 20})
sh.binSuffixes.addSuffix("Gi", bePair{2, 30})
@@ -94,10 +131,10 @@ func newSuffixer() suffixer {
sh.decSuffixes.addSuffix("P", bePair{10, 15})
sh.decSuffixes.addSuffix("E", bePair{10, 18})
- return sh
+ return fastLookup{sh}
}
-func (sh *suffixHandler) construct(base, exponent int, fmt Format) (s suffix, ok bool) {
+func (sh *suffixHandler) construct(base, exponent int32, fmt Format) (s suffix, ok bool) {
switch fmt {
case DecimalSI:
return sh.decSuffixes.construct(base, exponent)
@@ -115,7 +152,32 @@ func (sh *suffixHandler) construct(base, exponent int, fmt Format) (s suffix, ok
return "", false
}
-func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int, fmt Format, ok bool) {
+func (sh *suffixHandler) constructBytes(base, exponent int32, format Format) (s []byte, ok bool) {
+ switch format {
+ case DecimalSI:
+ return sh.decSuffixes.constructBytes(base, exponent)
+ case BinarySI:
+ return sh.binSuffixes.constructBytes(base, exponent)
+ case DecimalExponent:
+ if base != 10 {
+ return nil, false
+ }
+ if exponent == 0 {
+ return nil, true
+ }
+ result := make([]byte, 8, 8)
+ result[0] = 'e'
+ number := strconv.AppendInt(result[1:1], int64(exponent), 10)
+ if &result[1] == &number[0] {
+ return result[:1+len(number)], true
+ }
+ result = append(result[:1], number...)
+ return result, true
+ }
+ return nil, false
+}
+
+func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int32, fmt Format, ok bool) {
// Try lookup tables first
if b, e, ok := sh.decSuffixes.lookup(suffix); ok {
return b, e, DecimalSI, true
@@ -129,7 +191,7 @@ func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int, fmt Forma
if err != nil {
return 0, 0, DecimalExponent, false
}
- return 10, int(parsed), DecimalExponent, true
+ return 10, int32(parsed), DecimalExponent, true
}
return 0, 0, DecimalExponent, false
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource_helpers.go b/vendor/k8s.io/kubernetes/pkg/api/resource_helpers.go
similarity index 51%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource_helpers.go
rename to vendor/k8s.io/kubernetes/pkg/api/resource_helpers.go
index 7a98a4c2f07012cf895ae5ebe7fa8ce8fd496db9..4c55b120e1444156984fc21aa59032fea00e42ef 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/resource_helpers.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/resource_helpers.go
@@ -18,6 +18,7 @@ package api
import (
"k8s.io/kubernetes/pkg/api/resource"
+ "k8s.io/kubernetes/pkg/api/unversioned"
)
// Returns string version of ResourceName.
@@ -48,6 +49,13 @@ func (self *ResourceList) Pods() *resource.Quantity {
return &resource.Quantity{}
}
+func (self *ResourceList) NvidiaGPU() *resource.Quantity {
+ if val, ok := (*self)[ResourceNvidiaGPU]; ok {
+ return &val
+ }
+ return &resource.Quantity{}
+}
+
func GetContainerStatus(statuses []ContainerStatus, name string) (ContainerStatus, bool) {
for i := range statuses {
if statuses[i].Name == name {
@@ -80,12 +88,66 @@ func IsPodReadyConditionTrue(status PodStatus) bool {
// Extracts the pod ready condition from the given status and returns that.
// Returns nil if the condition is not present.
func GetPodReadyCondition(status PodStatus) *PodCondition {
- for i, c := range status.Conditions {
- if c.Type == PodReady {
- return &status.Conditions[i]
+ _, condition := GetPodCondition(&status, PodReady)
+ return condition
+}
+
+// GetPodCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the the index of the located condition.
+func GetPodCondition(status *PodStatus, conditionType PodConditionType) (int, *PodCondition) {
+ if status == nil {
+ return -1, nil
+ }
+ for i := range status.Conditions {
+ if status.Conditions[i].Type == conditionType {
+ return i, &status.Conditions[i]
+ }
+ }
+ return -1, nil
+}
+
+// GetNodeCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the the index of the located condition.
+func GetNodeCondition(status *NodeStatus, conditionType NodeConditionType) (int, *NodeCondition) {
+ if status == nil {
+ return -1, nil
+ }
+ for i := range status.Conditions {
+ if status.Conditions[i].Type == conditionType {
+ return i, &status.Conditions[i]
+ }
+ }
+ return -1, nil
+}
+
+// Updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
+// status has changed.
+// Returns true if pod condition has changed or has been added.
+func UpdatePodCondition(status *PodStatus, condition *PodCondition) bool {
+ condition.LastTransitionTime = unversioned.Now()
+ // Try to find this pod condition.
+ conditionIndex, oldCondition := GetPodCondition(status, condition.Type)
+
+ if oldCondition == nil {
+ // We are adding new pod condition.
+ status.Conditions = append(status.Conditions, *condition)
+ return true
+ } else {
+ // We are updating an existing condition, so we need to check if it has changed.
+ if condition.Status == oldCondition.Status {
+ condition.LastTransitionTime = oldCondition.LastTransitionTime
}
+
+ isEqual := condition.Status == oldCondition.Status &&
+ condition.Reason == oldCondition.Reason &&
+ condition.Message == oldCondition.Message &&
+ condition.LastProbeTime.Equal(oldCondition.LastProbeTime) &&
+ condition.LastTransitionTime.Equal(oldCondition.LastTransitionTime)
+
+ status.Conditions[conditionIndex] = *condition
+ // Return true if one of the fields have changed.
+ return !isEqual
}
- return nil
}
// IsNodeReady returns true if a node is ready; false otherwise.
@@ -106,15 +168,40 @@ func PodRequestsAndLimits(pod *Pod) (reqs map[ResourceName]resource.Quantity, li
for name, quantity := range container.Resources.Requests {
if value, ok := reqs[name]; !ok {
reqs[name] = *quantity.Copy()
- } else if err = value.Add(quantity); err != nil {
- return nil, nil, err
+ } else {
+ value.Add(quantity)
+ reqs[name] = value
}
}
for name, quantity := range container.Resources.Limits {
if value, ok := limits[name]; !ok {
limits[name] = *quantity.Copy()
- } else if err = value.Add(quantity); err != nil {
- return nil, nil, err
+ } else {
+ value.Add(quantity)
+ limits[name] = value
+ }
+ }
+ }
+ // init containers define the minimum of any resource
+ for _, container := range pod.Spec.InitContainers {
+ for name, quantity := range container.Resources.Requests {
+ value, ok := reqs[name]
+ if !ok {
+ reqs[name] = *quantity.Copy()
+ continue
+ }
+ if quantity.Cmp(value) > 0 {
+ reqs[name] = *quantity.Copy()
+ }
+ }
+ for name, quantity := range container.Resources.Limits {
+ value, ok := limits[name]
+ if !ok {
+ limits[name] = *quantity.Copy()
+ continue
+ }
+ if quantity.Cmp(value) > 0 {
+ limits[name] = *quantity.Copy()
}
}
}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/rest/create.go b/vendor/k8s.io/kubernetes/pkg/api/rest/create.go
new file mode 100644
index 0000000000000000000000000000000000000000..fa95b7f93f230cb13850c557bea36465038374f8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/create.go
@@ -0,0 +1,126 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 rest
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/validation"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+// RESTCreateStrategy defines the minimum validation, accepted input, and
+// name generation behavior to create an object that follows Kubernetes
+// API conventions.
+type RESTCreateStrategy interface {
+ runtime.ObjectTyper
+ // The name generate is used when the standard GenerateName field is set.
+ // The NameGenerator will be invoked prior to validation.
+ api.NameGenerator
+
+ // NamespaceScoped returns true if the object must be within a namespace.
+ NamespaceScoped() bool
+ // PrepareForCreate is invoked on create before validation to normalize
+ // the object. For example: remove fields that are not to be persisted,
+ // sort order-insensitive list fields, etc. This should not remove fields
+ // whose presence would be considered a validation error.
+ PrepareForCreate(obj runtime.Object)
+ // Validate is invoked after default fields in the object have been filled in before
+ // the object is persisted. This method should not mutate the object.
+ Validate(ctx api.Context, obj runtime.Object) field.ErrorList
+ // Canonicalize is invoked after validation has succeeded but before the
+ // object has been persisted. This method may mutate the object.
+ Canonicalize(obj runtime.Object)
+}
+
+// BeforeCreate ensures that common operations for all resources are performed on creation. It only returns
+// errors that can be converted to api.Status. It invokes PrepareForCreate, then GenerateName, then Validate.
+// It returns nil if the object should be created.
+func BeforeCreate(strategy RESTCreateStrategy, ctx api.Context, obj runtime.Object) error {
+ objectMeta, kind, kerr := objectMetaAndKind(strategy, obj)
+ if kerr != nil {
+ return kerr
+ }
+
+ if strategy.NamespaceScoped() {
+ if !api.ValidNamespace(ctx, objectMeta) {
+ return errors.NewBadRequest("the namespace of the provided object does not match the namespace sent on the request")
+ }
+ } else {
+ objectMeta.Namespace = api.NamespaceNone
+ }
+ objectMeta.DeletionTimestamp = nil
+ objectMeta.DeletionGracePeriodSeconds = nil
+ strategy.PrepareForCreate(obj)
+ api.FillObjectMetaSystemFields(ctx, objectMeta)
+ api.GenerateName(strategy, objectMeta)
+
+ if errs := strategy.Validate(ctx, obj); len(errs) > 0 {
+ return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+ }
+
+ // Custom validation (including name validation) passed
+ // Now run common validation on object meta
+ // Do this *after* custom validation so that specific error messages are shown whenever possible
+ if errs := validation.ValidateObjectMeta(objectMeta, strategy.NamespaceScoped(), validation.ValidatePathSegmentName, field.NewPath("metadata")); len(errs) > 0 {
+ return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+ }
+
+ strategy.Canonicalize(obj)
+
+ return nil
+}
+
+// CheckGeneratedNameError checks whether an error that occurred creating a resource is due
+// to generation being unable to pick a valid name.
+func CheckGeneratedNameError(strategy RESTCreateStrategy, err error, obj runtime.Object) error {
+ if !errors.IsAlreadyExists(err) {
+ return err
+ }
+
+ objectMeta, kind, kerr := objectMetaAndKind(strategy, obj)
+ if kerr != nil {
+ return kerr
+ }
+
+ if len(objectMeta.GenerateName) == 0 {
+ return err
+ }
+
+ return errors.NewServerTimeoutForKind(kind.GroupKind(), "POST", 0)
+}
+
+// objectMetaAndKind retrieves kind and ObjectMeta from a runtime object, or returns an error.
+func objectMetaAndKind(typer runtime.ObjectTyper, obj runtime.Object) (*api.ObjectMeta, unversioned.GroupVersionKind, error) {
+ objectMeta, err := api.ObjectMetaFor(obj)
+ if err != nil {
+ return nil, unversioned.GroupVersionKind{}, errors.NewInternalError(err)
+ }
+ kinds, _, err := typer.ObjectKinds(obj)
+ if err != nil {
+ return nil, unversioned.GroupVersionKind{}, errors.NewInternalError(err)
+ }
+ return objectMeta, kinds[0], nil
+}
+
+// NamespaceScopedStrategy has a method to tell if the object must be in a namespace.
+type NamespaceScopedStrategy interface {
+ // NamespaceScoped returns if the object must be in a namespace.
+ NamespaceScoped() bool
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/rest/delete.go b/vendor/k8s.io/kubernetes/pkg/api/rest/delete.go
new file mode 100644
index 0000000000000000000000000000000000000000..34965d52fe8e9d256617c1b8dd5a6de4bf2dd90a
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/delete.go
@@ -0,0 +1,93 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 rest
+
+import (
+ "fmt"
+ "time"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// RESTDeleteStrategy defines deletion behavior on an object that follows Kubernetes
+// API conventions.
+type RESTDeleteStrategy interface {
+ runtime.ObjectTyper
+}
+
+// RESTGracefulDeleteStrategy must be implemented by the registry that supports
+// graceful deletion.
+type RESTGracefulDeleteStrategy interface {
+ // CheckGracefulDelete should return true if the object can be gracefully deleted and set
+ // any default values on the DeleteOptions.
+ CheckGracefulDelete(obj runtime.Object, options *api.DeleteOptions) bool
+}
+
+// BeforeDelete tests whether the object can be gracefully deleted. If graceful is set the object
+// should be gracefully deleted, if gracefulPending is set the object has already been gracefully deleted
+// (and the provided grace period is longer than the time to deletion), and an error is returned if the
+// condition cannot be checked or the gracePeriodSeconds is invalid. The options argument may be updated with
+// default values if graceful is true.
+func BeforeDelete(strategy RESTDeleteStrategy, ctx api.Context, obj runtime.Object, options *api.DeleteOptions) (graceful, gracefulPending bool, err error) {
+ objectMeta, gvk, kerr := objectMetaAndKind(strategy, obj)
+ if kerr != nil {
+ return false, false, kerr
+ }
+ // Checking the Preconditions here to fail early. They'll be enforced later on when we actually do the deletion, too.
+ if options.Preconditions != nil && options.Preconditions.UID != nil && *options.Preconditions.UID != objectMeta.UID {
+ return false, false, errors.NewConflict(unversioned.GroupResource{Group: gvk.Group, Resource: gvk.Kind}, objectMeta.Name, fmt.Errorf("the UID in the precondition (%s) does not match the UID in record (%s). The object might have been deleted and then recreated", *options.Preconditions.UID, objectMeta.UID))
+ }
+ gracefulStrategy, ok := strategy.(RESTGracefulDeleteStrategy)
+ if !ok {
+ return false, false, nil
+ }
+ // if the object is already being deleted
+ if objectMeta.DeletionTimestamp != nil {
+ // if we are already being deleted, we may only shorten the deletion grace period
+ // this means the object was gracefully deleted previously but deletionGracePeriodSeconds was not set,
+ // so we force deletion immediately
+ if objectMeta.DeletionGracePeriodSeconds == nil {
+ return false, false, nil
+ }
+ // only a shorter grace period may be provided by a user
+ if options.GracePeriodSeconds != nil {
+ period := int64(*options.GracePeriodSeconds)
+ if period > *objectMeta.DeletionGracePeriodSeconds {
+ return false, true, nil
+ }
+ now := unversioned.NewTime(unversioned.Now().Add(time.Second * time.Duration(*options.GracePeriodSeconds)))
+ objectMeta.DeletionTimestamp = &now
+ objectMeta.DeletionGracePeriodSeconds = &period
+ options.GracePeriodSeconds = &period
+ return true, false, nil
+ }
+ // graceful deletion is pending, do nothing
+ options.GracePeriodSeconds = objectMeta.DeletionGracePeriodSeconds
+ return false, true, nil
+ }
+
+ if !gracefulStrategy.CheckGracefulDelete(obj, options) {
+ return false, false, nil
+ }
+ now := unversioned.NewTime(unversioned.Now().Add(time.Second * time.Duration(*options.GracePeriodSeconds)))
+ objectMeta.DeletionTimestamp = &now
+ objectMeta.DeletionGracePeriodSeconds = options.GracePeriodSeconds
+ return true, false, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/doc.go b/vendor/k8s.io/kubernetes/pkg/api/rest/doc.go
similarity index 82%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/rest/doc.go
index 32ce7c098d96817925d5c0ab86dc9359ed94f7bd..8fed0e9f486ae7dbc82826a41144f550682009c8 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/doc.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/doc.go
@@ -14,6 +14,5 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package json implements a simple encoder and decoder for streams
-// of watch events over io.Writer/Readers
-package json
+// Package rest defines common logic around changes to Kubernetes resources.
+package rest
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/api/rest/export.go
similarity index 62%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/rest/export.go
index 3ad4f279969554536fbdee8b21f83c0efc1af6fc..e12f65de3c76bdd6720ed8df94f207b09315021b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/export.go
@@ -14,16 +14,15 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
+package rest
-package autoscaling
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
-import api "k8s.io/kubernetes/pkg/api"
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs()
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
+// RESTExportStrategy is the interface that defines how to export a Kubernetes object
+type RESTExportStrategy interface {
+ // Export strips fields that can not be set by the user. If 'exact' is false
+ // fields specific to the cluster are also stripped
+ Export(obj runtime.Object, exact bool) error
}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/rest/rest.go b/vendor/k8s.io/kubernetes/pkg/api/rest/rest.go
new file mode 100644
index 0000000000000000000000000000000000000000..4d5b5ba977c28300050f017be4a308d3a759dea0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/rest.go
@@ -0,0 +1,306 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 rest
+
+import (
+ "io"
+ "net/http"
+ "net/url"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+//TODO:
+// Storage interfaces need to be separated into two groups; those that operate
+// on collections and those that operate on individually named items.
+// Collection interfaces:
+// (Method: Current -> Proposed)
+// GET: Lister -> CollectionGetter
+// WATCH: Watcher -> CollectionWatcher
+// CREATE: Creater -> CollectionCreater
+// DELETE: (n/a) -> CollectionDeleter
+// UPDATE: (n/a) -> CollectionUpdater
+//
+// Single item interfaces:
+// (Method: Current -> Proposed)
+// GET: Getter -> NamedGetter
+// WATCH: (n/a) -> NamedWatcher
+// CREATE: (n/a) -> NamedCreater
+// DELETE: Deleter -> NamedDeleter
+// UPDATE: Update -> NamedUpdater
+
+// Storage is a generic interface for RESTful storage services.
+// Resources which are exported to the RESTful API of apiserver need to implement this interface. It is expected
+// that objects may implement any of the below interfaces.
+type Storage interface {
+ // New returns an empty object that can be used with Create and Update after request data has been put into it.
+ // This object must be a pointer type for use with Codec.DecodeInto([]byte, runtime.Object)
+ New() runtime.Object
+}
+
+// KindProvider specifies a different kind for its API than for its internal storage. This is necessary for external
+// objects that are not compiled into the api server. For such objects, there is no in-memory representation for
+// the object, so they must be represented as generic objects (e.g. runtime.Unknown), but when we present the object as part of
+// API discovery we want to present the specific kind, not the generic internal representation.
+type KindProvider interface {
+ Kind() string
+}
+
+// Lister is an object that can retrieve resources that match the provided field and label criteria.
+type Lister interface {
+ // NewList returns an empty object that can be used with the List call.
+ // This object must be a pointer type for use with Codec.DecodeInto([]byte, runtime.Object)
+ NewList() runtime.Object
+ // List selects resources in the storage which match to the selector. 'options' can be nil.
+ List(ctx api.Context, options *api.ListOptions) (runtime.Object, error)
+}
+
+// Exporter is an object that knows how to strip a RESTful resource for export
+type Exporter interface {
+ // Export an object. Fields that are not user specified (e.g. Status, ObjectMeta.ResourceVersion) are stripped out
+ // Returns the stripped object. If 'exact' is true, fields that are specific to the cluster (e.g. namespace) are
+ // retained, otherwise they are stripped also.
+ Export(ctx api.Context, name string, opts unversioned.ExportOptions) (runtime.Object, error)
+}
+
+// Getter is an object that can retrieve a named RESTful resource.
+type Getter interface {
+ // Get finds a resource in the storage by name and returns it.
+ // Although it can return an arbitrary error value, IsNotFound(err) is true for the
+ // returned error value err when the specified resource is not found.
+ Get(ctx api.Context, name string) (runtime.Object, error)
+}
+
+// GetterWithOptions is an object that retrieve a named RESTful resource and takes
+// additional options on the get request. It allows a caller to also receive the
+// subpath of the GET request.
+type GetterWithOptions interface {
+ // Get finds a resource in the storage by name and returns it.
+ // Although it can return an arbitrary error value, IsNotFound(err) is true for the
+ // returned error value err when the specified resource is not found.
+ // The options object passed to it is of the same type returned by the NewGetOptions
+ // method.
+ Get(ctx api.Context, name string, options runtime.Object) (runtime.Object, error)
+
+ // NewGetOptions returns an empty options object that will be used to pass
+ // options to the Get method. It may return a bool and a string, if true, the
+ // value of the request path below the object will be included as the named
+ // string in the serialization of the runtime object. E.g., returning "path"
+ // will convert the trailing request scheme value to "path" in the map[string][]string
+ // passed to the converter.
+ NewGetOptions() (runtime.Object, bool, string)
+}
+
+// Deleter is an object that can delete a named RESTful resource.
+type Deleter interface {
+ // Delete finds a resource in the storage and deletes it.
+ // Although it can return an arbitrary error value, IsNotFound(err) is true for the
+ // returned error value err when the specified resource is not found.
+ // Delete *may* return the object that was deleted, or a status object indicating additional
+ // information about deletion.
+ Delete(ctx api.Context, name string) (runtime.Object, error)
+}
+
+// GracefulDeleter knows how to pass deletion options to allow delayed deletion of a
+// RESTful object.
+type GracefulDeleter interface {
+ // Delete finds a resource in the storage and deletes it.
+ // If options are provided, the resource will attempt to honor them or return an invalid
+ // request error.
+ // Although it can return an arbitrary error value, IsNotFound(err) is true for the
+ // returned error value err when the specified resource is not found.
+ // Delete *may* return the object that was deleted, or a status object indicating additional
+ // information about deletion.
+ Delete(ctx api.Context, name string, options *api.DeleteOptions) (runtime.Object, error)
+}
+
+// GracefulDeleteAdapter adapts the Deleter interface to GracefulDeleter
+type GracefulDeleteAdapter struct {
+ Deleter
+}
+
+// Delete implements RESTGracefulDeleter in terms of Deleter
+func (w GracefulDeleteAdapter) Delete(ctx api.Context, name string, options *api.DeleteOptions) (runtime.Object, error) {
+ return w.Deleter.Delete(ctx, name)
+}
+
+// CollectionDeleter is an object that can delete a collection
+// of RESTful resources.
+type CollectionDeleter interface {
+ // DeleteCollection selects all resources in the storage matching given 'listOptions'
+ // and deletes them. If 'options' are provided, the resource will attempt to honor
+ // them or return an invalid request error.
+ // DeleteCollection may not be atomic - i.e. it may delete some objects and still
+ // return an error after it. On success, returns a list of deleted objects.
+ DeleteCollection(ctx api.Context, options *api.DeleteOptions, listOptions *api.ListOptions) (runtime.Object, error)
+}
+
+// Creater is an object that can create an instance of a RESTful object.
+type Creater interface {
+ // New returns an empty object that can be used with Create after request data has been put into it.
+ // This object must be a pointer type for use with Codec.DecodeInto([]byte, runtime.Object)
+ New() runtime.Object
+
+ // Create creates a new version of a resource.
+ Create(ctx api.Context, obj runtime.Object) (runtime.Object, error)
+}
+
+// NamedCreater is an object that can create an instance of a RESTful object using a name parameter.
+type NamedCreater interface {
+ // New returns an empty object that can be used with Create after request data has been put into it.
+ // This object must be a pointer type for use with Codec.DecodeInto([]byte, runtime.Object)
+ New() runtime.Object
+
+ // Create creates a new version of a resource. It expects a name parameter from the path.
+ // This is needed for create operations on subresources which include the name of the parent
+ // resource in the path.
+ Create(ctx api.Context, name string, obj runtime.Object) (runtime.Object, error)
+}
+
+// UpdatedObjectInfo provides information about an updated object to an Updater.
+// It requires access to the old object in order to return the newly updated object.
+type UpdatedObjectInfo interface {
+ // Returns preconditions built from the updated object, if applicable.
+ // May return nil, or a preconditions object containing nil fields,
+ // if no preconditions can be determined from the updated object.
+ Preconditions() *api.Preconditions
+
+ // UpdatedObject returns the updated object, given a context and old object.
+ // The only time an empty oldObj should be passed in is if a "create on update" is occurring (there is no oldObj).
+ UpdatedObject(ctx api.Context, oldObj runtime.Object) (newObj runtime.Object, err error)
+}
+
+// Updater is an object that can update an instance of a RESTful object.
+type Updater interface {
+ // New returns an empty object that can be used with Update after request data has been put into it.
+ // This object must be a pointer type for use with Codec.DecodeInto([]byte, runtime.Object)
+ New() runtime.Object
+
+ // Update finds a resource in the storage and updates it. Some implementations
+ // may allow updates creates the object - they should set the created boolean
+ // to true.
+ Update(ctx api.Context, name string, objInfo UpdatedObjectInfo) (runtime.Object, bool, error)
+}
+
+// CreaterUpdater is a storage object that must support both create and update.
+// Go prevents embedded interfaces that implement the same method.
+type CreaterUpdater interface {
+ Creater
+ Update(ctx api.Context, name string, objInfo UpdatedObjectInfo) (runtime.Object, bool, error)
+}
+
+// CreaterUpdater must satisfy the Updater interface.
+var _ Updater = CreaterUpdater(nil)
+
+// Patcher is a storage object that supports both get and update.
+type Patcher interface {
+ Getter
+ Updater
+}
+
+// Watcher should be implemented by all Storage objects that
+// want to offer the ability to watch for changes through the watch api.
+type Watcher interface {
+ // 'label' selects on labels; 'field' selects on the object's fields. Not all fields
+ // are supported; an error should be returned if 'field' tries to select on a field that
+ // isn't supported. 'resourceVersion' allows for continuing/starting a watch at a
+ // particular version.
+ Watch(ctx api.Context, options *api.ListOptions) (watch.Interface, error)
+}
+
+// StandardStorage is an interface covering the common verbs. Provided for testing whether a
+// resource satisfies the normal storage methods. Use Storage when passing opaque storage objects.
+type StandardStorage interface {
+ Getter
+ Lister
+ CreaterUpdater
+ GracefulDeleter
+ CollectionDeleter
+ Watcher
+}
+
+// Redirector know how to return a remote resource's location.
+type Redirector interface {
+ // ResourceLocation should return the remote location of the given resource, and an optional transport to use to request it, or an error.
+ ResourceLocation(ctx api.Context, id string) (remoteLocation *url.URL, transport http.RoundTripper, err error)
+}
+
+// Responder abstracts the normal response behavior for a REST method and is passed to callers that
+// may wish to handle the response directly in some cases, but delegate to the normal error or object
+// behavior in other cases.
+type Responder interface {
+ // Object writes the provided object to the response. Invoking this method multiple times is undefined.
+ Object(statusCode int, obj runtime.Object)
+ // Error writes the provided error to the response. This method may only be invoked once.
+ Error(err error)
+}
+
+// Connecter is a storage object that responds to a connection request.
+type Connecter interface {
+ // Connect returns an http.Handler that will handle the request/response for a given API invocation.
+ // The provided responder may be used for common API responses. The responder will write both status
+ // code and body, so the ServeHTTP method should exit after invoking the responder. The Handler will
+ // be used for a single API request and then discarded. The Responder is guaranteed to write to the
+ // same http.ResponseWriter passed to ServeHTTP.
+ Connect(ctx api.Context, id string, options runtime.Object, r Responder) (http.Handler, error)
+
+ // NewConnectOptions returns an empty options object that will be used to pass
+ // options to the Connect method. If nil, then a nil options object is passed to
+ // Connect. It may return a bool and a string. If true, the value of the request
+ // path below the object will be included as the named string in the serialization
+ // of the runtime object.
+ NewConnectOptions() (runtime.Object, bool, string)
+
+ // ConnectMethods returns the list of HTTP methods handled by Connect
+ ConnectMethods() []string
+}
+
+// ResourceStreamer is an interface implemented by objects that prefer to be streamed from the server
+// instead of decoded directly.
+type ResourceStreamer interface {
+ // InputStream should return an io.ReadCloser if the provided object supports streaming. The desired
+ // api version and a accept header (may be empty) are passed to the call. If no error occurs,
+ // the caller may return a flag indicating whether the result should be flushed as writes occur
+ // and a content type string that indicates the type of the stream.
+ // If a null stream is returned, a StatusNoContent response wil be generated.
+ InputStream(apiVersion, acceptHeader string) (stream io.ReadCloser, flush bool, mimeType string, err error)
+}
+
+// StorageMetadata is an optional interface that callers can implement to provide additional
+// information about their Storage objects.
+type StorageMetadata interface {
+ // ProducesMIMETypes returns a list of the MIME types the specified HTTP verb (GET, POST, DELETE,
+ // PATCH) can respond with.
+ ProducesMIMETypes(verb string) []string
+}
+
+// ConnectRequest is an object passed to admission control for Connect operations
+type ConnectRequest struct {
+ // Name is the name of the object on which the connect request was made
+ Name string
+
+ // Options is the options object passed to the connect request. See the NewConnectOptions method on Connecter
+ Options runtime.Object
+
+ // ResourcePath is the path for the resource in the REST server (ie. "pods/proxy")
+ ResourcePath string
+}
+
+func (obj *ConnectRequest) GetObjectKind() unversioned.ObjectKind { return unversioned.EmptyObjectKind }
diff --git a/vendor/k8s.io/kubernetes/pkg/api/rest/types.go b/vendor/k8s.io/kubernetes/pkg/api/rest/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e7f048ba516023e4d6044176700fb06a3520072
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/types.go
@@ -0,0 +1,42 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 rest
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// ObjectFunc is a function to act on a given object. An error may be returned
+// if the hook cannot be completed. An ObjectFunc may transform the provided
+// object.
+type ObjectFunc func(obj runtime.Object) error
+
+// AllFuncs returns an ObjectFunc that attempts to run all of the provided functions
+// in order, returning early if there are any errors.
+func AllFuncs(fns ...ObjectFunc) ObjectFunc {
+ return func(obj runtime.Object) error {
+ for _, fn := range fns {
+ if fn == nil {
+ continue
+ }
+ if err := fn(obj); err != nil {
+ return err
+ }
+ }
+ return nil
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/rest/update.go b/vendor/k8s.io/kubernetes/pkg/api/rest/update.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc5ed0c5f8668bbb4499ad5cd9e71b148003e96c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/rest/update.go
@@ -0,0 +1,175 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 rest
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/validation"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+// RESTUpdateStrategy defines the minimum validation, accepted input, and
+// name generation behavior to update an object that follows Kubernetes
+// API conventions. A resource may have many UpdateStrategies, depending on
+// the call pattern in use.
+type RESTUpdateStrategy interface {
+ runtime.ObjectTyper
+ // NamespaceScoped returns true if the object must be within a namespace.
+ NamespaceScoped() bool
+ // AllowCreateOnUpdate returns true if the object can be created by a PUT.
+ AllowCreateOnUpdate() bool
+ // PrepareForUpdate is invoked on update before validation to normalize
+ // the object. For example: remove fields that are not to be persisted,
+ // sort order-insensitive list fields, etc. This should not remove fields
+ // whose presence would be considered a validation error.
+ PrepareForUpdate(obj, old runtime.Object)
+ // ValidateUpdate is invoked after default fields in the object have been
+ // filled in before the object is persisted. This method should not mutate
+ // the object.
+ ValidateUpdate(ctx api.Context, obj, old runtime.Object) field.ErrorList
+ // Canonicalize is invoked after validation has succeeded but before the
+ // object has been persisted. This method may mutate the object.
+ Canonicalize(obj runtime.Object)
+ // AllowUnconditionalUpdate returns true if the object can be updated
+ // unconditionally (irrespective of the latest resource version), when
+ // there is no resource version specified in the object.
+ AllowUnconditionalUpdate() bool
+}
+
+// TODO: add other common fields that require global validation.
+func validateCommonFields(obj, old runtime.Object) (field.ErrorList, error) {
+ allErrs := field.ErrorList{}
+ objectMeta, err := api.ObjectMetaFor(obj)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get new object metadata: %v", err)
+ }
+ oldObjectMeta, err := api.ObjectMetaFor(old)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get old object metadata: %v", err)
+ }
+ allErrs = append(allErrs, validation.ValidateObjectMetaUpdate(objectMeta, oldObjectMeta, field.NewPath("metadata"))...)
+
+ return allErrs, nil
+}
+
+// BeforeUpdate ensures that common operations for all resources are performed on update. It only returns
+// errors that can be converted to api.Status. It will invoke update validation with the provided existing
+// and updated objects.
+func BeforeUpdate(strategy RESTUpdateStrategy, ctx api.Context, obj, old runtime.Object) error {
+ objectMeta, kind, kerr := objectMetaAndKind(strategy, obj)
+ if kerr != nil {
+ return kerr
+ }
+ if strategy.NamespaceScoped() {
+ if !api.ValidNamespace(ctx, objectMeta) {
+ return errors.NewBadRequest("the namespace of the provided object does not match the namespace sent on the request")
+ }
+ } else {
+ objectMeta.Namespace = api.NamespaceNone
+ }
+
+ strategy.PrepareForUpdate(obj, old)
+
+ // Ensure some common fields, like UID, are validated for all resources.
+ errs, err := validateCommonFields(obj, old)
+ if err != nil {
+ return errors.NewInternalError(err)
+ }
+
+ errs = append(errs, strategy.ValidateUpdate(ctx, obj, old)...)
+ if len(errs) > 0 {
+ return errors.NewInvalid(kind.GroupKind(), objectMeta.Name, errs)
+ }
+
+ strategy.Canonicalize(obj)
+
+ return nil
+}
+
+// TransformFunc is a function to transform and return newObj
+type TransformFunc func(ctx api.Context, newObj runtime.Object, oldObj runtime.Object) (transformedNewObj runtime.Object, err error)
+
+// defaultUpdatedObjectInfo implements UpdatedObjectInfo
+type defaultUpdatedObjectInfo struct {
+ // obj is the updated object
+ obj runtime.Object
+
+ // copier makes a copy of the object before returning it.
+ // this allows repeated calls to UpdatedObject() to return
+ // pristine data, even if the returned value is mutated.
+ copier runtime.ObjectCopier
+
+ // transformers is an optional list of transforming functions that modify or
+ // replace obj using information from the context, old object, or other sources.
+ transformers []TransformFunc
+}
+
+// DefaultUpdatedObjectInfo returns an UpdatedObjectInfo impl based on the specified object.
+func DefaultUpdatedObjectInfo(obj runtime.Object, copier runtime.ObjectCopier, transformers ...TransformFunc) UpdatedObjectInfo {
+ return &defaultUpdatedObjectInfo{obj, copier, transformers}
+}
+
+// Preconditions satisfies the UpdatedObjectInfo interface.
+func (i *defaultUpdatedObjectInfo) Preconditions() *api.Preconditions {
+ // Attempt to get the UID out of the object
+ accessor, err := meta.Accessor(i.obj)
+ if err != nil {
+ // If no UID can be read, no preconditions are possible
+ return nil
+ }
+
+ // If empty, no preconditions needed
+ uid := accessor.GetUID()
+ if len(uid) == 0 {
+ return nil
+ }
+
+ return &api.Preconditions{UID: &uid}
+}
+
+// UpdatedObject satisfies the UpdatedObjectInfo interface.
+// It returns a copy of the held obj, passed through any configured transformers.
+func (i *defaultUpdatedObjectInfo) UpdatedObject(ctx api.Context, oldObj runtime.Object) (runtime.Object, error) {
+ var err error
+ // Start with the configured object
+ newObj := i.obj
+
+ // If the original is non-nil (might be nil if the first transformer builds the object from the oldObj), make a copy,
+ // so we don't return the original. BeforeUpdate can mutate the returned object, doing things like clearing ResourceVersion.
+ // If we're re-called, we need to be able to return the pristine version.
+ if newObj != nil {
+ newObj, err = i.copier.Copy(newObj)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ // Allow any configured transformers to update the new object
+ for _, transformer := range i.transformers {
+ newObj, err = transformer(ctx, newObj, oldObj)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return newObj, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/service/annotations.go b/vendor/k8s.io/kubernetes/pkg/api/service/annotations.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/service/annotations.go
rename to vendor/k8s.io/kubernetes/pkg/api/service/annotations.go
diff --git a/vendor/k8s.io/kubernetes/pkg/api/service/util.go b/vendor/k8s.io/kubernetes/pkg/api/service/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..b6611d2370d136fe094a3c581010761e197b783d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/service/util.go
@@ -0,0 +1,68 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 service
+
+import (
+ "fmt"
+ "strings"
+
+ "k8s.io/kubernetes/pkg/api"
+ netsets "k8s.io/kubernetes/pkg/util/net/sets"
+)
+
+const (
+ defaultLoadBalancerSourceRanges = "0.0.0.0/0"
+)
+
+// IsAllowAll checks whether the netsets.IPNet allows traffic from 0.0.0.0/0
+func IsAllowAll(ipnets netsets.IPNet) bool {
+ for _, s := range ipnets.StringSlice() {
+ if s == "0.0.0.0/0" {
+ return true
+ }
+ }
+ return false
+}
+
+// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
+// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
+// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
+func GetLoadBalancerSourceRanges(service *api.Service) (netsets.IPNet, error) {
+ var ipnets netsets.IPNet
+ var err error
+ // if SourceRange field is specified, ignore sourceRange annotation
+ if len(service.Spec.LoadBalancerSourceRanges) > 0 {
+ specs := service.Spec.LoadBalancerSourceRanges
+ ipnets, err = netsets.ParseIPNets(specs...)
+
+ if err != nil {
+ return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
+ }
+ } else {
+ val := service.Annotations[AnnotationLoadBalancerSourceRangesKey]
+ val = strings.TrimSpace(val)
+ if val == "" {
+ val = defaultLoadBalancerSourceRanges
+ }
+ specs := strings.Split(val, ",")
+ ipnets, err = netsets.ParseIPNets(specs...)
+ if err != nil {
+ return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", AnnotationLoadBalancerSourceRangesKey, val)
+ }
+ }
+ return ipnets, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/testapi/testapi.go b/vendor/k8s.io/kubernetes/pkg/api/testapi/testapi.go
similarity index 67%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/testapi/testapi.go
rename to vendor/k8s.io/kubernetes/pkg/api/testapi/testapi.go
index d5d5452adc66730dae64d4009a5cd6ca70763409..518dddbfff12003d44250c8338bd0bbc6d17bf0f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/testapi/testapi.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/testapi/testapi.go
@@ -19,25 +19,34 @@ package testapi
import (
"fmt"
+ "mime"
"os"
"reflect"
"strings"
+ "k8s.io/kubernetes/federation/apis/federation"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/apps"
"k8s.io/kubernetes/pkg/apis/autoscaling"
"k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/policy"
+ "k8s.io/kubernetes/pkg/apis/rbac"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer/recognizer"
+ _ "k8s.io/kubernetes/federation/apis/federation/install"
_ "k8s.io/kubernetes/pkg/api/install"
+ _ "k8s.io/kubernetes/pkg/apis/apps/install"
_ "k8s.io/kubernetes/pkg/apis/autoscaling/install"
_ "k8s.io/kubernetes/pkg/apis/batch/install"
_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
_ "k8s.io/kubernetes/pkg/apis/extensions/install"
- _ "k8s.io/kubernetes/pkg/apis/metrics/install"
+ _ "k8s.io/kubernetes/pkg/apis/policy/install"
+ _ "k8s.io/kubernetes/pkg/apis/rbac/install"
)
var (
@@ -46,6 +55,13 @@ var (
Autoscaling TestGroup
Batch TestGroup
Extensions TestGroup
+ Apps TestGroup
+ Policy TestGroup
+ Federation TestGroup
+ Rbac TestGroup
+
+ serializer runtime.SerializerInfo
+ storageSerializer runtime.SerializerInfo
)
type TestGroup struct {
@@ -55,6 +71,30 @@ type TestGroup struct {
}
func init() {
+ if apiMediaType := os.Getenv("KUBE_TEST_API_TYPE"); len(apiMediaType) > 0 {
+ var ok bool
+ mediaType, options, err := mime.ParseMediaType(apiMediaType)
+ if err != nil {
+ panic(err)
+ }
+ serializer, ok = api.Codecs.SerializerForMediaType(mediaType, options)
+ if !ok {
+ panic(fmt.Sprintf("no serializer for %s", apiMediaType))
+ }
+ }
+
+ if storageMediaType := StorageMediaType(); len(storageMediaType) > 0 {
+ var ok bool
+ mediaType, options, err := mime.ParseMediaType(storageMediaType)
+ if err != nil {
+ panic(err)
+ }
+ storageSerializer, ok = api.Codecs.SerializerForMediaType(mediaType, options)
+ if !ok {
+ panic(fmt.Sprintf("no serializer for %s", storageMediaType))
+ }
+ }
+
kubeTestAPI := os.Getenv("KUBE_TEST_API")
if len(kubeTestAPI) != 0 {
testGroupVersions := strings.Split(kubeTestAPI, ",")
@@ -118,15 +158,47 @@ func init() {
if _, ok := Groups[batch.GroupName]; !ok {
Groups[batch.GroupName] = TestGroup{
externalGroupVersion: unversioned.GroupVersion{Group: batch.GroupName, Version: registered.GroupOrDie(batch.GroupName).GroupVersion.Version},
+ internalGroupVersion: batch.SchemeGroupVersion,
+ internalTypes: api.Scheme.KnownTypes(batch.SchemeGroupVersion),
+ }
+ }
+ if _, ok := Groups[apps.GroupName]; !ok {
+ Groups[apps.GroupName] = TestGroup{
+ externalGroupVersion: unversioned.GroupVersion{Group: apps.GroupName, Version: registered.GroupOrDie(apps.GroupName).GroupVersion.Version},
internalGroupVersion: extensions.SchemeGroupVersion,
internalTypes: api.Scheme.KnownTypes(extensions.SchemeGroupVersion),
}
}
+ if _, ok := Groups[policy.GroupName]; !ok {
+ Groups[policy.GroupName] = TestGroup{
+ externalGroupVersion: unversioned.GroupVersion{Group: policy.GroupName, Version: registered.GroupOrDie(policy.GroupName).GroupVersion.Version},
+ internalGroupVersion: policy.SchemeGroupVersion,
+ internalTypes: api.Scheme.KnownTypes(policy.SchemeGroupVersion),
+ }
+ }
+ if _, ok := Groups[federation.GroupName]; !ok {
+ Groups[federation.GroupName] = TestGroup{
+ externalGroupVersion: unversioned.GroupVersion{Group: federation.GroupName, Version: registered.GroupOrDie(federation.GroupName).GroupVersion.Version},
+ internalGroupVersion: federation.SchemeGroupVersion,
+ internalTypes: api.Scheme.KnownTypes(federation.SchemeGroupVersion),
+ }
+ }
+ if _, ok := Groups[rbac.GroupName]; !ok {
+ Groups[rbac.GroupName] = TestGroup{
+ externalGroupVersion: unversioned.GroupVersion{Group: rbac.GroupName, Version: registered.GroupOrDie(rbac.GroupName).GroupVersion.Version},
+ internalGroupVersion: rbac.SchemeGroupVersion,
+ internalTypes: api.Scheme.KnownTypes(rbac.SchemeGroupVersion),
+ }
+ }
Default = Groups[api.GroupName]
Autoscaling = Groups[autoscaling.GroupName]
Batch = Groups[batch.GroupName]
+ Apps = Groups[apps.GroupName]
+ Policy = Groups[policy.GroupName]
Extensions = Groups[extensions.GroupName]
+ Federation = Groups[federation.GroupName]
+ Rbac = Groups[rbac.GroupName]
}
func (g TestGroup) ContentConfig() (string, *unversioned.GroupVersion, runtime.Codec) {
@@ -150,9 +222,40 @@ func (g TestGroup) InternalTypes() map[string]reflect.Type {
}
// Codec returns the codec for the API version to test against, as set by the
-// KUBE_TEST_API env var.
+// KUBE_TEST_API_TYPE env var.
func (g TestGroup) Codec() runtime.Codec {
- return api.Codecs.LegacyCodec(g.externalGroupVersion)
+ if serializer.Serializer == nil {
+ return api.Codecs.LegacyCodec(g.externalGroupVersion)
+ }
+ return api.Codecs.CodecForVersions(serializer, api.Codecs.UniversalDeserializer(), []unversioned.GroupVersion{g.externalGroupVersion}, nil)
+}
+
+// NegotiatedSerializer returns the negotiated serializer for the server.
+func (g TestGroup) NegotiatedSerializer() runtime.NegotiatedSerializer {
+ return api.Codecs
+}
+
+func StorageMediaType() string {
+ return os.Getenv("KUBE_TEST_API_STORAGE_TYPE")
+}
+
+// StorageCodec returns the codec for the API version to store in etcd, as set by the
+// KUBE_TEST_API_STORAGE_TYPE env var.
+func (g TestGroup) StorageCodec() runtime.Codec {
+ s := storageSerializer.Serializer
+
+ if s == nil {
+ return api.Codecs.LegacyCodec(g.externalGroupVersion)
+ }
+
+ // etcd2 only supports string data - we must wrap any result before returning
+ // TODO: remove for etcd3 / make parameterizable
+ if !storageSerializer.EncodesAsText {
+ s = runtime.NewBase64Serializer(s)
+ }
+ ds := recognizer.NewDecoder(s, api.Codecs.UniversalDeserializer())
+
+ return api.Codecs.CodecForVersions(s, ds, []unversioned.GroupVersion{g.externalGroupVersion}, nil)
}
// Converter returns the api.Scheme for the API version to test against, as set by the
@@ -232,15 +335,26 @@ func (g TestGroup) ResourcePath(resource, namespace, name string) string {
}
func (g TestGroup) RESTMapper() meta.RESTMapper {
- return registered.GroupOrDie(g.externalGroupVersion.Group).RESTMapper
+ return registered.RESTMapper()
+}
+
+// ExternalGroupVersions returns all external group versions allowed for the server.
+func ExternalGroupVersions() []unversioned.GroupVersion {
+ versions := []unversioned.GroupVersion{}
+ for _, g := range Groups {
+ gv := g.GroupVersion()
+ versions = append(versions, *gv)
+ }
+ return versions
}
// Get codec based on runtime.Object
func GetCodecForObject(obj runtime.Object) (runtime.Codec, error) {
- kind, err := api.Scheme.ObjectKind(obj)
+ kinds, _, err := api.Scheme.ObjectKinds(obj)
if err != nil {
return nil, fmt.Errorf("unexpected encoding error: %v", err)
}
+ kind := kinds[0]
for _, group := range Groups {
if group.GroupVersion().Group != kind.Group {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.generated.go b/vendor/k8s.io/kubernetes/pkg/api/types.generated.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/types.generated.go
index b4ccb56ccd6d6303f0d2e7a6718babbafc028e6b..b2dcd4afb7383fa08575e997750f849cbd41d0ff 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -27,14 +27,13 @@ import (
codec1978 "github.com/ugorji/go/codec"
pkg3_resource "k8s.io/kubernetes/pkg/api/resource"
pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- pkg7_fields "k8s.io/kubernetes/pkg/fields"
- pkg6_labels "k8s.io/kubernetes/pkg/labels"
- pkg8_runtime "k8s.io/kubernetes/pkg/runtime"
+ pkg6_fields "k8s.io/kubernetes/pkg/fields"
+ pkg5_labels "k8s.io/kubernetes/pkg/labels"
+ pkg7_runtime "k8s.io/kubernetes/pkg/runtime"
pkg1_types "k8s.io/kubernetes/pkg/types"
- pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ pkg4_intstr "k8s.io/kubernetes/pkg/util/intstr"
"reflect"
"runtime"
- pkg4_inf "speter.net/go/exp/math/dec/inf"
time "time"
)
@@ -70,14 +69,13 @@ func init() {
if false { // reference the types, but skip this branch at build/run time
var v0 pkg3_resource.Quantity
var v1 pkg2_unversioned.Time
- var v2 pkg7_fields.Selector
- var v3 pkg6_labels.Selector
- var v4 pkg8_runtime.Object
+ var v2 pkg6_fields.Selector
+ var v3 pkg5_labels.Selector
+ var v4 pkg7_runtime.Object
var v5 pkg1_types.UID
- var v6 pkg5_intstr.IntOrString
- var v7 pkg4_inf.Dec
- var v8 time.Time
- _, _, _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6, v7, v8
+ var v6 pkg4_intstr.IntOrString
+ var v7 time.Time
+ _, _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6, v7
}
}
@@ -95,7 +93,7 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [12]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Name != ""
@@ -110,9 +108,11 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[9] = x.DeletionGracePeriodSeconds != nil
yyq2[10] = len(x.Labels) != 0
yyq2[11] = len(x.Annotations) != 0
+ yyq2[12] = len(x.OwnerReferences) != 0
+ yyq2[13] = len(x.Finalizers) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(12)
+ r.EncodeArrayStart(14)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -481,6 +481,72 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[12] {
+ if x.OwnerReferences == nil {
+ r.EncodeNil()
+ } else {
+ yym44 := z.EncBinary()
+ _ = yym44
+ if false {
+ } else {
+ h.encSliceOwnerReference(([]OwnerReference)(x.OwnerReferences), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[12] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ownerReferences"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.OwnerReferences == nil {
+ r.EncodeNil()
+ } else {
+ yym45 := z.EncBinary()
+ _ = yym45
+ if false {
+ } else {
+ h.encSliceOwnerReference(([]OwnerReference)(x.OwnerReferences), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[13] {
+ if x.Finalizers == nil {
+ r.EncodeNil()
+ } else {
+ yym47 := z.EncBinary()
+ _ = yym47
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Finalizers, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[13] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("finalizers"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Finalizers == nil {
+ r.EncodeNil()
+ } else {
+ yym48 := z.EncBinary()
+ _ = yym48
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Finalizers, false, e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -662,6 +728,30 @@ func (x *ObjectMeta) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.F.DecMapStringStringX(yyv19, false, d)
}
}
+ case "ownerReferences":
+ if r.TryDecodeAsNil() {
+ x.OwnerReferences = nil
+ } else {
+ yyv21 := &x.OwnerReferences
+ yym22 := z.DecBinary()
+ _ = yym22
+ if false {
+ } else {
+ h.decSliceOwnerReference((*[]OwnerReference)(yyv21), d)
+ }
+ }
+ case "finalizers":
+ if r.TryDecodeAsNil() {
+ x.Finalizers = nil
+ } else {
+ yyv23 := &x.Finalizers
+ yym24 := z.DecBinary()
+ _ = yym24
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv23, false, d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -673,16 +763,16 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj21 int
- var yyb21 bool
- var yyhl21 bool = l >= 0
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ var yyj25 int
+ var yyb25 bool
+ var yyhl25 bool = l >= 0
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -692,13 +782,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -708,13 +798,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.GenerateName = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -724,13 +814,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Namespace = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -740,13 +830,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SelfLink = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -756,13 +846,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.UID = pkg1_types.UID(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -772,13 +862,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ResourceVersion = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -788,13 +878,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Generation = int64(r.DecodeInt(64))
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -802,26 +892,26 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.CreationTimestamp = pkg2_unversioned.Time{}
} else {
- yyv29 := &x.CreationTimestamp
- yym30 := z.DecBinary()
- _ = yym30
+ yyv33 := &x.CreationTimestamp
+ yym34 := z.DecBinary()
+ _ = yym34
if false {
- } else if z.HasExtensions() && z.DecExt(yyv29) {
- } else if yym30 {
- z.DecBinaryUnmarshal(yyv29)
- } else if !yym30 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv29)
+ } else if z.HasExtensions() && z.DecExt(yyv33) {
+ } else if yym34 {
+ z.DecBinaryUnmarshal(yyv33)
+ } else if !yym34 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv33)
} else {
- z.DecFallback(yyv29, false)
+ z.DecFallback(yyv33, false)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -834,25 +924,25 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.DeletionTimestamp == nil {
x.DeletionTimestamp = new(pkg2_unversioned.Time)
}
- yym32 := z.DecBinary()
- _ = yym32
+ yym36 := z.DecBinary()
+ _ = yym36
if false {
} else if z.HasExtensions() && z.DecExt(x.DeletionTimestamp) {
- } else if yym32 {
+ } else if yym36 {
z.DecBinaryUnmarshal(x.DeletionTimestamp)
- } else if !yym32 && z.IsJSONHandle() {
+ } else if !yym36 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.DeletionTimestamp)
} else {
z.DecFallback(x.DeletionTimestamp, false)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -865,20 +955,20 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.DeletionGracePeriodSeconds == nil {
x.DeletionGracePeriodSeconds = new(int64)
}
- yym34 := z.DecBinary()
- _ = yym34
+ yym38 := z.DecBinary()
+ _ = yym38
if false {
} else {
*((*int64)(x.DeletionGracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -886,21 +976,21 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Labels = nil
} else {
- yyv35 := &x.Labels
- yym36 := z.DecBinary()
- _ = yym36
+ yyv39 := &x.Labels
+ yym40 := z.DecBinary()
+ _ = yym40
if false {
} else {
- z.F.DecMapStringStringX(yyv35, false, d)
+ z.F.DecMapStringStringX(yyv39, false, d)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -908,26 +998,70 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Annotations = nil
} else {
- yyv37 := &x.Annotations
- yym38 := z.DecBinary()
- _ = yym38
+ yyv41 := &x.Annotations
+ yym42 := z.DecBinary()
+ _ = yym42
+ if false {
+ } else {
+ z.F.DecMapStringStringX(yyv41, false, d)
+ }
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.OwnerReferences = nil
+ } else {
+ yyv43 := &x.OwnerReferences
+ yym44 := z.DecBinary()
+ _ = yym44
+ if false {
+ } else {
+ h.decSliceOwnerReference((*[]OwnerReference)(yyv43), d)
+ }
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Finalizers = nil
+ } else {
+ yyv45 := &x.Finalizers
+ yym46 := z.DecBinary()
+ _ = yym46
if false {
} else {
- z.F.DecMapStringStringX(yyv37, false, d)
+ z.F.DecSliceStringX(yyv45, false, d)
}
}
for {
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj21-1, "")
+ z.DecStructFieldNotFound(yyj25-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -946,7 +1080,7 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [20]bool
+ var yyq2 [21]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = x.VolumeSource.HostPath != nil && x.HostPath != nil
@@ -968,9 +1102,10 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[17] = x.VolumeSource.FC != nil && x.FC != nil
yyq2[18] = x.VolumeSource.AzureFile != nil && x.AzureFile != nil
yyq2[19] = x.VolumeSource.ConfigMap != nil && x.ConfigMap != nil
+ yyq2[20] = x.VolumeSource.VsphereVolume != nil && x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(20)
+ r.EncodeArrayStart(21)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -1703,6 +1838,43 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ var yyn63 bool
+ if x.VolumeSource.VsphereVolume == nil {
+ yyn63 = true
+ goto LABEL63
+ }
+ LABEL63:
+ if yyr2 || yy2arr2 {
+ if yyn63 {
+ r.EncodeNil()
+ } else {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[20] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ }
+ } else {
+ if yyq2[20] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyn63 {
+ r.EncodeNil()
+ } else {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -2036,6 +2208,20 @@ func (x *Volume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if x.VolumeSource.VsphereVolume == nil {
+ x.VolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -2047,16 +2233,16 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj24 int
- var yyb24 bool
- var yyhl24 bool = l >= 0
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ var yyj25 int
+ var yyb25 bool
+ var yyhl25 bool = l >= 0
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2069,13 +2255,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.HostPath == nil {
x.VolumeSource.HostPath = new(HostPathVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2093,13 +2279,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.EmptyDir == nil {
x.VolumeSource.EmptyDir = new(EmptyDirVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2117,13 +2303,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.GCEPersistentDisk == nil {
x.VolumeSource.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2141,13 +2327,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.AWSElasticBlockStore == nil {
x.VolumeSource.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2165,13 +2351,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.GitRepo == nil {
x.VolumeSource.GitRepo = new(GitRepoVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2189,13 +2375,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Secret == nil {
x.VolumeSource.Secret = new(SecretVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2213,13 +2399,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.NFS == nil {
x.VolumeSource.NFS = new(NFSVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2237,13 +2423,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.ISCSI == nil {
x.VolumeSource.ISCSI = new(ISCSIVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2261,13 +2447,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Glusterfs == nil {
x.VolumeSource.Glusterfs = new(GlusterfsVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2285,13 +2471,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.PersistentVolumeClaim == nil {
x.VolumeSource.PersistentVolumeClaim = new(PersistentVolumeClaimVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2309,13 +2495,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.RBD == nil {
x.VolumeSource.RBD = new(RBDVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2333,13 +2519,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.FlexVolume == nil {
x.VolumeSource.FlexVolume = new(FlexVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2357,13 +2543,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Cinder == nil {
x.VolumeSource.Cinder = new(CinderVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2381,13 +2567,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.CephFS == nil {
x.VolumeSource.CephFS = new(CephFSVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2405,13 +2591,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Flocker == nil {
x.VolumeSource.Flocker = new(FlockerVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2429,13 +2615,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.DownwardAPI == nil {
x.VolumeSource.DownwardAPI = new(DownwardAPIVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2453,13 +2639,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.FC == nil {
x.VolumeSource.FC = new(FCVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2477,13 +2663,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.AzureFile == nil {
x.VolumeSource.AzureFile = new(AzureFileVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2501,13 +2687,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.ConfigMap == nil {
x.VolumeSource.ConfigMap = new(ConfigMapVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2522,18 +2708,42 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ if x.VolumeSource.VsphereVolume == nil {
+ x.VolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj24-1, "")
+ z.DecStructFieldNotFound(yyj25-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -2552,7 +2762,7 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [19]bool
+ var yyq2 [20]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.HostPath != nil
@@ -2574,9 +2784,10 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[16] = x.FC != nil
yyq2[17] = x.AzureFile != nil
yyq2[18] = x.ConfigMap != nil
+ yyq2[19] = x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(19)
+ r.EncodeArrayStart(20)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -3024,6 +3235,29 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[19] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[19] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -3294,6 +3528,17 @@ func (x *VolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -3305,16 +3550,16 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj23 int
- var yyb23 bool
- var yyhl23 bool = l >= 0
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ var yyj24 int
+ var yyb24 bool
+ var yyhl24 bool = l >= 0
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3329,13 +3574,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.HostPath.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3350,13 +3595,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.EmptyDir.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3371,13 +3616,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.GCEPersistentDisk.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3392,13 +3637,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.AWSElasticBlockStore.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3413,13 +3658,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.GitRepo.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3434,13 +3679,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Secret.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3455,13 +3700,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.NFS.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3476,13 +3721,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ISCSI.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3497,13 +3742,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Glusterfs.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3518,13 +3763,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.PersistentVolumeClaim.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3539,13 +3784,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.RBD.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3560,13 +3805,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FlexVolume.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3581,13 +3826,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Cinder.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3602,13 +3847,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.CephFS.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3623,13 +3868,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Flocker.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3644,13 +3889,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.DownwardAPI.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3665,13 +3910,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FC.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3686,13 +3931,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.AzureFile.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3707,18 +3952,39 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
+ } else {
+ yyb24 = r.CheckBreak()
+ }
+ if yyb24 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj23-1, "")
+ z.DecStructFieldNotFound(yyj24-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -3737,7 +4003,7 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [13]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.GCEPersistentDisk != nil
@@ -3753,9 +4019,10 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[10] = x.FC != nil
yyq2[11] = x.Flocker != nil
yyq2[12] = x.AzureFile != nil
+ yyq2[13] = x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(13)
+ r.EncodeArrayStart(14)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -4065,6 +4332,29 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[13] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[13] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -4269,6 +4559,17 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Deco
}
x.AzureFile.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -4280,16 +4581,16 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj17 int
- var yyb17 bool
- var yyhl17 bool = l >= 0
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ var yyj18 int
+ var yyb18 bool
+ var yyhl18 bool = l >= 0
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4304,13 +4605,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.GCEPersistentDisk.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4325,13 +4626,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.AWSElasticBlockStore.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4346,13 +4647,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.HostPath.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4367,13 +4668,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Glusterfs.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4388,13 +4689,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.NFS.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4409,13 +4710,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.RBD.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4430,13 +4731,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.ISCSI.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4451,13 +4752,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.FlexVolume.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4472,13 +4773,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Cinder.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4493,13 +4794,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.CephFS.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4514,13 +4815,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.FC.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4535,13 +4836,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Flocker.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4556,18 +4857,39 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.AzureFile.CodecDecodeSelf(d)
}
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj17-1, "")
+ z.DecStructFieldNotFound(yyj18-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -5139,7 +5461,7 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [17]bool
+ var yyq2 [18]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = len(x.AccessModes) != 0
@@ -5158,9 +5480,10 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[14] = x.PersistentVolumeSource.FC != nil && x.FC != nil
yyq2[15] = x.PersistentVolumeSource.Flocker != nil && x.Flocker != nil
yyq2[16] = x.PersistentVolumeSource.AzureFile != nil && x.AzureFile != nil
+ yyq2[17] = x.PersistentVolumeSource.VsphereVolume != nil && x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(17)
+ r.EncodeArrayStart(18)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -5740,6 +6063,43 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ var yyn54 bool
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ yyn54 = true
+ goto LABEL54
+ }
+ LABEL54:
+ if yyr2 || yy2arr2 {
+ if yyn54 {
+ r.EncodeNil()
+ } else {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[17] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ }
+ } else {
+ if yyq2[17] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyn54 {
+ r.EncodeNil()
+ } else {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -6019,6 +6379,20 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decode
}
x.AzureFile.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ x.PersistentVolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -6030,16 +6404,16 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj22 int
- var yyb22 bool
- var yyhl22 bool = l >= 0
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ var yyj23 int
+ var yyb23 bool
+ var yyhl23 bool = l >= 0
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6047,16 +6421,16 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv23 := &x.Capacity
- yyv23.CodecDecodeSelf(d)
+ yyv24 := &x.Capacity
+ yyv24.CodecDecodeSelf(d)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6064,21 +6438,21 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.AccessModes = nil
} else {
- yyv24 := &x.AccessModes
- yym25 := z.DecBinary()
- _ = yym25
+ yyv25 := &x.AccessModes
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv24), d)
+ h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv25), d)
}
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6093,13 +6467,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
}
x.ClaimRef.CodecDecodeSelf(d)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6112,13 +6486,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.GCEPersistentDisk == nil {
x.PersistentVolumeSource.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6136,13 +6510,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.AWSElasticBlockStore == nil {
x.PersistentVolumeSource.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6160,13 +6534,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.HostPath == nil {
x.PersistentVolumeSource.HostPath = new(HostPathVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6184,13 +6558,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Glusterfs == nil {
x.PersistentVolumeSource.Glusterfs = new(GlusterfsVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6208,13 +6582,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.NFS == nil {
x.PersistentVolumeSource.NFS = new(NFSVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6232,13 +6606,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.RBD == nil {
x.PersistentVolumeSource.RBD = new(RBDVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6256,13 +6630,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.ISCSI == nil {
x.PersistentVolumeSource.ISCSI = new(ISCSIVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6280,13 +6654,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.FlexVolume == nil {
x.PersistentVolumeSource.FlexVolume = new(FlexVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6304,13 +6678,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Cinder == nil {
x.PersistentVolumeSource.Cinder = new(CinderVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6328,13 +6702,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.CephFS == nil {
x.PersistentVolumeSource.CephFS = new(CephFSVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6352,13 +6726,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.FC == nil {
x.PersistentVolumeSource.FC = new(FCVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6376,13 +6750,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Flocker == nil {
x.PersistentVolumeSource.Flocker = new(FlockerVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6400,13 +6774,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.AzureFile == nil {
x.PersistentVolumeSource.AzureFile = new(AzureFileVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6421,18 +6795,42 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
}
x.AzureFile.CodecDecodeSelf(d)
}
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ x.PersistentVolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj22-1, "")
+ z.DecStructFieldNotFound(yyj23-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -7763,15 +8161,16 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.AccessModes) != 0
- yyq2[1] = true
- yyq2[2] = x.VolumeName != ""
+ yyq2[1] = x.Selector != nil
+ yyq2[2] = true
+ yyq2[3] = x.VolumeName != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -7818,25 +8217,60 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yy7 := &x.Resources
- yy7.CodecEncodeSelf(e)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
} else {
r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("resources"))
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.Resources
- yy9.CodecEncodeSelf(e)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
+ yy10 := &x.Resources
+ yy10.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resources"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.Resources
+ yy12.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumeName))
@@ -7845,12 +8279,12 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumeName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
+ yym16 := z.EncBinary()
+ _ = yym16
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumeName))
@@ -7930,12 +8364,29 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv4), d)
}
}
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
case "resources":
if r.TryDecodeAsNil() {
x.Resources = ResourceRequirements{}
} else {
- yyv6 := &x.Resources
- yyv6.CodecDecodeSelf(d)
+ yyv8 := &x.Resources
+ yyv8.CodecDecodeSelf(d)
}
case "volumeName":
if r.TryDecodeAsNil() {
@@ -7954,16 +8405,16 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7971,21 +8422,48 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.AccessModes = nil
} else {
- yyv9 := &x.AccessModes
- yym10 := z.DecBinary()
- _ = yym10
+ yyv11 := &x.AccessModes
+ yym12 := z.DecBinary()
+ _ = yym12
if false {
} else {
- h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv9), d)
+ h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv11), d)
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7993,16 +8471,16 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Resources = ResourceRequirements{}
} else {
- yyv11 := &x.Resources
- yyv11.CodecDecodeSelf(d)
+ yyv15 := &x.Resources
+ yyv15.CodecDecodeSelf(d)
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -8013,17 +8491,17 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
x.VolumeName = string(r.DecodeString())
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -8958,7 +9436,7 @@ func (x *GCEPersistentDiskVolumeSource) codecDecodeSelfFromMap(l int, d *codec19
if r.TryDecodeAsNil() {
x.Partition = 0
} else {
- x.Partition = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Partition = int32(r.DecodeInt(32))
}
case "readOnly":
if r.TryDecodeAsNil() {
@@ -9026,7 +9504,7 @@ func (x *GCEPersistentDiskVolumeSource) codecDecodeSelfFromArray(l int, d *codec
if r.TryDecodeAsNil() {
x.Partition = 0
} else {
- x.Partition = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Partition = int32(r.DecodeInt(32))
}
yyj8++
if yyhl8 {
@@ -9323,7 +9801,7 @@ func (x *ISCSIVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Lun = 0
} else {
- x.Lun = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Lun = int32(r.DecodeInt(32))
}
case "iscsiInterface":
if r.TryDecodeAsNil() {
@@ -9403,7 +9881,7 @@ func (x *ISCSIVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.Lun = 0
} else {
- x.Lun = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Lun = int32(r.DecodeInt(32))
}
yyj10++
if yyhl10 {
@@ -9687,13 +10165,13 @@ func (x *FCVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
} else {
if x.Lun == nil {
- x.Lun = new(int)
+ x.Lun = new(int32)
}
yym7 := z.DecBinary()
_ = yym7
if false {
} else {
- *((*int)(x.Lun)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.Lun)) = int32(r.DecodeInt(32))
}
}
case "fsType":
@@ -9761,13 +10239,13 @@ func (x *FCVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
} else {
if x.Lun == nil {
- x.Lun = new(int)
+ x.Lun = new(int32)
}
yym14 := z.DecBinary()
_ = yym14
if false {
} else {
- *((*int)(x.Lun)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.Lun)) = int32(r.DecodeInt(32))
}
}
yyj10++
@@ -10404,7 +10882,7 @@ func (x *AWSElasticBlockStoreVolumeSource) codecDecodeSelfFromMap(l int, d *code
if r.TryDecodeAsNil() {
x.Partition = 0
} else {
- x.Partition = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Partition = int32(r.DecodeInt(32))
}
case "readOnly":
if r.TryDecodeAsNil() {
@@ -10472,7 +10950,7 @@ func (x *AWSElasticBlockStoreVolumeSource) codecDecodeSelfFromArray(l int, d *co
if r.TryDecodeAsNil() {
x.Partition = 0
} else {
- x.Partition = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Partition = int32(r.DecodeInt(32))
}
yyj8++
if yyhl8 {
@@ -10778,13 +11256,14 @@ func (x *SecretVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.SecretName != ""
+ yyq2[1] = len(x.Items) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(2)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -10820,6 +11299,39 @@ func (x *SecretVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -10887,6 +11399,18 @@ func (x *SecretVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
} else {
x.SecretName = string(r.DecodeString())
}
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv5 := &x.Items
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv5), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -10898,16 +11422,16 @@ func (x *SecretVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -10917,18 +11441,40 @@ func (x *SecretVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.SecretName = string(r.DecodeString())
}
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv9 := &x.Items
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv9), d)
+ }
+ }
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -11453,12 +11999,16 @@ func (x *RBDVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[2] = x.FSType != ""
+ yyq2[3] = x.RBDPool != ""
+ yyq2[4] = x.RadosUser != ""
+ yyq2[5] = x.Keyring != ""
+ yyq2[6] = x.SecretRef != nil
yyq2[7] = x.ReadOnly != false
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(8)
} else {
- yynn2 = 6
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -11540,76 +12090,100 @@ func (x *RBDVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("pool"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("pool"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
+ if yyq2[4] {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("user"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("user"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym19 := z.EncBinary()
- _ = yym19
- if false {
+ if yyq2[5] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("keyring"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("keyring"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.SecretRef == nil {
- r.EncodeNil()
+ if yyq2[6] {
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
} else {
- x.SecretRef.CodecEncodeSelf(e)
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.SecretRef == nil {
- r.EncodeNil()
- } else {
- x.SecretRef.CodecEncodeSelf(e)
+ if yyq2[6] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
}
}
if yyr2 || yy2arr2 {
@@ -12979,14 +13553,16 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[1] = x.FieldRef != nil
+ yyq2[2] = x.ResourceFieldRef != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -13016,14 +13592,49 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.FieldRef
- yy7.CodecEncodeSelf(e)
+ if yyq2[1] {
+ if x.FieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.FieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("fieldRef"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.FieldRef
- yy9.CodecEncodeSelf(e)
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.FieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.FieldRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceFieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -13094,10 +13705,25 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromMap(l int, d *codec1978.Decod
}
case "fieldRef":
if r.TryDecodeAsNil() {
- x.FieldRef = ObjectFieldSelector{}
+ if x.FieldRef != nil {
+ x.FieldRef = nil
+ }
} else {
- yyv5 := &x.FieldRef
- yyv5.CodecDecodeSelf(d)
+ if x.FieldRef == nil {
+ x.FieldRef = new(ObjectFieldSelector)
+ }
+ x.FieldRef.CodecDecodeSelf(d)
+ }
+ case "resourceFieldRef":
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -13110,16 +13736,16 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -13129,35 +13755,60 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.Path = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.FieldRef = ObjectFieldSelector{}
+ if x.FieldRef != nil {
+ x.FieldRef = nil
+ }
} else {
- yyv8 := &x.FieldRef
- yyv8.CodecDecodeSelf(d)
+ if x.FieldRef == nil {
+ x.FieldRef = new(ObjectFieldSelector)
+ }
+ x.FieldRef.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -13413,7 +14064,7 @@ func (x *AzureFileVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *VsphereVirtualDiskVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -13430,7 +14081,7 @@ func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = len(x.Items) != 0
+ yyq2[1] = x.FSType != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
@@ -13446,54 +14097,46 @@ func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
- }
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, string(x.VolumePath))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
- }
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumePath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.VolumePath))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FSType))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("Name"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fsType"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FSType))
+ }
}
}
if yyr2 || yy2arr2 {
@@ -13505,7 +14148,7 @@ func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ConfigMapVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *VsphereVirtualDiskVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13535,7 +14178,7 @@ func (x *ConfigMapVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ConfigMapVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *VsphereVirtualDiskVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13557,23 +14200,17 @@ func (x *ConfigMapVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decod
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "items":
+ case "volumePath":
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.VolumePath = ""
} else {
- yyv4 := &x.Items
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- h.decSliceKeyToPath((*[]KeyToPath)(yyv4), d)
- }
+ x.VolumePath = string(r.DecodeString())
}
- case "Name":
+ case "fsType":
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.FSType = ""
} else {
- x.Name = string(r.DecodeString())
+ x.FSType = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -13582,68 +14219,62 @@ func (x *ConfigMapVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ConfigMapVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *VsphereVirtualDiskVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.VolumePath = ""
} else {
- yyv8 := &x.Items
- yym9 := z.DecBinary()
- _ = yym9
- if false {
- } else {
- h.decSliceKeyToPath((*[]KeyToPath)(yyv8), d)
- }
+ x.VolumePath = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.FSType = ""
} else {
- x.Name = string(r.DecodeString())
+ x.FSType = string(r.DecodeString())
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -13660,11 +14291,12 @@ func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = len(x.Items) != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -13675,21 +14307,35 @@ func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("key"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
@@ -13698,17 +14344,17 @@ func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym7
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("path"))
+ r.EncodeString(codecSelferC_UTF81234, string("Name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym8 := z.EncBinary()
_ = yym8
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
if yyr2 || yy2arr2 {
@@ -13720,7 +14366,222 @@ func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *KeyToPath) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ConfigMapVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ConfigMapVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv4 := &x.Items
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv4), d)
+ }
+ }
+ case "Name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ConfigMapVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv8 := &x.Items
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv8), d)
+ }
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *KeyToPath) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("path"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *KeyToPath) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14060,13 +14921,13 @@ func (x *ContainerPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.HostPort = 0
} else {
- x.HostPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HostPort = int32(r.DecodeInt(32))
}
case "containerPort":
if r.TryDecodeAsNil() {
x.ContainerPort = 0
} else {
- x.ContainerPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ContainerPort = int32(r.DecodeInt(32))
}
case "protocol":
if r.TryDecodeAsNil() {
@@ -14124,7 +14985,7 @@ func (x *ContainerPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.HostPort = 0
} else {
- x.HostPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HostPort = int32(r.DecodeInt(32))
}
yyj9++
if yyhl9 {
@@ -14140,7 +15001,7 @@ func (x *ContainerPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ContainerPort = 0
} else {
- x.ContainerPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ContainerPort = int32(r.DecodeInt(32))
}
yyj9++
if yyhl9 {
@@ -14204,13 +15065,14 @@ func (x *VolumeMount) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = x.ReadOnly != false
+ yyq2[3] = x.SubPath != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 2
for _, b := range yyq2 {
@@ -14284,6 +15146,31 @@ func (x *VolumeMount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, string(x.MountPath))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.SubPath))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subPath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.SubPath))
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -14363,6 +15250,12 @@ func (x *VolumeMount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.MountPath = string(r.DecodeString())
}
+ case "subPath":
+ if r.TryDecodeAsNil() {
+ x.SubPath = ""
+ } else {
+ x.SubPath = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -14374,16 +15267,16 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14393,13 +15286,13 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14409,13 +15302,13 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ReadOnly = bool(r.DecodeBool())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14425,18 +15318,34 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.MountPath = string(r.DecodeString())
}
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SubPath = ""
+ } else {
+ x.SubPath = string(r.DecodeString())
+ }
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -14721,15 +15630,16 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.FieldRef != nil
- yyq2[1] = x.ConfigMapKeyRef != nil
- yyq2[2] = x.SecretKeyRef != nil
+ yyq2[1] = x.ResourceFieldRef != nil
+ yyq2[2] = x.ConfigMapKeyRef != nil
+ yyq2[3] = x.SecretKeyRef != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -14766,6 +15676,29 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceFieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
if x.ConfigMapKeyRef == nil {
r.EncodeNil()
} else {
@@ -14775,7 +15708,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("configMapKeyRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -14788,7 +15721,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
+ if yyq2[3] {
if x.SecretKeyRef == nil {
r.EncodeNil()
} else {
@@ -14798,7 +15731,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("secretKeyRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -14881,6 +15814,17 @@ func (x *EnvVarSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.FieldRef.CodecDecodeSelf(d)
}
+ case "resourceFieldRef":
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
+ }
case "configMapKeyRef":
if r.TryDecodeAsNil() {
if x.ConfigMapKeyRef != nil {
@@ -14914,16 +15858,16 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14938,13 +15882,34 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FieldRef.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14959,13 +15924,13 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMapKeyRef.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14981,17 +15946,17 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.SecretKeyRef.CodecDecodeSelf(d)
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -15199,7 +16164,7 @@ func (x *ObjectFieldSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ResourceFieldSelector) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -15213,14 +16178,16 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = x.ContainerName != ""
+ yyq2[2] = true
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -15231,21 +16198,27 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContainerName))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("key"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("containerName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContainerName))
+ }
}
}
if yyr2 || yy2arr2 {
@@ -15254,17 +16227,50 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym7
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("Name"))
+ r.EncodeString(codecSelferC_UTF81234, string("resource"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym8 := z.EncBinary()
_ = yym8
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy10 := &x.Divisor
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
+ } else {
+ z.EncFallback(yy10)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("divisor"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.Divisor
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
+ } else {
+ z.EncFallback(yy12)
+ }
}
}
if yyr2 || yy2arr2 {
@@ -15276,7 +16282,7 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15306,7 +16312,7 @@ func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15328,17 +16334,32 @@ func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decode
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "key":
+ case "containerName":
if r.TryDecodeAsNil() {
- x.Key = ""
+ x.ContainerName = ""
} else {
- x.Key = string(r.DecodeString())
+ x.ContainerName = string(r.DecodeString())
}
- case "Name":
+ case "resource":
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Resource = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Resource = string(r.DecodeString())
+ }
+ case "divisor":
+ if r.TryDecodeAsNil() {
+ x.Divisor = pkg3_resource.Quantity{}
+ } else {
+ yyv6 := &x.Divisor
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -15347,62 +16368,87 @@ func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ConfigMapKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Key = ""
+ x.ContainerName = ""
} else {
- x.Key = string(r.DecodeString())
+ x.ContainerName = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Resource = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Resource = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Divisor = pkg3_resource.Quantity{}
+ } else {
+ yyv11 := &x.Divisor
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else if !yym12 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv11)
+ } else {
+ z.DecFallback(yyv11, false)
+ }
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *SecretKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -15479,7 +16525,7 @@ func (x *SecretKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *SecretKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15509,7 +16555,7 @@ func (x *SecretKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *SecretKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15550,7 +16596,210 @@ func (x *SecretKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *SecretKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ConfigMapKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *SecretKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *SecretKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *SecretKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ case "Name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *SecretKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16043,7 +17292,7 @@ func (x *HTTPGetAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
case "port":
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv5 := &x.Port
yym6 := z.DecBinary()
@@ -16122,7 +17371,7 @@ func (x *HTTPGetAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv13 := &x.Port
yym14 := z.DecBinary()
@@ -16358,7 +17607,7 @@ func (x *TCPSocketAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
switch yys3 {
case "port":
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv4 := &x.Port
yym5 := z.DecBinary()
@@ -16397,7 +17646,7 @@ func (x *TCPSocketAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv7 := &x.Port
yym8 := z.DecBinary()
@@ -16954,31 +18203,31 @@ func (x *Probe) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.InitialDelaySeconds = 0
} else {
- x.InitialDelaySeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.InitialDelaySeconds = int32(r.DecodeInt(32))
}
case "timeoutSeconds":
if r.TryDecodeAsNil() {
x.TimeoutSeconds = 0
} else {
- x.TimeoutSeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.TimeoutSeconds = int32(r.DecodeInt(32))
}
case "periodSeconds":
if r.TryDecodeAsNil() {
x.PeriodSeconds = 0
} else {
- x.PeriodSeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.PeriodSeconds = int32(r.DecodeInt(32))
}
case "successThreshold":
if r.TryDecodeAsNil() {
x.SuccessThreshold = 0
} else {
- x.SuccessThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.SuccessThreshold = int32(r.DecodeInt(32))
}
case "failureThreshold":
if r.TryDecodeAsNil() {
x.FailureThreshold = 0
} else {
- x.FailureThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.FailureThreshold = int32(r.DecodeInt(32))
}
case "exec":
if x.Handler.Exec == nil {
@@ -17050,7 +18299,7 @@ func (x *Probe) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.InitialDelaySeconds = 0
} else {
- x.InitialDelaySeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.InitialDelaySeconds = int32(r.DecodeInt(32))
}
yyj12++
if yyhl12 {
@@ -17066,7 +18315,7 @@ func (x *Probe) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.TimeoutSeconds = 0
} else {
- x.TimeoutSeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.TimeoutSeconds = int32(r.DecodeInt(32))
}
yyj12++
if yyhl12 {
@@ -17082,7 +18331,7 @@ func (x *Probe) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.PeriodSeconds = 0
} else {
- x.PeriodSeconds = int(r.DecodeInt(codecSelferBitsize1234))
+ x.PeriodSeconds = int32(r.DecodeInt(32))
}
yyj12++
if yyhl12 {
@@ -17098,7 +18347,7 @@ func (x *Probe) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.SuccessThreshold = 0
} else {
- x.SuccessThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.SuccessThreshold = int32(r.DecodeInt(32))
}
yyj12++
if yyhl12 {
@@ -17114,7 +18363,7 @@ func (x *Probe) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.FailureThreshold = 0
} else {
- x.FailureThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.FailureThreshold = int32(r.DecodeInt(32))
}
if x.Handler.Exec == nil {
x.Handler.Exec = new(ExecAction)
@@ -20072,13 +21321,13 @@ func (x *ContainerStateTerminated) codecDecodeSelfFromMap(l int, d *codec1978.De
if r.TryDecodeAsNil() {
x.ExitCode = 0
} else {
- x.ExitCode = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ExitCode = int32(r.DecodeInt(32))
}
case "signal":
if r.TryDecodeAsNil() {
x.Signal = 0
} else {
- x.Signal = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Signal = int32(r.DecodeInt(32))
}
case "reason":
if r.TryDecodeAsNil() {
@@ -20160,7 +21409,7 @@ func (x *ContainerStateTerminated) codecDecodeSelfFromArray(l int, d *codec1978.
if r.TryDecodeAsNil() {
x.ExitCode = 0
} else {
- x.ExitCode = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ExitCode = int32(r.DecodeInt(32))
}
yyj13++
if yyhl13 {
@@ -20176,7 +21425,7 @@ func (x *ContainerStateTerminated) codecDecodeSelfFromArray(l int, d *codec1978.
if r.TryDecodeAsNil() {
x.Signal = 0
} else {
- x.Signal = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Signal = int32(r.DecodeInt(32))
}
yyj13++
if yyhl13 {
@@ -20863,7 +22112,7 @@ func (x *ContainerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.RestartCount = 0
} else {
- x.RestartCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RestartCount = int32(r.DecodeInt(32))
}
case "image":
if r.TryDecodeAsNil() {
@@ -20977,7 +22226,7 @@ func (x *ContainerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.RestartCount = 0
} else {
- x.RestartCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RestartCount = int32(r.DecodeInt(32))
}
yyj12++
if yyhl12 {
@@ -22599,13 +23848,15 @@ func (x *Affinity) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.NodeAffinity != nil
+ yyq2[1] = x.PodAffinity != nil
+ yyq2[2] = x.PodAntiAffinity != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -22639,6 +23890,52 @@ func (x *Affinity) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PodAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAffinity.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAffinity"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAffinity.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.PodAntiAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAntiAffinity.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAntiAffinity"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodAntiAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAntiAffinity.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -22711,6 +24008,28 @@ func (x *Affinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.NodeAffinity.CodecDecodeSelf(d)
}
+ case "podAffinity":
+ if r.TryDecodeAsNil() {
+ if x.PodAffinity != nil {
+ x.PodAffinity = nil
+ }
+ } else {
+ if x.PodAffinity == nil {
+ x.PodAffinity = new(PodAffinity)
+ }
+ x.PodAffinity.CodecDecodeSelf(d)
+ }
+ case "podAntiAffinity":
+ if r.TryDecodeAsNil() {
+ if x.PodAntiAffinity != nil {
+ x.PodAntiAffinity = nil
+ }
+ } else {
+ if x.PodAntiAffinity == nil {
+ x.PodAntiAffinity = new(PodAntiAffinity)
+ }
+ x.PodAntiAffinity.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -22722,16 +24041,16 @@ func (x *Affinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -22746,23 +24065,65 @@ func (x *Affinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.NodeAffinity.CodecDecodeSelf(d)
}
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.PodAffinity != nil {
+ x.PodAffinity = nil
+ }
+ } else {
+ if x.PodAffinity == nil {
+ x.PodAffinity = new(PodAffinity)
+ }
+ x.PodAffinity.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.PodAntiAffinity != nil {
+ x.PodAntiAffinity = nil
+ }
+ } else {
+ if x.PodAntiAffinity == nil {
+ x.PodAntiAffinity = new(PodAntiAffinity)
+ }
+ x.PodAntiAffinity.CodecDecodeSelf(d)
+ }
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *PodAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -22779,7 +24140,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.RequiredDuringSchedulingIgnoredDuringExecution != nil
+ yyq2[0] = len(x.RequiredDuringSchedulingIgnoredDuringExecution) != 0
yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
var yynn2 int
if yyr2 || yy2arr2 {
@@ -22800,7 +24161,12 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
r.EncodeNil()
} else {
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
}
} else {
r.EncodeNil()
@@ -22813,7 +24179,12 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
r.EncodeNil()
} else {
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
}
}
}
@@ -22827,7 +24198,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym7
if false {
} else {
- h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
}
}
} else {
@@ -22845,7 +24216,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym8
if false {
} else {
- h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
}
}
}
@@ -22859,7 +24230,1018 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *NodeAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *PodAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "requiredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv4 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv4), d)
+ }
+ }
+ case "preferredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv6 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv9 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv11 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodAntiAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.RequiredDuringSchedulingIgnoredDuringExecution) != 0
+ yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preferredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodAntiAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAntiAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "requiredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv4 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv4), d)
+ }
+ }
+ case "preferredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv6 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAntiAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv9 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv11 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *WeightedPodAffinityTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("weight"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy7 := &x.PodAffinityTerm
+ yy7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAffinityTerm"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.PodAffinityTerm
+ yy9.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *WeightedPodAffinityTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *WeightedPodAffinityTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "weight":
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ case "podAffinityTerm":
+ if r.TryDecodeAsNil() {
+ x.PodAffinityTerm = PodAffinityTerm{}
+ } else {
+ yyv5 := &x.PodAffinityTerm
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *WeightedPodAffinityTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodAffinityTerm = PodAffinityTerm{}
+ } else {
+ yyv8 := &x.PodAffinityTerm
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodAffinityTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.LabelSelector != nil
+ yyq2[2] = x.TopologyKey != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.LabelSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LabelSelector) {
+ } else {
+ z.EncFallback(x.LabelSelector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LabelSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LabelSelector) {
+ } else {
+ z.EncFallback(x.LabelSelector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Namespaces == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Namespaces, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("namespaces"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Namespaces == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Namespaces, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.TopologyKey))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("topologyKey"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.TopologyKey))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodAffinityTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAffinityTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "labelSelector":
+ if r.TryDecodeAsNil() {
+ if x.LabelSelector != nil {
+ x.LabelSelector = nil
+ }
+ } else {
+ if x.LabelSelector == nil {
+ x.LabelSelector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LabelSelector) {
+ } else {
+ z.DecFallback(x.LabelSelector, false)
+ }
+ }
+ case "namespaces":
+ if r.TryDecodeAsNil() {
+ x.Namespaces = nil
+ } else {
+ yyv6 := &x.Namespaces
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "topologyKey":
+ if r.TryDecodeAsNil() {
+ x.TopologyKey = ""
+ } else {
+ x.TopologyKey = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAffinityTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.LabelSelector != nil {
+ x.LabelSelector = nil
+ }
+ } else {
+ if x.LabelSelector == nil {
+ x.LabelSelector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LabelSelector) {
+ } else {
+ z.DecFallback(x.LabelSelector, false)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Namespaces = nil
+ } else {
+ yyv12 := &x.Namespaces
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv12, false, d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.TopologyKey = ""
+ } else {
+ x.TopologyKey = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.RequiredDuringSchedulingIgnoredDuringExecution != nil
+ yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preferredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NodeAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -23128,18 +25510,547 @@ func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Dec
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "weight":
+ case "weight":
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ case "preference":
+ if r.TryDecodeAsNil() {
+ x.Preference = NodeSelectorTerm{}
+ } else {
+ yyv5 := &x.Preference
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PreferredSchedulingTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Preference = NodeSelectorTerm{}
+ } else {
+ yyv8 := &x.Preference
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Taint) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.Value != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("value"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Effect.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("effect"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Effect.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Taint) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Taint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ case "value":
+ if r.TryDecodeAsNil() {
+ x.Value = ""
+ } else {
+ x.Value = string(r.DecodeString())
+ }
+ case "effect":
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Taint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Value = ""
+ } else {
+ x.Value = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x TaintEffect) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *TaintEffect) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *Toleration) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Key != ""
+ yyq2[1] = x.Operator != ""
+ yyq2[2] = x.Value != ""
+ yyq2[3] = x.Effect != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ x.Operator.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("operator"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Operator.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("value"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ x.Effect.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("effect"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Effect.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Toleration) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Toleration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
if r.TryDecodeAsNil() {
- x.Weight = 0
+ x.Key = ""
} else {
- x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Key = string(r.DecodeString())
}
- case "preference":
+ case "operator":
if r.TryDecodeAsNil() {
- x.Preference = NodeSelectorTerm{}
+ x.Operator = ""
} else {
- yyv5 := &x.Preference
- yyv5.CodecDecodeSelf(d)
+ x.Operator = TolerationOperator(r.DecodeString())
+ }
+ case "value":
+ if r.TryDecodeAsNil() {
+ x.Value = ""
+ } else {
+ x.Value = string(r.DecodeString())
+ }
+ case "effect":
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -23148,62 +26059,119 @@ func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PreferredSchedulingTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *Toleration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Weight = 0
+ x.Key = ""
} else {
- x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Key = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Preference = NodeSelectorTerm{}
+ x.Operator = ""
} else {
- yyv8 := &x.Preference
- yyv8.CodecDecodeSelf(d)
+ x.Operator = TolerationOperator(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Value = ""
+ } else {
+ x.Value = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x TolerationOperator) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *TolerationOperator) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -23218,7 +26186,7 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [11]bool
+ var yyq2 [13]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[2] = x.RestartPolicy != ""
@@ -23229,9 +26197,11 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[8] = x.NodeName != ""
yyq2[9] = x.SecurityContext != nil
yyq2[10] = len(x.ImagePullSecrets) != 0
+ yyq2[11] = x.Hostname != ""
+ yyq2[12] = x.Subdomain != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(11)
+ r.EncodeArrayStart(13)
} else {
yynn2 = 3
for _, b := range yyq2 {
@@ -23529,6 +26499,56 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[11] {
+ yym41 := z.EncBinary()
+ _ = yym41
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[11] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostname"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym42 := z.EncBinary()
+ _ = yym42
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[12] {
+ yym44 := z.EncBinary()
+ _ = yym44
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Subdomain))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[12] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subdomain"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym45 := z.EncBinary()
+ _ = yym45
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Subdomain))
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -23705,6 +26725,18 @@ func (x *PodSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv19), d)
}
}
+ case "hostname":
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ case "subdomain":
+ if r.TryDecodeAsNil() {
+ x.Subdomain = ""
+ } else {
+ x.Subdomain = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -23716,16 +26748,16 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj21 int
- var yyb21 bool
- var yyhl21 bool = l >= 0
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ var yyj23 int
+ var yyb23 bool
+ var yyhl23 bool = l >= 0
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23733,21 +26765,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Volumes = nil
} else {
- yyv22 := &x.Volumes
- yym23 := z.DecBinary()
- _ = yym23
+ yyv24 := &x.Volumes
+ yym25 := z.DecBinary()
+ _ = yym25
if false {
} else {
- h.decSliceVolume((*[]Volume)(yyv22), d)
+ h.decSliceVolume((*[]Volume)(yyv24), d)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23755,21 +26787,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Containers = nil
} else {
- yyv24 := &x.Containers
- yym25 := z.DecBinary()
- _ = yym25
+ yyv26 := &x.Containers
+ yym27 := z.DecBinary()
+ _ = yym27
if false {
} else {
- h.decSliceContainer((*[]Container)(yyv24), d)
+ h.decSliceContainer((*[]Container)(yyv26), d)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23779,13 +26811,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.RestartPolicy = RestartPolicy(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23798,20 +26830,20 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.TerminationGracePeriodSeconds == nil {
x.TerminationGracePeriodSeconds = new(int64)
}
- yym28 := z.DecBinary()
- _ = yym28
+ yym30 := z.DecBinary()
+ _ = yym30
if false {
} else {
*((*int64)(x.TerminationGracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23824,20 +26856,20 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.ActiveDeadlineSeconds == nil {
x.ActiveDeadlineSeconds = new(int64)
}
- yym30 := z.DecBinary()
- _ = yym30
+ yym32 := z.DecBinary()
+ _ = yym32
if false {
} else {
*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23847,13 +26879,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.DNSPolicy = DNSPolicy(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23861,21 +26893,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodeSelector = nil
} else {
- yyv32 := &x.NodeSelector
- yym33 := z.DecBinary()
- _ = yym33
+ yyv34 := &x.NodeSelector
+ yym35 := z.DecBinary()
+ _ = yym35
if false {
} else {
- z.F.DecMapStringStringX(yyv32, false, d)
+ z.F.DecMapStringStringX(yyv34, false, d)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23885,13 +26917,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ServiceAccountName = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23901,13 +26933,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.NodeName = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23922,13 +26954,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.SecurityContext.CodecDecodeSelf(d)
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23936,26 +26968,58 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ImagePullSecrets = nil
} else {
- yyv37 := &x.ImagePullSecrets
- yym38 := z.DecBinary()
- _ = yym38
+ yyv39 := &x.ImagePullSecrets
+ yym40 := z.DecBinary()
+ _ = yym40
if false {
} else {
- h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv37), d)
+ h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv39), d)
}
}
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Subdomain = ""
+ } else {
+ x.Subdomain = string(r.DecodeString())
+ }
for {
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb21 {
+ if yyb23 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj21-1, "")
+ z.DecStructFieldNotFound(yyj23-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -26825,7 +29889,7 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
case "selector":
if r.TryDecodeAsNil() {
@@ -26878,7 +29942,7 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
yyj8++
if yyhl8 {
@@ -27105,13 +30169,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
case "fullyLabeledReplicas":
if r.TryDecodeAsNil() {
x.FullyLabeledReplicas = 0
} else {
- x.FullyLabeledReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.FullyLabeledReplicas = int32(r.DecodeInt(32))
}
case "observedGeneration":
if r.TryDecodeAsNil() {
@@ -27147,7 +30211,7 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
yyj7++
if yyhl7 {
@@ -27163,7 +30227,7 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
if r.TryDecodeAsNil() {
x.FullyLabeledReplicas = 0
} else {
- x.FullyLabeledReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.FullyLabeledReplicas = int32(r.DecodeInt(32))
}
yyj7++
if yyhl7 {
@@ -28863,7 +31927,7 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [7]bool
+ var yyq2 [8]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Type != ""
@@ -28871,9 +31935,10 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[4] = len(x.ExternalIPs) != 0
yyq2[5] = x.LoadBalancerIP != ""
yyq2[6] = x.SessionAffinity != ""
+ yyq2[7] = len(x.LoadBalancerSourceRanges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(7)
+ r.EncodeArrayStart(8)
} else {
yynn2 = 2
for _, b := range yyq2 {
@@ -29051,6 +32116,39 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
x.SessionAffinity.CodecEncodeSelf(e)
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[7] {
+ if x.LoadBalancerSourceRanges == nil {
+ r.EncodeNil()
+ } else {
+ yym25 := z.EncBinary()
+ _ = yym25
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[7] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("loadBalancerSourceRanges"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LoadBalancerSourceRanges == nil {
+ r.EncodeNil()
+ } else {
+ yym26 := z.EncBinary()
+ _ = yym26
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -29172,6 +32270,18 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.SessionAffinity = ServiceAffinity(r.DecodeString())
}
+ case "loadBalancerSourceRanges":
+ if r.TryDecodeAsNil() {
+ x.LoadBalancerSourceRanges = nil
+ } else {
+ yyv14 := &x.LoadBalancerSourceRanges
+ yym15 := z.DecBinary()
+ _ = yym15
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv14, false, d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -29183,16 +32293,16 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj14 int
- var yyb14 bool
- var yyhl14 bool = l >= 0
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ var yyj16 int
+ var yyb16 bool
+ var yyhl16 bool = l >= 0
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29202,13 +32312,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = ServiceType(r.DecodeString())
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29216,21 +32326,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv16 := &x.Ports
- yym17 := z.DecBinary()
- _ = yym17
+ yyv18 := &x.Ports
+ yym19 := z.DecBinary()
+ _ = yym19
if false {
} else {
- h.decSliceServicePort((*[]ServicePort)(yyv16), d)
+ h.decSliceServicePort((*[]ServicePort)(yyv18), d)
}
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29238,21 +32348,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv18 := &x.Selector
- yym19 := z.DecBinary()
- _ = yym19
+ yyv20 := &x.Selector
+ yym21 := z.DecBinary()
+ _ = yym21
if false {
} else {
- z.F.DecMapStringStringX(yyv18, false, d)
+ z.F.DecMapStringStringX(yyv20, false, d)
}
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29262,13 +32372,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ClusterIP = string(r.DecodeString())
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29276,21 +32386,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ExternalIPs = nil
} else {
- yyv21 := &x.ExternalIPs
- yym22 := z.DecBinary()
- _ = yym22
+ yyv23 := &x.ExternalIPs
+ yym24 := z.DecBinary()
+ _ = yym24
if false {
} else {
- z.F.DecSliceStringX(yyv21, false, d)
+ z.F.DecSliceStringX(yyv23, false, d)
}
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29300,13 +32410,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.LoadBalancerIP = string(r.DecodeString())
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29316,18 +32426,40 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SessionAffinity = ServiceAffinity(r.DecodeString())
}
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LoadBalancerSourceRanges = nil
+ } else {
+ yyv27 := &x.LoadBalancerSourceRanges
+ yym28 := z.DecBinary()
+ _ = yym28
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv27, false, d)
+ }
+ }
for {
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb16 = r.CheckBreak()
}
- if yyb14 {
+ if yyb16 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj14-1, "")
+ z.DecStructFieldNotFound(yyj16-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -29532,11 +32664,11 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
case "targetPort":
if r.TryDecodeAsNil() {
- x.TargetPort = pkg5_intstr.IntOrString{}
+ x.TargetPort = pkg4_intstr.IntOrString{}
} else {
yyv7 := &x.TargetPort
yym8 := z.DecBinary()
@@ -29553,7 +32685,7 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodePort = 0
} else {
- x.NodePort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.NodePort = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -29615,7 +32747,7 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
yyj10++
if yyhl10 {
@@ -29629,7 +32761,7 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.TargetPort = pkg5_intstr.IntOrString{}
+ x.TargetPort = pkg4_intstr.IntOrString{}
} else {
yyv14 := &x.TargetPort
yym15 := z.DecBinary()
@@ -29656,7 +32788,7 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodePort = 0
} else {
- x.NodePort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.NodePort = int32(r.DecodeInt(32))
}
for {
yyj10++
@@ -31387,12 +34519,13 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[1] = x.Hostname != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 2
for _, b := range yyq2 {
@@ -31422,6 +34555,31 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, string(x.IP))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostname"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.TargetRef == nil {
@@ -31506,6 +34664,12 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.IP = string(r.DecodeString())
}
+ case "hostname":
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
case "TargetRef":
if r.TryDecodeAsNil() {
if x.TargetRef != nil {
@@ -31528,16 +34692,16 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31547,13 +34711,29 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.IP = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31569,17 +34749,17 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.TargetRef.CodecDecodeSelf(d)
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -31732,7 +34912,7 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
case "Protocol":
if r.TryDecodeAsNil() {
@@ -31784,7 +34964,7 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
yyj7++
if yyhl7 {
@@ -32589,7 +35769,7 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -32619,7 +35799,7 @@ func (x *DaemonEndpoint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
for {
yyj5++
@@ -32814,14 +35994,14 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [10]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(10)
} else {
- yynn2 = 8
+ yynn2 = 10
for _, b := range yyq2 {
if b {
yynn2++
@@ -32982,6 +36162,44 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("operatingSystem"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym31 := z.EncBinary()
+ _ = yym31
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("architecture"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym32 := z.EncBinary()
+ _ = yym32
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -33091,6 +36309,18 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.KubeProxyVersion = string(r.DecodeString())
}
+ case "operatingSystem":
+ if r.TryDecodeAsNil() {
+ x.OperatingSystem = ""
+ } else {
+ x.OperatingSystem = string(r.DecodeString())
+ }
+ case "architecture":
+ if r.TryDecodeAsNil() {
+ x.Architecture = ""
+ } else {
+ x.Architecture = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -33100,18 +36330,18 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj12 int
- var yyb12 bool
- var yyhl12 bool = l >= 0
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj14 int
+ var yyb14 bool
+ var yyhl14 bool = l >= 0
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33121,13 +36351,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.MachineID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33137,13 +36367,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SystemUUID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33153,13 +36383,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.BootID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33169,13 +36399,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KernelVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33185,13 +36415,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.OSImage = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33201,13 +36431,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ContainerRuntimeVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33217,13 +36447,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeletVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33233,18 +36463,50 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeProxyVersion = string(r.DecodeString())
}
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.OperatingSystem = ""
+ } else {
+ x.OperatingSystem = string(r.DecodeString())
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Architecture = ""
+ } else {
+ x.Architecture = string(r.DecodeString())
+ }
for {
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj12-1, "")
+ z.DecStructFieldNotFound(yyj14-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33263,7 +36525,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [10]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.Capacity) != 0
@@ -33273,11 +36535,14 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[4] = len(x.Addresses) != 0
yyq2[5] = true
yyq2[6] = true
+ yyq2[7] = len(x.Images) != 0
+ yyq2[8] = len(x.VolumesInUse) != 0
+ yyq2[9] = len(x.VolumesAttached) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(10)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -33449,28 +36714,100 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Images == nil {
- r.EncodeNil()
- } else {
- yym29 := z.EncBinary()
- _ = yym29
- if false {
+ if yyq2[7] {
+ if x.Images == nil {
+ r.EncodeNil()
} else {
- h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ }
}
+ } else {
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("images"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Images == nil {
+ if yyq2[7] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("images"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Images == nil {
+ r.EncodeNil()
+ } else {
+ yym30 := z.EncBinary()
+ _ = yym30
+ if false {
+ } else {
+ h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[8] {
+ if x.VolumesInUse == nil {
+ r.EncodeNil()
+ } else {
+ yym32 := z.EncBinary()
+ _ = yym32
+ if false {
+ } else {
+ h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
+ }
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumesInUse"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumesInUse == nil {
+ r.EncodeNil()
+ } else {
+ yym33 := z.EncBinary()
+ _ = yym33
+ if false {
+ } else {
+ h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[9] {
+ if x.VolumesAttached == nil {
+ r.EncodeNil()
+ } else {
+ yym35 := z.EncBinary()
+ _ = yym35
+ if false {
+ } else {
+ h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
+ }
+ }
} else {
- yym30 := z.EncBinary()
- _ = yym30
- if false {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[9] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumesAttached"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumesAttached == nil {
+ r.EncodeNil()
} else {
- h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ yym36 := z.EncBinary()
+ _ = yym36
+ if false {
+ } else {
+ h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
+ }
}
}
}
@@ -33605,6 +36942,30 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
h.decSliceContainerImage((*[]ContainerImage)(yyv13), d)
}
}
+ case "volumesInUse":
+ if r.TryDecodeAsNil() {
+ x.VolumesInUse = nil
+ } else {
+ yyv15 := &x.VolumesInUse
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv15), d)
+ }
+ }
+ case "volumesAttached":
+ if r.TryDecodeAsNil() {
+ x.VolumesAttached = nil
+ } else {
+ yyv17 := &x.VolumesAttached
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv17), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -33616,16 +36977,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj15 int
- var yyb15 bool
- var yyhl15 bool = l >= 0
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ var yyj19 int
+ var yyb19 bool
+ var yyhl19 bool = l >= 0
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33633,16 +36994,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv16 := &x.Capacity
- yyv16.CodecDecodeSelf(d)
+ yyv20 := &x.Capacity
+ yyv20.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33650,16 +37011,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Allocatable = nil
} else {
- yyv17 := &x.Allocatable
- yyv17.CodecDecodeSelf(d)
+ yyv21 := &x.Allocatable
+ yyv21.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33669,13 +37030,13 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Phase = NodePhase(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33683,21 +37044,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv19 := &x.Conditions
- yym20 := z.DecBinary()
- _ = yym20
+ yyv23 := &x.Conditions
+ yym24 := z.DecBinary()
+ _ = yym24
if false {
} else {
- h.decSliceNodeCondition((*[]NodeCondition)(yyv19), d)
+ h.decSliceNodeCondition((*[]NodeCondition)(yyv23), d)
}
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33705,21 +37066,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv21 := &x.Addresses
- yym22 := z.DecBinary()
- _ = yym22
+ yyv25 := &x.Addresses
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- h.decSliceNodeAddress((*[]NodeAddress)(yyv21), d)
+ h.decSliceNodeAddress((*[]NodeAddress)(yyv25), d)
}
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33727,16 +37088,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DaemonEndpoints = NodeDaemonEndpoints{}
} else {
- yyv23 := &x.DaemonEndpoints
- yyv23.CodecDecodeSelf(d)
+ yyv27 := &x.DaemonEndpoints
+ yyv27.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33744,16 +37105,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodeInfo = NodeSystemInfo{}
} else {
- yyv24 := &x.NodeInfo
- yyv24.CodecDecodeSelf(d)
+ yyv28 := &x.NodeInfo
+ yyv28.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33761,26 +37122,289 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Images = nil
} else {
- yyv25 := &x.Images
- yym26 := z.DecBinary()
- _ = yym26
+ yyv29 := &x.Images
+ yym30 := z.DecBinary()
+ _ = yym30
+ if false {
+ } else {
+ h.decSliceContainerImage((*[]ContainerImage)(yyv29), d)
+ }
+ }
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
+ } else {
+ yyb19 = r.CheckBreak()
+ }
+ if yyb19 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumesInUse = nil
+ } else {
+ yyv31 := &x.VolumesInUse
+ yym32 := z.DecBinary()
+ _ = yym32
+ if false {
+ } else {
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv31), d)
+ }
+ }
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
+ } else {
+ yyb19 = r.CheckBreak()
+ }
+ if yyb19 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumesAttached = nil
+ } else {
+ yyv33 := &x.VolumesAttached
+ yym34 := z.DecBinary()
+ _ = yym34
if false {
} else {
- h.decSliceContainerImage((*[]ContainerImage)(yyv25), d)
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv33), d)
}
}
for {
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj15-1, "")
+ z.DecStructFieldNotFound(yyj19-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x UniqueVolumeName) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *UniqueVolumeName) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Name.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Name.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("devicePath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *AttachedVolume) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = UniqueVolumeName(r.DecodeString())
+ }
+ case "devicePath":
+ if r.TryDecodeAsNil() {
+ x.DevicePath = ""
+ } else {
+ x.DevicePath = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = UniqueVolumeName(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DevicePath = ""
+ } else {
+ x.DevicePath = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -37015,7 +40639,7 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *Preconditions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -37029,16 +40653,15 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.Kind != ""
- yyq2[2] = x.APIVersion != ""
+ yyq2[0] = x.UID != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(1)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -37049,38 +40672,309 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.GracePeriodSeconds == nil {
+ if yyq2[0] {
+ if x.UID == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.UID
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yy4))
+ }
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.UID == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.UID
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Preconditions) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "uid":
+ if r.TryDecodeAsNil() {
+ if x.UID != nil {
+ x.UID = nil
+ }
+ } else {
+ if x.UID == nil {
+ x.UID = new(pkg1_types.UID)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.UID) {
} else {
- yy4 := *x.GracePeriodSeconds
- yym5 := z.EncBinary()
- _ = yym5
- if false {
+ *((*string)(x.UID)) = r.DecodeString()
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.UID != nil {
+ x.UID = nil
+ }
+ } else {
+ if x.UID == nil {
+ x.UID = new(pkg1_types.UID)
+ }
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.UID) {
+ } else {
+ *((*string)(x.UID)) = r.DecodeString()
+ }
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.GracePeriodSeconds != nil
+ yyq2[1] = x.Preconditions != nil
+ yyq2[2] = x.OrphanDependents != nil
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.GracePeriodSeconds == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(yy4))
+ yy4 := *x.GracePeriodSeconds
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
}
+ } else {
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.GracePeriodSeconds == nil {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.GracePeriodSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.GracePeriodSeconds
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Preconditions == nil {
+ r.EncodeNil()
+ } else {
+ x.Preconditions.CodecEncodeSelf(e)
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preconditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Preconditions == nil {
+ r.EncodeNil()
+ } else {
+ x.Preconditions.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.OrphanDependents == nil {
+ r.EncodeNil()
+ } else {
+ yy12 := *x.OrphanDependents
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeBool(bool(yy12))
+ }
+ }
} else {
- yy6 := *x.GracePeriodSeconds
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("orphanDependents"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.OrphanDependents == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(yy6))
+ yy14 := *x.OrphanDependents
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeBool(bool(yy14))
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym9 := z.EncBinary()
- _ = yym9
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -37089,12 +40983,12 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[1] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym10 := z.EncBinary()
- _ = yym10
+ yym18 := z.EncBinary()
+ _ = yym18
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -37103,9 +40997,9 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -37114,12 +41008,12 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
+ yym21 := z.EncBinary()
+ _ = yym21
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -37203,6 +41097,33 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
+ case "preconditions":
+ if r.TryDecodeAsNil() {
+ if x.Preconditions != nil {
+ x.Preconditions = nil
+ }
+ } else {
+ if x.Preconditions == nil {
+ x.Preconditions = new(Preconditions)
+ }
+ x.Preconditions.CodecDecodeSelf(d)
+ }
+ case "orphanDependents":
+ if r.TryDecodeAsNil() {
+ if x.OrphanDependents != nil {
+ x.OrphanDependents = nil
+ }
+ } else {
+ if x.OrphanDependents == nil {
+ x.OrphanDependents = new(bool)
+ }
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else {
+ *((*bool)(x.OrphanDependents)) = r.DecodeBool()
+ }
+ }
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -37226,16 +41147,16 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37248,20 +41169,67 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.GracePeriodSeconds == nil {
x.GracePeriodSeconds = new(int64)
}
- yym10 := z.DecBinary()
- _ = yym10
+ yym13 := z.DecBinary()
+ _ = yym13
if false {
} else {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Preconditions != nil {
+ x.Preconditions = nil
+ }
+ } else {
+ if x.Preconditions == nil {
+ x.Preconditions = new(Preconditions)
+ }
+ x.Preconditions.CodecDecodeSelf(d)
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.OrphanDependents != nil {
+ x.OrphanDependents = nil
+ }
+ } else {
+ if x.OrphanDependents == nil {
+ x.OrphanDependents = new(bool)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*bool)(x.OrphanDependents)) = r.DecodeBool()
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37271,13 +41239,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37288,17 +41256,17 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.APIVersion = string(r.DecodeString())
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj11-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -40403,11 +44371,312 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "Path":
+ case "Path":
+ if r.TryDecodeAsNil() {
+ x.Path = ""
+ } else {
+ x.Path = string(r.DecodeString())
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Path = ""
+ } else {
+ x.Path = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[4] = x.Controller != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 4
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.Controller == nil {
+ r.EncodeNil()
+ } else {
+ yy16 := *x.Controller
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeBool(bool(yy16))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("controller"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Controller == nil {
+ r.EncodeNil()
+ } else {
+ yy18 := *x.Controller
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeBool(bool(yy18))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *OwnerReference) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *OwnerReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "apiVersion":
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.APIVersion = ""
} else {
- x.Path = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
case "kind":
if r.TryDecodeAsNil() {
@@ -40415,11 +44684,33 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
} else {
x.Kind = string(r.DecodeString())
}
- case "apiVersion":
+ case "name":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Name = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Name = string(r.DecodeString())
+ }
+ case "uid":
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = pkg1_types.UID(r.DecodeString())
+ }
+ case "controller":
+ if r.TryDecodeAsNil() {
+ if x.Controller != nil {
+ x.Controller = nil
+ }
+ } else {
+ if x.Controller == nil {
+ x.Controller = new(bool)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*bool)(x.Controller)) = r.DecodeBool()
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -40428,36 +44719,36 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.APIVersion = ""
} else {
- x.Path = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40467,34 +44758,76 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.Kind = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Name = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Name = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = pkg1_types.UID(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Controller != nil {
+ x.Controller = nil
+ }
+ } else {
+ if x.Controller == nil {
+ x.Controller = new(bool)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*bool)(x.Controller)) = r.DecodeBool()
+ }
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42044,7 +46377,7 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Count = 0
} else {
- x.Count = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Count = int32(r.DecodeInt(32))
}
case "type":
if r.TryDecodeAsNil() {
@@ -42229,7 +46562,7 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Count = 0
} else {
- x.Count = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Count = int32(r.DecodeInt(32))
}
yyj17++
if yyhl17 {
@@ -42710,7 +47043,7 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym9
if false {
} else {
- h.encSliceruntime_Object(([]pkg8_runtime.Object)(x.Items), e)
+ h.encSliceruntime_Object(([]pkg7_runtime.Object)(x.Items), e)
}
}
} else {
@@ -42724,7 +47057,7 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym10
if false {
} else {
- h.encSliceruntime_Object(([]pkg8_runtime.Object)(x.Items), e)
+ h.encSliceruntime_Object(([]pkg7_runtime.Object)(x.Items), e)
}
}
}
@@ -42861,7 +47194,7 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
_ = yym7
if false {
} else {
- h.decSliceruntime_Object((*[]pkg8_runtime.Object)(yyv6), d)
+ h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv6), d)
}
}
case "kind":
@@ -42932,7 +47265,7 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
_ = yym14
if false {
} else {
- h.decSliceruntime_Object((*[]pkg8_runtime.Object)(yyv13), d)
+ h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv13), d)
}
}
yyj10++
@@ -46482,14 +50815,13 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = len(x.Items) != 0
yyq2[2] = x.Kind != ""
yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -46529,34 +50861,28 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.Items == nil {
- r.EncodeNil()
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
- }
+ h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
}
- } else {
- r.EncodeNil()
}
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
- }
+ h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
}
}
}
@@ -49036,6 +53362,125 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x codecSelfer1234) encSliceOwnerReference(v []OwnerReference, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceOwnerReference(v *[]OwnerReference, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []OwnerReference{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]OwnerReference, yyrl1)
+ }
+ } else {
+ yyv1 = make([]OwnerReference, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, OwnerReference{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, OwnerReference{}) // var yyz1 OwnerReference
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []OwnerReference{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encSlicePersistentVolumeAccessMode(v []PersistentVolumeAccessMode, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -49185,7 +53630,7 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 400)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 456)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -49304,7 +53749,7 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -49384,7 +53829,7 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai
}
}
-func (x codecSelfer1234) encSliceDownwardAPIVolumeFile(v []DownwardAPIVolumeFile, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceKeyToPath(v []KeyToPath, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -49397,7 +53842,7 @@ func (x codecSelfer1234) encSliceDownwardAPIVolumeFile(v []DownwardAPIVolumeFile
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFile, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -49408,7 +53853,7 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []DownwardAPIVolumeFile{}
+ yyv1 = []KeyToPath{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -49423,15 +53868,15 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]DownwardAPIVolumeFile, yyrl1)
+ yyv1 = make([]KeyToPath, yyrl1)
}
} else {
- yyv1 = make([]DownwardAPIVolumeFile, yyrl1)
+ yyv1 = make([]KeyToPath, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -49446,7 +53891,7 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DownwardAPIVolumeFile{}
+ yyv1[yyj1] = KeyToPath{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -49455,10 +53900,10 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, DownwardAPIVolumeFile{})
+ yyv1 = append(yyv1, KeyToPath{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DownwardAPIVolumeFile{}
+ yyv1[yyj1] = KeyToPath{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -49472,13 +53917,13 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, DownwardAPIVolumeFile{}) // var yyz1 DownwardAPIVolumeFile
+ yyv1 = append(yyv1, KeyToPath{}) // var yyz1 KeyToPath
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DownwardAPIVolumeFile{}
+ yyv1[yyj1] = KeyToPath{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -49493,7 +53938,7 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []DownwardAPIVolumeFile{}
+ yyv1 = []KeyToPath{}
yyc1 = true
}
}
@@ -49503,7 +53948,7 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
}
}
-func (x codecSelfer1234) encSliceKeyToPath(v []KeyToPath, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceDownwardAPIVolumeFile(v []DownwardAPIVolumeFile, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -49516,7 +53961,7 @@ func (x codecSelfer1234) encSliceKeyToPath(v []KeyToPath, e *codec1978.Encoder)
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFile, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -49527,7 +53972,7 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []KeyToPath{}
+ yyv1 = []DownwardAPIVolumeFile{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -49547,10 +53992,10 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]KeyToPath, yyrl1)
+ yyv1 = make([]DownwardAPIVolumeFile, yyrl1)
}
} else {
- yyv1 = make([]KeyToPath, yyrl1)
+ yyv1 = make([]DownwardAPIVolumeFile, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -49565,7 +54010,7 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = KeyToPath{}
+ yyv1[yyj1] = DownwardAPIVolumeFile{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -49574,10 +54019,10 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, KeyToPath{})
+ yyv1 = append(yyv1, DownwardAPIVolumeFile{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = KeyToPath{}
+ yyv1[yyj1] = DownwardAPIVolumeFile{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -49591,13 +54036,13 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, KeyToPath{}) // var yyz1 KeyToPath
+ yyv1 = append(yyv1, DownwardAPIVolumeFile{}) // var yyz1 DownwardAPIVolumeFile
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = KeyToPath{}
+ yyv1[yyj1] = DownwardAPIVolumeFile{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -49612,7 +54057,7 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []KeyToPath{}
+ yyv1 = []DownwardAPIVolumeFile{}
yyc1 = true
}
}
@@ -49890,7 +54335,7 @@ func (x codecSelfer1234) decSliceContainerPort(v *[]ContainerPort, d *codec1978.
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -50128,7 +54573,7 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -50247,7 +54692,7 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 496)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 624)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -50565,6 +55010,244 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir
}
}
+func (x codecSelfer1234) encSlicePodAffinityTerm(v []PodAffinityTerm, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PodAffinityTerm{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PodAffinityTerm, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PodAffinityTerm, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PodAffinityTerm{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PodAffinityTerm{}) // var yyz1 PodAffinityTerm
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PodAffinityTerm{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceWeightedPodAffinityTerm(v []WeightedPodAffinityTerm, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinityTerm, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []WeightedPodAffinityTerm{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]WeightedPodAffinityTerm, yyrl1)
+ }
+ } else {
+ yyv1 = make([]WeightedPodAffinityTerm, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, WeightedPodAffinityTerm{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, WeightedPodAffinityTerm{}) // var yyz1 WeightedPodAffinityTerm
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []WeightedPodAffinityTerm{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encSlicePreferredSchedulingTerm(v []PreferredSchedulingTerm, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -50723,7 +55406,7 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 168)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 176)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51199,7 +55882,7 @@ func (x codecSelfer1234) decSliceContainerStatus(v *[]ContainerStatus, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 128)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 120)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51318,7 +56001,7 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 520)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 672)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51437,7 +56120,7 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 240)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51556,7 +56239,7 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 336)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 408)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52032,7 +56715,7 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 240)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 288)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52270,7 +56953,7 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52508,7 +57191,7 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52945,6 +57628,235 @@ func (x codecSelfer1234) decSliceContainerImage(v *[]ContainerImage, d *codec197
}
}
+func (x codecSelfer1234) encSliceUniqueVolumeName(v []UniqueVolumeName, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yyv1.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []UniqueVolumeName{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]UniqueVolumeName, yyrl1)
+ }
+ } else {
+ yyv1 = make([]UniqueVolumeName, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 UniqueVolumeName
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []UniqueVolumeName{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceAttachedVolume(v []AttachedVolume, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []AttachedVolume{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]AttachedVolume, yyrl1)
+ }
+ } else {
+ yyv1 = make([]AttachedVolume, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, AttachedVolume{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, AttachedVolume{}) // var yyz1 AttachedVolume
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []AttachedVolume{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encResourceList(v ResourceList, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -52977,7 +57889,7 @@ func (x codecSelfer1234) decResourceList(v *ResourceList, d *codec1978.Decoder)
yyl1 := r.ReadMapStart()
yybh1 := z.DecBasicHandle()
if yyv1 == nil {
- yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 72)
yyv1 = make(map[ResourceName]pkg3_resource.Quantity, yyrl1)
*v = yyv1
}
@@ -53098,7 +58010,7 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 488)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 616)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53327,7 +58239,7 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 232)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53446,7 +58358,7 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 440)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 488)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53526,7 +58438,7 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceruntime_Object(v []pkg8_runtime.Object, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceruntime_Object(v []pkg7_runtime.Object, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -53548,7 +58460,7 @@ func (x codecSelfer1234) encSliceruntime_Object(v []pkg8_runtime.Object, e *code
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg8_runtime.Object, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg7_runtime.Object, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -53559,7 +58471,7 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg8_runtime.Object, d *cod
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []pkg8_runtime.Object{}
+ yyv1 = []pkg7_runtime.Object{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -53579,10 +58491,10 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg8_runtime.Object, d *cod
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]pkg8_runtime.Object, yyrl1)
+ yyv1 = make([]pkg7_runtime.Object, yyrl1)
}
} else {
- yyv1 = make([]pkg8_runtime.Object, yyrl1)
+ yyv1 = make([]pkg7_runtime.Object, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -53635,7 +58547,7 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg8_runtime.Object, d *cod
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, nil) // var yyz1 pkg8_runtime.Object
+ yyv1 = append(yyv1, nil) // var yyz1 pkg7_runtime.Object
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
@@ -53662,7 +58574,7 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg8_runtime.Object, d *cod
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []pkg8_runtime.Object{}
+ yyv1 = []pkg7_runtime.Object{}
yyc1 = true
}
}
@@ -53830,7 +58742,7 @@ func (x codecSelfer1234) decSliceLimitRange(v *[]LimitRange, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54059,7 +58971,7 @@ func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 240)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 288)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54406,7 +59318,7 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54525,7 +59437,7 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 200)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 248)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54763,7 +59675,7 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.go b/vendor/k8s.io/kubernetes/pkg/api/types.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.go
rename to vendor/k8s.io/kubernetes/pkg/api/types.go
index a82aa45c075a23ebb78444f8a8fe00856193c80a..6d11c183baea787eb8357d857d7b9ba4cc0e185f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/types.go
@@ -138,6 +138,18 @@ type ObjectMeta struct {
// objects. Annotation keys have the same formatting restrictions as Label keys. See the
// comments on Labels for details.
Annotations map[string]string `json:"annotations,omitempty"`
+
+ // 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.
+ OwnerReferences []OwnerReference `json:"ownerReferences,omitempty"`
+
+ // 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 []string `json:"finalizers,omitempty"`
}
const (
@@ -219,6 +231,8 @@ type VolumeSource struct {
AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty"`
// ConfigMap represents a configMap that should populate this volume
ConfigMap *ConfigMapVolumeSource `json:"configMap,omitempty"`
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ VsphereVolume *VsphereVirtualDiskVolumeSource `json:"vsphereVolume,omitempty"`
}
// Similar to VolumeSource but meant for the administrator who creates PVs.
@@ -257,6 +271,8 @@ type PersistentVolumeSource struct {
Flocker *FlockerVolumeSource `json:"flocker,omitempty"`
// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty"`
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ VsphereVolume *VsphereVirtualDiskVolumeSource `json:"vsphereVolume,omitempty"`
}
type PersistentVolumeClaimVolumeSource struct {
@@ -290,6 +306,8 @@ type PersistentVolumeSpec struct {
// ClaimRef is part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim.
// ClaimRef is expected to be non-nil when bound.
// claim.VolumeName is the authoritative bind between PV and PVC.
+ // When set to non-nil value, PVC.Spec.Selector of the referenced PVC is
+ // ignored, i.e. labels of this PV do not need to match PVC selector.
ClaimRef *ObjectReference `json:"claimRef,omitempty"`
// Optional: what happens to a persistent volume when released from its claim.
PersistentVolumeReclaimPolicy PersistentVolumeReclaimPolicy `json:"persistentVolumeReclaimPolicy,omitempty"`
@@ -305,7 +323,7 @@ const (
// PersistentVolumeReclaimDelete means the volume will be deleted from Kubernetes on release from its claim.
// The volume plugin must support Deletion.
PersistentVolumeReclaimDelete PersistentVolumeReclaimPolicy = "Delete"
- // PersistentVolumeReclaimRetain means the volume will left in its current phase (Released) for manual reclamation by the administrator.
+ // PersistentVolumeReclaimRetain means the volume will be left in its current phase (Released) for manual reclamation by the administrator.
// The default policy is Retain.
PersistentVolumeReclaimRetain PersistentVolumeReclaimPolicy = "Retain"
)
@@ -350,9 +368,13 @@ type PersistentVolumeClaimList struct {
type PersistentVolumeClaimSpec struct {
// Contains the types of access modes required
AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty"`
+ // A label query over volumes to consider for binding. This selector is
+ // ignored when VolumeName is set
+ Selector *unversioned.LabelSelector `json:"selector,omitempty"`
// Resources represents the minimum resources required
Resources ResourceRequirements `json:"resources,omitempty"`
- // VolumeName is the binding reference to the PersistentVolume backing this claim
+ // VolumeName is the binding reference to the PersistentVolume backing this
+ // claim. When set to non-empty value Selector is not evaluated
VolumeName string `json:"volumeName,omitempty"`
}
@@ -401,6 +423,10 @@ const (
ClaimPending PersistentVolumeClaimPhase = "Pending"
// used for PersistentVolumeClaims that are bound
ClaimBound PersistentVolumeClaimPhase = "Bound"
+ // 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.
+ ClaimLost PersistentVolumeClaimPhase = "Lost"
)
// Represents a host path mapped into a pod.
@@ -456,7 +482,7 @@ type GCEPersistentDiskVolumeSource struct {
// Optional: Partition on the disk to mount.
// If omitted, kubelet will attempt to mount the device name.
// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field is 0 or empty.
- Partition int `json:"partition,omitempty"`
+ Partition int32 `json:"partition,omitempty"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
ReadOnly bool `json:"readOnly,omitempty"`
@@ -472,7 +498,7 @@ type ISCSIVolumeSource struct {
// Required: target iSCSI Qualified Name
IQN string `json:"iqn,omitempty"`
// Required: iSCSI target lun number
- Lun int `json:"lun,omitempty"`
+ Lun int32 `json:"lun,omitempty"`
// Optional: Defaults to 'default' (tcp). iSCSI interface name that uses an iSCSI transport.
ISCSIInterface string `json:"iscsiInterface,omitempty"`
// Filesystem type to mount.
@@ -492,7 +518,7 @@ type FCVolumeSource struct {
// Required: FC target world wide names (WWNs)
TargetWWNs []string `json:"targetWWNs"`
// Required: FC target lun number
- Lun *int `json:"lun"`
+ Lun *int32 `json:"lun"`
// 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.
@@ -512,7 +538,11 @@ type FlexVolumeSource struct {
// Must be a filesystem type supported by the host operating system.
// Ex. "ext4", "xfs", "ntfs". The default filesystem depends on FlexVolume script.
FSType string `json:"fsType,omitempty"`
- // Optional: SecretRef is reference to the authentication secret for User, default is empty.
+ // 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.
SecretRef *LocalObjectReference `json:"secretRef,omitempty"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
@@ -538,7 +568,7 @@ type AWSElasticBlockStoreVolumeSource struct {
// Optional: Partition on the disk to mount.
// If omitted, kubelet will attempt to mount the device name.
// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field is 0 or empty.
- Partition int `json:"partition,omitempty"`
+ Partition int32 `json:"partition,omitempty"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
ReadOnly bool `json:"readOnly,omitempty"`
@@ -568,6 +598,14 @@ type GitRepoVolumeSource struct {
type SecretVolumeSource struct {
// Name of the secret in the pod's namespace to use.
SecretName string `json:"secretName,omitempty"`
+ // 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. Paths must be relative and may not contain
+ // the '..' path or start with '..'.
+ Items []KeyToPath `json:"items,omitempty"`
}
// Represents an NFS mount that lasts the lifetime of a pod.
@@ -611,13 +649,13 @@ type RBDVolumeSource struct {
// TODO: how do we prevent errors in the filesystem from compromising the machine
FSType string `json:"fsType,omitempty"`
// Optional: RadosPool is the rados pool name,default is rbd
- RBDPool string `json:"pool"`
+ RBDPool string `json:"pool,omitempty"`
// Optional: RBDUser is the rados user name, default is admin
- RadosUser string `json:"user"`
+ RadosUser string `json:"user,omitempty"`
// Optional: Keyring is the path to key ring for RBDUser, default is /etc/ceph/keyring
- Keyring string `json:"keyring"`
- // Optional: SecretRef is name of the authentication secret for RBDUser, default is empty.
- SecretRef *LocalObjectReference `json:"secretRef"`
+ Keyring string `json:"keyring,omitempty"`
+ // Optional: SecretRef is name of the authentication secret for RBDUser, default is nil.
+ SecretRef *LocalObjectReference `json:"secretRef,omitempty"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
ReadOnly bool `json:"readOnly,omitempty"`
@@ -676,7 +714,10 @@ type DownwardAPIVolumeFile struct {
// 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 '..'
Path string `json:"path"`
// Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.
- FieldRef ObjectFieldSelector `json:"fieldRef"`
+ FieldRef *ObjectFieldSelector `json:"fieldRef,omitempty"`
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ ResourceFieldRef *ResourceFieldSelector `json:"resourceFieldRef,omitempty"`
}
// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
@@ -690,6 +731,16 @@ type AzureFileVolumeSource struct {
ReadOnly bool `json:"readOnly,omitempty"`
}
+// Represents a vSphere volume resource.
+type VsphereVirtualDiskVolumeSource struct {
+ // Path that identifies vSphere volume vmdk
+ VolumePath string `json:"volumePath"`
+ // 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.
+ FSType string `json:"fsType,omitempty"`
+}
+
// Adapts a ConfigMap into a volume.
//
// The contents of the target ConfigMap's Data field will be presented in a
@@ -727,9 +778,9 @@ type ContainerPort struct {
Name string `json:"name,omitempty"`
// Optional: If specified, this must be a valid port number, 0 < x < 65536.
// If HostNetwork is specified, this must match ContainerPort.
- HostPort int `json:"hostPort,omitempty"`
+ HostPort int32 `json:"hostPort,omitempty"`
// Required: This must be a valid port number, 0 < x < 65536.
- ContainerPort int `json:"containerPort"`
+ ContainerPort int32 `json:"containerPort"`
// Required: Supports "TCP" and "UDP".
Protocol Protocol `json:"protocol,omitempty"`
// Optional: What host IP to bind the external port to.
@@ -744,6 +795,9 @@ type VolumeMount struct {
ReadOnly bool `json:"readOnly,omitempty"`
// Required. Must not contain ':'.
MountPath string `json:"mountPath"`
+ // Path within the volume from which the container's volume should be mounted.
+ // Defaults to "" (volume's root).
+ SubPath string `json:"subPath,omitempty"`
}
// EnvVar represents an environment variable present in a Container.
@@ -768,6 +822,9 @@ type EnvVar struct {
type EnvVarSource struct {
// Selects a field of the pod; only name and namespace are supported.
FieldRef *ObjectFieldSelector `json:"fieldRef,omitempty"`
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ ResourceFieldRef *ResourceFieldSelector `json:"resourceFieldRef,omitempty"`
// Selects a key of a ConfigMap.
ConfigMapKeyRef *ConfigMapKeySelector `json:"configMapKeyRef,omitempty"`
// Selects a key of a secret in the pod's namespace.
@@ -784,6 +841,16 @@ type ObjectFieldSelector struct {
FieldPath string `json:"fieldPath"`
}
+// ResourceFieldSelector represents container resources (cpu, memory) and their output format
+type ResourceFieldSelector struct {
+ // Container name: required for volumes, optional for env vars
+ ContainerName string `json:"containerName,omitempty"`
+ // Required: resource to select
+ Resource string `json:"resource"`
+ // Specifies the output format of the exposed resources, defaults to "1"
+ Divisor resource.Quantity `json:"divisor,omitempty"`
+}
+
// Selects a key from a ConfigMap.
type ConfigMapKeySelector struct {
// The ConfigMap to select from.
@@ -854,16 +921,16 @@ type Probe struct {
// The action taken to determine the health of a container
Handler `json:",inline"`
// Length of time before health checking is activated. In seconds.
- InitialDelaySeconds int `json:"initialDelaySeconds,omitempty"`
+ InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty"`
// Length of time before health checking times out. In seconds.
- TimeoutSeconds int `json:"timeoutSeconds,omitempty"`
+ TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`
// How often (in seconds) to perform the probe.
- PeriodSeconds int `json:"periodSeconds,omitempty"`
+ PeriodSeconds int32 `json:"periodSeconds,omitempty"`
// Minimum consecutive successes for the probe to be considered successful after having failed.
// Must be 1 for liveness.
- SuccessThreshold int `json:"successThreshold,omitempty"`
+ SuccessThreshold int32 `json:"successThreshold,omitempty"`
// Minimum consecutive failures for the probe to be considered failed after having succeeded.
- FailureThreshold int `json:"failureThreshold,omitempty"`
+ FailureThreshold int32 `json:"failureThreshold,omitempty"`
}
// PullPolicy describes a policy for if/when to pull a container image
@@ -994,8 +1061,8 @@ type ContainerStateRunning struct {
}
type ContainerStateTerminated struct {
- ExitCode int `json:"exitCode"`
- Signal int `json:"signal,omitempty"`
+ ExitCode int32 `json:"exitCode"`
+ Signal int32 `json:"signal,omitempty"`
Reason string `json:"reason,omitempty"`
Message string `json:"message,omitempty"`
StartedAt unversioned.Time `json:"startedAt,omitempty"`
@@ -1021,7 +1088,7 @@ type ContainerStatus struct {
Ready bool `json:"ready"`
// Note that this is calculated from dead containers. But those containers are subject to
// garbage collection. This value will get capped at 5 by GC.
- RestartCount int `json:"restartCount"`
+ RestartCount int32 `json:"restartCount"`
Image string `json:"image"`
ImageID string `json:"imageID"`
ContainerID string `json:"containerID,omitempty"`
@@ -1054,9 +1121,13 @@ type PodConditionType string
// These are valid conditions of pod.
const (
+ // PodScheduled represents status of the scheduling process for this pod.
+ PodScheduled PodConditionType = "PodScheduled"
// PodReady means the pod is able to service requests and should be added to the
// load balancing pools of all matching services.
PodReady PodConditionType = "Ready"
+ // PodInitialized means that all init containers in the pod have started successfully.
+ PodInitialized PodConditionType = "Initialized"
)
type PodCondition struct {
@@ -1145,11 +1216,109 @@ const (
NodeSelectorOpLt NodeSelectorOperator = "Lt"
)
-// Affinity is a group of affinity scheduling rules, currently
-// only node affinity, but in the future also inter-pod affinity.
+// Affinity is a group of affinity scheduling rules.
type Affinity struct {
// Describes node affinity scheduling rules for the pod.
NodeAffinity *NodeAffinity `json:"nodeAffinity,omitempty"`
+ // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
+ PodAffinity *PodAffinity `json:"podAffinity,omitempty"`
+ // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
+ PodAntiAffinity *PodAntiAffinity `json:"podAntiAffinity,omitempty"`
+}
+
+// Pod affinity is a group of inter pod affinity scheduling rules.
+type PodAffinity struct {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
+ // 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.
+ PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
+}
+
+// Pod anti affinity is a group of inter pod anti affinity scheduling rules.
+type PodAntiAffinity struct {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
+ // 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.
+ PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
+}
+
+// The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
+type WeightedPodAffinityTerm struct {
+ // weight associated with matching the corresponding podAffinityTerm,
+ // in the range 1-100.
+ Weight int `json:"weight"`
+ // Required. A pod affinity term, associated with the corresponding weight.
+ PodAffinityTerm PodAffinityTerm `json:"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 <topologyKey> matches that of any node on which
+// a pod of the set of pods is running.
+type PodAffinityTerm struct {
+ // A label query over a set of resources, in this case pods.
+ LabelSelector *unversioned.LabelSelector `json:"labelSelector,omitempty"`
+ // namespaces specifies which namespaces the labelSelector applies to (matches against);
+ // nil list means "this pod's namespace," empty list means "all namespaces"
+ // The json tag here is not "omitempty" since we need to distinguish nil and empty.
+ // See https://golang.org/pkg/encoding/json/#Marshal for more details.
+ Namespaces []string `json:"namespaces"`
+ // 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.
+ // For PreferredDuringScheduling pod anti-affinity, empty topologyKey is interpreted as "all topologies"
+ // ("all topologies" here means all the topologyKeys indicated by scheduler command-line argument --failure-domains);
+ // for affinity and for RequiredDuringScheduling pod anti-affinity, empty topologyKey is not allowed.
+ TopologyKey string `json:"topologyKey,omitempty"`
}
// Node affinity is a group of node affinity scheduling rules.
@@ -1184,15 +1353,84 @@ type NodeAffinity struct {
// (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
type PreferredSchedulingTerm struct {
// Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
- Weight int `json:"weight"`
+ Weight int32 `json:"weight"`
// A node selector term, associated with the corresponding weight.
Preference NodeSelectorTerm `json:"preference"`
}
+// The node this Taint is attached to has the effect "effect" on
+// any pod that that does not tolerate the Taint.
+type Taint struct {
+ // Required. The taint key to be applied to a node.
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key"`
+ // Required. The taint value corresponding to the taint key.
+ Value string `json:"value,omitempty"`
+ // Required. The effect of the taint on pods
+ // that do not tolerate the taint.
+ // Valid effects are NoSchedule and PreferNoSchedule.
+ Effect TaintEffect `json:"effect"`
+}
+
+type TaintEffect string
+
+const (
+ // 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.
+ TaintEffectNoSchedule TaintEffect = "NoSchedule"
+ // 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.
+ TaintEffectPreferNoSchedule TaintEffect = "PreferNoSchedule"
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // Do not allow new pods to schedule onto the node unless they tolerate the taint,
+ // do not allow pods to start on Kubelet unless they tolerate the taint,
+ // but allow all already-running pods to continue running.
+ // Enforced by the scheduler and Kubelet.
+ // TaintEffectNoScheduleNoAdmit TaintEffect = "NoScheduleNoAdmit"
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // Do not allow new pods to schedule onto the node unless they tolerate the taint,
+ // do not allow pods to start on Kubelet unless they tolerate the taint,
+ // and evict any already-running pods that do not tolerate the taint.
+ // Enforced by the scheduler and Kubelet.
+ // TaintEffectNoScheduleNoAdmitNoExecute = "NoScheduleNoAdmitNoExecute"
+)
+
+// The pod this Toleration is attached to tolerates any taint that matches
+// the triple <key,value,effect> using the matching operator <operator>.
+type Toleration struct {
+ // Required. Key is the taint key that the toleration applies to.
+ Key string `json:"key,omitempty" patchStrategy:"merge" patchMergeKey:"key"`
+ // 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.
+ Operator TolerationOperator `json:"operator,omitempty"`
+ // Value is the taint value the toleration matches to.
+ // If the operator is Exists, the value should be empty, otherwise just a regular string.
+ Value string `json:"value,omitempty"`
+ // Effect indicates the taint effect to match. Empty means match all taint effects.
+ // When specified, allowed values are NoSchedule and PreferNoSchedule.
+ Effect TaintEffect `json:"effect,omitempty"`
+ // TODO: For forgiveness (#1574), we'd eventually add at least a grace period
+ // here, and possibly an occurrence threshold and period.
+}
+
+// A toleration operator is the set of operators that can be used in a toleration.
+type TolerationOperator string
+
+const (
+ TolerationOpExists TolerationOperator = "Exists"
+ TolerationOpEqual TolerationOperator = "Equal"
+)
+
// PodSpec is a description of a pod
type PodSpec struct {
Volumes []Volume `json:"volumes"`
- // Required: there must be at least one container in a pod.
+ // List of initialization containers belonging to the pod.
+ InitContainers []Container `json:"-"`
+ // List of containers belonging to the pod.
Containers []Container `json:"containers"`
RestartPolicy RestartPolicy `json:"restartPolicy,omitempty"`
// Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request.
@@ -1225,6 +1463,12 @@ type PodSpec struct {
// If specified, these secrets will be passed to individual puller implementations for them to use. For example,
// in the case of docker, only DockerConfig type secrets are honored.
ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty"`
+ // Specifies the hostname of the Pod.
+ // If not specified, the pod's hostname will be set to a system-defined value.
+ Hostname string `json:"hostname,omitempty"`
+ // If specified, the fully qualified Pod hostname will be "<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>".
+ // If not specified, the pod will not have a domainname at all.
+ Subdomain string `json:"subdomain,omitempty"`
}
// PodSecurityContext holds pod-level security attributes and common container settings.
@@ -1293,6 +1537,11 @@ type PodStatus struct {
// This is before the Kubelet pulled the container image(s) for the pod.
StartTime *unversioned.Time `json:"startTime,omitempty"`
+ // 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: http://releases.k8s.io/HEAD/docs/user-guide/pod-states.md#container-statuses
+ InitContainerStatuses []ContainerStatus `json:"-"`
// The list has one entry per container in the manifest. Each entry is
// currently the output of `docker inspect`. This output format is *not*
// final and should not be relied upon.
@@ -1358,7 +1607,7 @@ type PodTemplateList struct {
// a TemplateRef or a Template set.
type ReplicationControllerSpec struct {
// Replicas is the number of desired replicas.
- Replicas int `json:"replicas"`
+ Replicas int32 `json:"replicas"`
// Selector is a label query over pods that should match the Replicas count.
Selector map[string]string `json:"selector"`
@@ -1378,10 +1627,10 @@ type ReplicationControllerSpec struct {
// controller.
type ReplicationControllerStatus struct {
// Replicas is the number of actual replicas.
- Replicas int `json:"replicas"`
+ Replicas int32 `json:"replicas"`
// The number of pods that have labels matching the labels of the pod template of the replication controller.
- FullyLabeledReplicas int `json:"fullyLabeledReplicas,omitempty"`
+ FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`
// ObservedGeneration is the most recent generation observed by the controller.
ObservedGeneration int64 `json:"observedGeneration,omitempty"`
@@ -1510,8 +1759,13 @@ type ServiceSpec struct {
// This field will be ignored if the cloud-provider does not support the feature.
LoadBalancerIP string `json:"loadBalancerIP,omitempty"`
- // Required: Supports "ClientIP" and "None". Used to maintain session affinity.
+ // Optional: Supports "ClientIP" and "None". Used to maintain session affinity.
SessionAffinity ServiceAffinity `json:"sessionAffinity,omitempty"`
+
+ // Optional: 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."
+ LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty"`
}
type ServicePort struct {
@@ -1525,7 +1779,7 @@ type ServicePort struct {
Protocol Protocol `json:"protocol"`
// The port that will be exposed on the service.
- Port int `json:"port"`
+ Port int32 `json:"port"`
// Optional: The target port on pods selected by this service. If this
// is a string, it will be looked up as a named port in the target
@@ -1537,7 +1791,7 @@ type ServicePort struct {
// The port on each node on which this service is exposed.
// Default is to auto-allocate a port if the ServiceType of this Service requires one.
- NodePort int `json:"nodePort"`
+ NodePort int32 `json:"nodePort"`
}
// +genclient=true
@@ -1624,9 +1878,13 @@ type EndpointSubset struct {
// EndpointAddress is a tuple that describes single IP address.
type EndpointAddress struct {
// The IP of this endpoint.
+ // IPv6 is also accepted but not fully supported on all platforms. Also, certain
+ // kubernetes components, like kube-proxy, are not IPv6 ready.
// TODO: This should allow hostname or IP, see #4447.
IP string
-
+ // Optional: Hostname of this endpoint
+ // Meant to be used by DNS servers etc.
+ Hostname string `json:"hostname,omitempty"`
// Optional: The kubernetes object related to the entry point.
TargetRef *ObjectReference
}
@@ -1638,7 +1896,7 @@ type EndpointPort struct {
Name string
// The port number.
- Port int
+ Port int32
// The IP protocol for this port.
Protocol Protocol
@@ -1671,8 +1929,14 @@ type NodeSpec struct {
// DaemonEndpoint contains information about a single Daemon endpoint.
type DaemonEndpoint struct {
+ /*
+ The port tag was not properly in quotes in earlier releases, so it must be
+ uppercased for backwards compat (since it was falling back to var name of
+ 'Port').
+ */
+
// Port number of the given endpoint.
- Port int `json:port`
+ Port int32 `json:"Port"`
}
// NodeDaemonEndpoints lists ports opened by daemons running on the Node.
@@ -1699,6 +1963,10 @@ type NodeSystemInfo struct {
KubeletVersion string `json:"kubeletVersion"`
// KubeProxy Version reported by the node.
KubeProxyVersion string `json:"kubeProxyVersion"`
+ // The Operating System reported by the node
+ OperatingSystem string `json:"operatingSystem"`
+ // The Architecture reported by the node
+ Architecture string `json:"architecture"`
}
// NodeStatus is information about the current status of a node.
@@ -1718,7 +1986,22 @@ type NodeStatus struct {
// Set of ids/uuids to uniquely identify the node.
NodeInfo NodeSystemInfo `json:"nodeInfo,omitempty"`
// List of container images on this node
- Images []ContainerImage `json:"images",omitempty`
+ Images []ContainerImage `json:"images,omitempty"`
+ // List of attachable volumes in use (mounted) by the node.
+ VolumesInUse []UniqueVolumeName `json:"volumesInUse,omitempty"`
+ // List of volumes that are attached to the node.
+ VolumesAttached []AttachedVolume `json:"volumesAttached,omitempty"`
+}
+
+type UniqueVolumeName string
+
+// AttachedVolume describes a volume attached to a node
+type AttachedVolume struct {
+ // Name of the attached volume
+ Name UniqueVolumeName `json:"name"`
+
+ // DevicePath represents the device path where the volume should be avilable
+ DevicePath string `json:"devicePath"`
}
// Describe a container image
@@ -1752,6 +2035,10 @@ const (
// NodeOutOfDisk means the kubelet will not accept new pods due to insufficient free disk
// space on the node.
NodeOutOfDisk NodeConditionType = "OutOfDisk"
+ // NodeMemoryPressure means the kubelet is under pressure due to insufficient available memory.
+ NodeMemoryPressure NodeConditionType = "MemoryPressure"
+ // NodeNetworkUnavailable means that network for the node is not correctly configured.
+ NodeNetworkUnavailable NodeConditionType = "NetworkUnavailable"
)
type NodeCondition struct {
@@ -1789,6 +2076,11 @@ type NodeResources struct {
// ResourceName is the name identifying various resources in a ResourceList.
type ResourceName string
+// Resource names must be not more than 63 characters, consisting of upper- or lower-case alphanumeric characters,
+// with the -, _, and . characters allowed anywhere, except the first or last character.
+// The default convention, matching that for annotations, is to use lower-case names, with dashes, rather than
+// camel case, separating compound words.
+// Fully-qualified resource typenames are constructed from a DNS-style subdomain, followed by a slash `/` and a name.
const (
// CPU, in cores. (500m = .5 cores)
ResourceCPU ResourceName = "cpu"
@@ -1796,6 +2088,8 @@ const (
ResourceMemory ResourceName = "memory"
// Volume size, in bytes (e,g. 5Gi = 5GiB = 5 * 1024 * 1024 * 1024)
ResourceStorage ResourceName = "storage"
+ // NVIDIA GPU, in devices. Alpha, might change: although fractional and allowing values >1, only one whole device per node is assigned.
+ ResourceNvidiaGPU ResourceName = "alpha.kubernetes.io/nvidia-gpu"
// Number of Pods that may be running on this Node: see ResourcePods
)
@@ -1836,6 +2130,7 @@ type FinalizerName string
// These are internal finalizer values to Kubernetes, must be qualified name unless defined here
const (
FinalizerKubernetes FinalizerName = "kubernetes"
+ FinalizerOrphan string = "orphan"
)
// NamespaceStatus is information about the current status of a Namespace.
@@ -1887,6 +2182,12 @@ type Binding struct {
Target ObjectReference `json:"target"`
}
+// Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
+type Preconditions struct {
+ // Specifies the target UID.
+ UID *types.UID `json:"uid,omitempty"`
+}
+
// DeleteOptions may be provided when deleting an API object
type DeleteOptions struct {
unversioned.TypeMeta `json:",inline"`
@@ -1894,7 +2195,15 @@ type DeleteOptions struct {
// Optional 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.
- GracePeriodSeconds *int64 `json:"gracePeriodSeconds"`
+ GracePeriodSeconds *int64 `json:"gracePeriodSeconds,omitempty"`
+
+ // Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be
+ // returned.
+ Preconditions *Preconditions `json:"preconditions,omitempty"`
+
+ // Should the dependent objects be orphaned. If true/false, the "orphan"
+ // finalizer will be added to/removed from the object's finalizers list.
+ OrphanDependents *bool `json:"orphanDependents,omitempty"`
}
// ExportOptions is the query options to the standard REST get call.
@@ -2027,6 +2336,25 @@ type ServiceProxyOptions struct {
Path string
}
+// OwnerReference contains enough information to let you identify an owning
+// object. Currently, an owning object must be in the same namespace, so there
+// is no namespace field.
+type OwnerReference struct {
+ // API version of the referent.
+ APIVersion string `json:"apiVersion"`
+ // Kind of the referent.
+ // More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind"`
+ // Name of the referent.
+ // More info: http://releases.k8s.io/HEAD/docs/user-guide/identifiers.md#names
+ Name string `json:"name"`
+ // UID of the referent.
+ // More info: http://releases.k8s.io/HEAD/docs/user-guide/identifiers.md#uids
+ UID types.UID `json:"uid"`
+ // If true, this reference points to the managing controller.
+ Controller *bool `json:"controller,omitempty"`
+}
+
// ObjectReference contains enough information to let you inspect or modify the referred object.
type ObjectReference struct {
Kind string `json:"kind,omitempty"`
@@ -2104,7 +2432,7 @@ type Event struct {
LastTimestamp unversioned.Time `json:"lastTimestamp,omitempty"`
// The number of times this event has occurred.
- Count int `json:"count,omitempty"`
+ Count int32 `json:"count,omitempty"`
// Type of this event (Normal, Warning), new types could be added in the future.
Type string `json:"type,omitempty"`
@@ -2194,6 +2522,10 @@ const (
ResourceConfigMaps ResourceName = "configmaps"
// ResourcePersistentVolumeClaims, number
ResourcePersistentVolumeClaims ResourceName = "persistentvolumeclaims"
+ // ResourceServicesNodePorts, number
+ ResourceServicesNodePorts ResourceName = "services.nodeports"
+ // ResourceServicesLoadBalancers, number
+ ResourceServicesLoadBalancers ResourceName = "services.loadbalancers"
// CPU request, in cores. (500m = .5 cores)
ResourceRequestsCPU ResourceName = "requests.cpu"
// Memory request, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
@@ -2385,7 +2717,7 @@ type ConfigMapList struct {
unversioned.ListMeta `json:"metadata,omitempty"`
// Items is the list of ConfigMaps.
- Items []ConfigMap `json:"items,omitempty"`
+ Items []ConfigMap `json:"items"`
}
// These constants are for remote command execution and port forwarding and are
@@ -2539,4 +2871,14 @@ type RangeAllocation struct {
const (
// "default-scheduler" is the name of default scheduler.
DefaultSchedulerName = "default-scheduler"
+
+ // RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule
+ // corresponding to every RequiredDuringScheduling affinity rule.
+ // When the --hard-pod-affinity-weight scheduler flag is not specified,
+ // DefaultHardPodAffinityWeight defines the weight of the implicit PreferredDuringScheduling affinity rule.
+ DefaultHardPodAffinitySymmetricWeight int = 1
+
+ // When the --failure-domains scheduler flag is not specified,
+ // DefaultFailureDomains defines the set of label keys used when TopologyKey is empty in PreferredDuringScheduling anti-affinity.
+ DefaultFailureDomains string = unversioned.LabelHostname + "," + unversioned.LabelZoneFailureDomain + "," + unversioned.LabelZoneRegion
)
diff --git a/vendor/k8s.io/kubernetes/pkg/api/unversioned/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..ff8f1f0d66fe8a77f1ff6d342b46c3e74dfe3eb2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/deep_copy_generated.go
@@ -0,0 +1,314 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package unversioned
+
+import (
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ time "time"
+)
+
+func DeepCopy_unversioned_APIGroup(in APIGroup, out *APIGroup, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Name = in.Name
+ if in.Versions != nil {
+ in, out := in.Versions, &out.Versions
+ *out = make([]GroupVersionForDiscovery, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_GroupVersionForDiscovery(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Versions = nil
+ }
+ if err := DeepCopy_unversioned_GroupVersionForDiscovery(in.PreferredVersion, &out.PreferredVersion, c); err != nil {
+ return err
+ }
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]ServerAddressByClientCIDR, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_ServerAddressByClientCIDR(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_APIGroupList(in APIGroupList, out *APIGroupList, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if in.Groups != nil {
+ in, out := in.Groups, &out.Groups
+ *out = make([]APIGroup, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_APIGroup(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Groups = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_APIResource(in APIResource, out *APIResource, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Namespaced = in.Namespaced
+ out.Kind = in.Kind
+ return nil
+}
+
+func DeepCopy_unversioned_APIResourceList(in APIResourceList, out *APIResourceList, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.GroupVersion = in.GroupVersion
+ if in.APIResources != nil {
+ in, out := in.APIResources, &out.APIResources
+ *out = make([]APIResource, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_APIResource(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.APIResources = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_APIVersions(in APIVersions, out *APIVersions, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if in.Versions != nil {
+ in, out := in.Versions, &out.Versions
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Versions = nil
+ }
+ if in.ServerAddressByClientCIDRs != nil {
+ in, out := in.ServerAddressByClientCIDRs, &out.ServerAddressByClientCIDRs
+ *out = make([]ServerAddressByClientCIDR, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_ServerAddressByClientCIDR(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ServerAddressByClientCIDRs = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_Duration(in Duration, out *Duration, c *conversion.Cloner) error {
+ out.Duration = in.Duration
+ return nil
+}
+
+func DeepCopy_unversioned_ExportOptions(in ExportOptions, out *ExportOptions, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Export = in.Export
+ out.Exact = in.Exact
+ return nil
+}
+
+func DeepCopy_unversioned_GroupKind(in GroupKind, out *GroupKind, c *conversion.Cloner) error {
+ out.Group = in.Group
+ out.Kind = in.Kind
+ return nil
+}
+
+func DeepCopy_unversioned_GroupResource(in GroupResource, out *GroupResource, c *conversion.Cloner) error {
+ out.Group = in.Group
+ out.Resource = in.Resource
+ return nil
+}
+
+func DeepCopy_unversioned_GroupVersion(in GroupVersion, out *GroupVersion, c *conversion.Cloner) error {
+ out.Group = in.Group
+ out.Version = in.Version
+ return nil
+}
+
+func DeepCopy_unversioned_GroupVersionForDiscovery(in GroupVersionForDiscovery, out *GroupVersionForDiscovery, c *conversion.Cloner) error {
+ out.GroupVersion = in.GroupVersion
+ out.Version = in.Version
+ return nil
+}
+
+func DeepCopy_unversioned_GroupVersionKind(in GroupVersionKind, out *GroupVersionKind, c *conversion.Cloner) error {
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Kind = in.Kind
+ return nil
+}
+
+func DeepCopy_unversioned_GroupVersionResource(in GroupVersionResource, out *GroupVersionResource, c *conversion.Cloner) error {
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Resource = in.Resource
+ return nil
+}
+
+func DeepCopy_unversioned_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
+ if in.MatchLabels != nil {
+ in, out := in.MatchLabels, &out.MatchLabels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.MatchLabels = nil
+ }
+ if in.MatchExpressions != nil {
+ in, out := in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_LabelSelectorRequirement(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ if in.Values != nil {
+ in, out := in.Values, &out.Values
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Values = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_ListMeta(in ListMeta, out *ListMeta, c *conversion.Cloner) error {
+ out.SelfLink = in.SelfLink
+ out.ResourceVersion = in.ResourceVersion
+ return nil
+}
+
+func DeepCopy_unversioned_Patch(in Patch, out *Patch, c *conversion.Cloner) error {
+ return nil
+}
+
+func DeepCopy_unversioned_RootPaths(in RootPaths, out *RootPaths, c *conversion.Cloner) error {
+ if in.Paths != nil {
+ in, out := in.Paths, &out.Paths
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Paths = nil
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_ServerAddressByClientCIDR(in ServerAddressByClientCIDR, out *ServerAddressByClientCIDR, c *conversion.Cloner) error {
+ out.ClientCIDR = in.ClientCIDR
+ out.ServerAddress = in.ServerAddress
+ return nil
+}
+
+func DeepCopy_unversioned_Status(in Status, out *Status, c *conversion.Cloner) error {
+ if err := DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ out.Status = in.Status
+ out.Message = in.Message
+ out.Reason = in.Reason
+ if in.Details != nil {
+ in, out := in.Details, &out.Details
+ *out = new(StatusDetails)
+ if err := DeepCopy_unversioned_StatusDetails(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Details = nil
+ }
+ out.Code = in.Code
+ return nil
+}
+
+func DeepCopy_unversioned_StatusCause(in StatusCause, out *StatusCause, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Message = in.Message
+ out.Field = in.Field
+ return nil
+}
+
+func DeepCopy_unversioned_StatusDetails(in StatusDetails, out *StatusDetails, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Group = in.Group
+ out.Kind = in.Kind
+ if in.Causes != nil {
+ in, out := in.Causes, &out.Causes
+ *out = make([]StatusCause, len(in))
+ for i := range in {
+ if err := DeepCopy_unversioned_StatusCause(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Causes = nil
+ }
+ out.RetryAfterSeconds = in.RetryAfterSeconds
+ return nil
+}
+
+func DeepCopy_unversioned_Time(in Time, out *Time, c *conversion.Cloner) error {
+ if newVal, err := c.DeepCopy(in.Time); err != nil {
+ return err
+ } else {
+ out.Time = newVal.(time.Time)
+ }
+ return nil
+}
+
+func DeepCopy_unversioned_Timestamp(in Timestamp, out *Timestamp, c *conversion.Cloner) error {
+ out.Seconds = in.Seconds
+ out.Nanos = in.Nanos
+ return nil
+}
+
+func DeepCopy_unversioned_TypeMeta(in TypeMeta, out *TypeMeta, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.APIVersion = in.APIVersion
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/duration.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/duration.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/duration.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/duration.go
index 6ff634ee525e3d0c4625449356163957e9df7b49..cdaf257300b493b59018fc7b580b4eb2590859ab 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/duration.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/duration.go
@@ -25,7 +25,7 @@ import (
// marshaling to YAML and JSON. In particular, it marshals into strings, which
// can be used as map keys in json.
type Duration struct {
- time.Duration
+ time.Duration `protobuf:"varint,1,opt,name=duration,casttype=time.Duration"`
}
// UnmarshalJSON implements the json.Unmarshaller interface.
diff --git a/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..cb9803552ed76520e5767947a82888660da6e86b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.pb.go
@@ -0,0 +1,4212 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/api/unversioned/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package unversioned is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/api/unversioned/generated.proto
+
+ It has these top-level messages:
+ APIGroup
+ APIGroupList
+ APIResource
+ APIResourceList
+ APIVersions
+ Duration
+ ExportOptions
+ GroupKind
+ GroupResource
+ GroupVersion
+ GroupVersionForDiscovery
+ GroupVersionKind
+ GroupVersionResource
+ LabelSelector
+ LabelSelectorRequirement
+ ListMeta
+ RootPaths
+ ServerAddressByClientCIDR
+ Status
+ StatusCause
+ StatusDetails
+ Time
+ Timestamp
+ TypeMeta
+*/
+package unversioned
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import time "time"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *APIGroup) Reset() { *m = APIGroup{} }
+func (m *APIGroup) String() string { return proto.CompactTextString(m) }
+func (*APIGroup) ProtoMessage() {}
+
+func (m *APIGroupList) Reset() { *m = APIGroupList{} }
+func (m *APIGroupList) String() string { return proto.CompactTextString(m) }
+func (*APIGroupList) ProtoMessage() {}
+
+func (m *APIResource) Reset() { *m = APIResource{} }
+func (m *APIResource) String() string { return proto.CompactTextString(m) }
+func (*APIResource) ProtoMessage() {}
+
+func (m *APIResourceList) Reset() { *m = APIResourceList{} }
+func (m *APIResourceList) String() string { return proto.CompactTextString(m) }
+func (*APIResourceList) ProtoMessage() {}
+
+func (m *APIVersions) Reset() { *m = APIVersions{} }
+func (*APIVersions) ProtoMessage() {}
+
+func (m *Duration) Reset() { *m = Duration{} }
+func (m *Duration) String() string { return proto.CompactTextString(m) }
+func (*Duration) ProtoMessage() {}
+
+func (m *ExportOptions) Reset() { *m = ExportOptions{} }
+func (m *ExportOptions) String() string { return proto.CompactTextString(m) }
+func (*ExportOptions) ProtoMessage() {}
+
+func (m *GroupKind) Reset() { *m = GroupKind{} }
+func (*GroupKind) ProtoMessage() {}
+
+func (m *GroupResource) Reset() { *m = GroupResource{} }
+func (*GroupResource) ProtoMessage() {}
+
+func (m *GroupVersion) Reset() { *m = GroupVersion{} }
+func (*GroupVersion) ProtoMessage() {}
+
+func (m *GroupVersionForDiscovery) Reset() { *m = GroupVersionForDiscovery{} }
+func (m *GroupVersionForDiscovery) String() string { return proto.CompactTextString(m) }
+func (*GroupVersionForDiscovery) ProtoMessage() {}
+
+func (m *GroupVersionKind) Reset() { *m = GroupVersionKind{} }
+func (*GroupVersionKind) ProtoMessage() {}
+
+func (m *GroupVersionResource) Reset() { *m = GroupVersionResource{} }
+func (*GroupVersionResource) ProtoMessage() {}
+
+func (m *LabelSelector) Reset() { *m = LabelSelector{} }
+func (m *LabelSelector) String() string { return proto.CompactTextString(m) }
+func (*LabelSelector) ProtoMessage() {}
+
+func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} }
+func (m *LabelSelectorRequirement) String() string { return proto.CompactTextString(m) }
+func (*LabelSelectorRequirement) ProtoMessage() {}
+
+func (m *ListMeta) Reset() { *m = ListMeta{} }
+func (m *ListMeta) String() string { return proto.CompactTextString(m) }
+func (*ListMeta) ProtoMessage() {}
+
+func (m *RootPaths) Reset() { *m = RootPaths{} }
+func (m *RootPaths) String() string { return proto.CompactTextString(m) }
+func (*RootPaths) ProtoMessage() {}
+
+func (m *ServerAddressByClientCIDR) Reset() { *m = ServerAddressByClientCIDR{} }
+func (m *ServerAddressByClientCIDR) String() string { return proto.CompactTextString(m) }
+func (*ServerAddressByClientCIDR) ProtoMessage() {}
+
+func (m *Status) Reset() { *m = Status{} }
+func (m *Status) String() string { return proto.CompactTextString(m) }
+func (*Status) ProtoMessage() {}
+
+func (m *StatusCause) Reset() { *m = StatusCause{} }
+func (m *StatusCause) String() string { return proto.CompactTextString(m) }
+func (*StatusCause) ProtoMessage() {}
+
+func (m *StatusDetails) Reset() { *m = StatusDetails{} }
+func (m *StatusDetails) String() string { return proto.CompactTextString(m) }
+func (*StatusDetails) ProtoMessage() {}
+
+func (m *Time) Reset() { *m = Time{} }
+func (m *Time) String() string { return proto.CompactTextString(m) }
+func (*Time) ProtoMessage() {}
+
+func (m *Timestamp) Reset() { *m = Timestamp{} }
+func (m *Timestamp) String() string { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage() {}
+
+func (m *TypeMeta) Reset() { *m = TypeMeta{} }
+func (m *TypeMeta) String() string { return proto.CompactTextString(m) }
+func (*TypeMeta) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*APIGroup)(nil), "k8s.io.kubernetes.pkg.api.unversioned.APIGroup")
+ proto.RegisterType((*APIGroupList)(nil), "k8s.io.kubernetes.pkg.api.unversioned.APIGroupList")
+ proto.RegisterType((*APIResource)(nil), "k8s.io.kubernetes.pkg.api.unversioned.APIResource")
+ proto.RegisterType((*APIResourceList)(nil), "k8s.io.kubernetes.pkg.api.unversioned.APIResourceList")
+ proto.RegisterType((*APIVersions)(nil), "k8s.io.kubernetes.pkg.api.unversioned.APIVersions")
+ proto.RegisterType((*Duration)(nil), "k8s.io.kubernetes.pkg.api.unversioned.Duration")
+ proto.RegisterType((*ExportOptions)(nil), "k8s.io.kubernetes.pkg.api.unversioned.ExportOptions")
+ proto.RegisterType((*GroupKind)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupKind")
+ proto.RegisterType((*GroupResource)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupResource")
+ proto.RegisterType((*GroupVersion)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupVersion")
+ proto.RegisterType((*GroupVersionForDiscovery)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupVersionForDiscovery")
+ proto.RegisterType((*GroupVersionKind)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupVersionKind")
+ proto.RegisterType((*GroupVersionResource)(nil), "k8s.io.kubernetes.pkg.api.unversioned.GroupVersionResource")
+ proto.RegisterType((*LabelSelector)(nil), "k8s.io.kubernetes.pkg.api.unversioned.LabelSelector")
+ proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.kubernetes.pkg.api.unversioned.LabelSelectorRequirement")
+ proto.RegisterType((*ListMeta)(nil), "k8s.io.kubernetes.pkg.api.unversioned.ListMeta")
+ proto.RegisterType((*RootPaths)(nil), "k8s.io.kubernetes.pkg.api.unversioned.RootPaths")
+ proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.kubernetes.pkg.api.unversioned.ServerAddressByClientCIDR")
+ proto.RegisterType((*Status)(nil), "k8s.io.kubernetes.pkg.api.unversioned.Status")
+ proto.RegisterType((*StatusCause)(nil), "k8s.io.kubernetes.pkg.api.unversioned.StatusCause")
+ proto.RegisterType((*StatusDetails)(nil), "k8s.io.kubernetes.pkg.api.unversioned.StatusDetails")
+ proto.RegisterType((*Time)(nil), "k8s.io.kubernetes.pkg.api.unversioned.Time")
+ proto.RegisterType((*Timestamp)(nil), "k8s.io.kubernetes.pkg.api.unversioned.Timestamp")
+ proto.RegisterType((*TypeMeta)(nil), "k8s.io.kubernetes.pkg.api.unversioned.TypeMeta")
+}
+func (m *APIGroup) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIGroup) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ if len(m.Versions) > 0 {
+ for _, msg := range m.Versions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PreferredVersion.Size()))
+ n1, err := m.PreferredVersion.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, msg := range m.ServerAddressByClientCIDRs {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *APIGroupList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIGroupList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Groups) > 0 {
+ for _, msg := range m.Groups {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *APIResource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIResource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x10
+ i++
+ if m.Namespaced {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ return i, nil
+}
+
+func (m *APIResourceList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIResourceList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.GroupVersion)))
+ i += copy(data[i:], m.GroupVersion)
+ if len(m.APIResources) > 0 {
+ for _, msg := range m.APIResources {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *APIVersions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIVersions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Versions) > 0 {
+ for _, s := range m.Versions {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, msg := range m.ServerAddressByClientCIDRs {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *Duration) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Duration) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Duration))
+ return i, nil
+}
+
+func (m *ExportOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ExportOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Export {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ if m.Exact {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *GroupKind) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupKind) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ return i, nil
+}
+
+func (m *GroupResource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupResource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Resource)))
+ i += copy(data[i:], m.Resource)
+ return i, nil
+}
+
+func (m *GroupVersion) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupVersion) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Version)))
+ i += copy(data[i:], m.Version)
+ return i, nil
+}
+
+func (m *GroupVersionForDiscovery) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupVersionForDiscovery) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.GroupVersion)))
+ i += copy(data[i:], m.GroupVersion)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Version)))
+ i += copy(data[i:], m.Version)
+ return i, nil
+}
+
+func (m *GroupVersionKind) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupVersionKind) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Version)))
+ i += copy(data[i:], m.Version)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ return i, nil
+}
+
+func (m *GroupVersionResource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GroupVersionResource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Version)))
+ i += copy(data[i:], m.Version)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Resource)))
+ i += copy(data[i:], m.Resource)
+ return i, nil
+}
+
+func (m *LabelSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k := range m.MatchLabels {
+ data[i] = 0xa
+ i++
+ v := m.MatchLabels[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, msg := range m.MatchExpressions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LabelSelectorRequirement) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelectorRequirement) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ListMeta) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ListMeta) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SelfLink)))
+ i += copy(data[i:], m.SelfLink)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ResourceVersion)))
+ i += copy(data[i:], m.ResourceVersion)
+ return i, nil
+}
+
+func (m *RootPaths) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RootPaths) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Paths) > 0 {
+ for _, s := range m.Paths {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ServerAddressByClientCIDR) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServerAddressByClientCIDR) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ClientCIDR)))
+ i += copy(data[i:], m.ClientCIDR)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ServerAddress)))
+ i += copy(data[i:], m.ServerAddress)
+ return i, nil
+}
+
+func (m *Status) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Status) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n2, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ if m.Details != nil {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Details.Size()))
+ n3, err := m.Details.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ }
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Code))
+ return i, nil
+}
+
+func (m *StatusCause) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *StatusCause) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Field)))
+ i += copy(data[i:], m.Field)
+ return i, nil
+}
+
+func (m *StatusDetails) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *StatusDetails) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Group)))
+ i += copy(data[i:], m.Group)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ if len(m.Causes) > 0 {
+ for _, msg := range m.Causes {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RetryAfterSeconds))
+ return i, nil
+}
+
+func (m *Timestamp) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Timestamp) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Seconds))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Nanos))
+ return i, nil
+}
+
+func (m *TypeMeta) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *TypeMeta) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *APIGroup) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Versions) > 0 {
+ for _, e := range m.Versions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.PreferredVersion.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, e := range m.ServerAddressByClientCIDRs {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *APIGroupList) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Groups) > 0 {
+ for _, e := range m.Groups {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *APIResource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *APIResourceList) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.GroupVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.APIResources) > 0 {
+ for _, e := range m.APIResources {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *APIVersions) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Versions) > 0 {
+ for _, s := range m.Versions {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.ServerAddressByClientCIDRs) > 0 {
+ for _, e := range m.ServerAddressByClientCIDRs {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *Duration) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Duration))
+ return n
+}
+
+func (m *ExportOptions) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 2
+ return n
+}
+
+func (m *GroupKind) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GroupResource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Resource)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GroupVersion) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Version)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GroupVersionForDiscovery) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.GroupVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Version)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GroupVersionKind) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Version)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GroupVersionResource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Version)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Resource)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *LabelSelector) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k, v := range m.MatchLabels {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, e := range m.MatchExpressions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LabelSelectorRequirement) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ListMeta) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.SelfLink)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ResourceVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *RootPaths) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Paths) > 0 {
+ for _, s := range m.Paths {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ServerAddressByClientCIDR) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.ClientCIDR)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ServerAddress)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Status) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Details != nil {
+ l = m.Details.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.Code))
+ return n
+}
+
+func (m *StatusCause) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Field)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *StatusDetails) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Group)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Causes) > 0 {
+ for _, e := range m.Causes {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ n += 1 + sovGenerated(uint64(m.RetryAfterSeconds))
+ return n
+}
+
+func (m *Timestamp) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Seconds))
+ n += 1 + sovGenerated(uint64(m.Nanos))
+ return n
+}
+
+func (m *TypeMeta) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *APIGroup) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIGroup: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIGroup: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Versions = append(m.Versions, GroupVersionForDiscovery{})
+ if err := m.Versions[len(m.Versions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreferredVersion", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.PreferredVersion.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
+ if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *APIGroupList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIGroupList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Groups = append(m.Groups, APIGroup{})
+ if err := m.Groups[len(m.Groups)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *APIResource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIResource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIResource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Namespaced = bool(v != 0)
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *APIResourceList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIResourceList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.GroupVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIResources", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIResources = append(m.APIResources, APIResource{})
+ if err := m.APIResources[len(m.APIResources)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *APIVersions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIVersions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIVersions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Versions = append(m.Versions, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
+ if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Duration) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Duration: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
+ }
+ m.Duration = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Duration |= (time.Duration(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ExportOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Export = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Exact = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupKind) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupKind: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupKind: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupResource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupResource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupResource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Resource = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupVersion) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupVersion: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupVersion: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Version = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupVersionForDiscovery) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupVersionForDiscovery: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupVersionForDiscovery: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.GroupVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Version = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupVersionKind) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupVersionKind: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupVersionKind: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Version = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GroupVersionResource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GroupVersionResource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GroupVersionResource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Version = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Resource = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.MatchLabels == nil {
+ m.MatchLabels = make(map[string]string)
+ }
+ m.MatchLabels[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
+ if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelectorRequirement) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = LabelSelectorOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Values = append(m.Values, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ListMeta) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ListMeta: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ListMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SelfLink = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RootPaths) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RootPaths: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RootPaths: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Paths = append(m.Paths, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServerAddressByClientCIDR) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServerAddressByClientCIDR: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ClientCIDR = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServerAddress = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Status) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Status: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = StatusReason(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Details == nil {
+ m.Details = &StatusDetails{}
+ }
+ if err := m.Details.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
+ }
+ m.Code = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Code |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *StatusCause) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: StatusCause: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: StatusCause: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = CauseType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Field = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *StatusDetails) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: StatusDetails: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: StatusDetails: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Group = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Causes", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Causes = append(m.Causes, StatusCause{})
+ if err := m.Causes[len(m.Causes)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RetryAfterSeconds", wireType)
+ }
+ m.RetryAfterSeconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.RetryAfterSeconds |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Timestamp) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Timestamp: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType)
+ }
+ m.Seconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Seconds |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType)
+ }
+ m.Nanos = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Nanos |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *TypeMeta) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.proto b/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..e26cbd7b3e8b64c0b5a5b9288887d5183eedeba6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/generated.proto
@@ -0,0 +1,377 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.api.unversioned;
+
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "unversioned";
+
+// APIGroup contains the name, the supported versions, and the preferred version
+// of a group.
+message APIGroup {
+ // name is the name of the group.
+ optional string name = 1;
+
+ // versions are the versions supported in this group.
+ repeated GroupVersionForDiscovery versions = 2;
+
+ // preferredVersion is the version preferred by the API server, which
+ // probably is the storage version.
+ optional GroupVersionForDiscovery preferredVersion = 3;
+
+ // 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.
+ repeated ServerAddressByClientCIDR serverAddressByClientCIDRs = 4;
+}
+
+// APIGroupList is a list of APIGroup, to allow clients to discover the API at
+// /apis.
+message APIGroupList {
+ // groups is a list of APIGroup.
+ repeated APIGroup groups = 1;
+}
+
+// APIResource specifies the name of a resource and whether it is namespaced.
+message APIResource {
+ // name is the name of the resource.
+ optional string name = 1;
+
+ // namespaced indicates if a resource is namespaced or not.
+ optional bool namespaced = 2;
+
+ // kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')
+ optional string kind = 3;
+}
+
+// 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.
+message APIResourceList {
+ // groupVersion is the group and version this APIResourceList is for.
+ optional string groupVersion = 1;
+
+ // resources contains the name of the resources and if they are namespaced.
+ repeated APIResource resources = 2;
+}
+
+// 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.
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message APIVersions {
+ // versions are the api versions that are available.
+ repeated string versions = 1;
+
+ // 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.
+ repeated ServerAddressByClientCIDR serverAddressByClientCIDRs = 2;
+}
+
+// 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.
+message Duration {
+ optional int64 duration = 1;
+}
+
+// ExportOptions is the query options to the standard REST get call.
+message ExportOptions {
+ // Should this value be exported. Export strips fields that a user can not specify.`
+ optional bool export = 1;
+
+ // Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
+ optional bool exact = 2;
+}
+
+// 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 types
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message GroupKind {
+ optional string group = 1;
+
+ optional string kind = 2;
+}
+
+// GroupResource specifies a Group and a Resource, but does not force a version. This is useful for identifying
+// concepts during lookup stages without having partially valid types
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message GroupResource {
+ optional string group = 1;
+
+ optional string resource = 2;
+}
+
+// GroupVersion contains the "group" and the "version", which uniquely identifies the API.
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message GroupVersion {
+ optional string group = 1;
+
+ optional string version = 2;
+}
+
+// GroupVersion contains the "group/version" and "version" string of a version.
+// It is made a struct to keep extensiblity.
+message GroupVersionForDiscovery {
+ // groupVersion specifies the API group and version in the form "group/version"
+ optional string groupVersion = 1;
+
+ // version specifies the version in the form of "version". This is to save
+ // the clients the trouble of splitting the GroupVersion.
+ optional string version = 2;
+}
+
+// GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion
+// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message GroupVersionKind {
+ optional string group = 1;
+
+ optional string version = 2;
+
+ optional string kind = 3;
+}
+
+// GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion
+// to avoid automatic coersion. It doesn't use a GroupVersion to avoid custom marshalling
+//
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message GroupVersionResource {
+ optional string group = 1;
+
+ optional string version = 2;
+
+ optional string resource = 3;
+}
+
+// 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.
+message LabelSelector {
+ // 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.
+ map<string, string> matchLabels = 1;
+
+ // matchExpressions is a list of label selector requirements. The requirements are ANDed.
+ repeated LabelSelectorRequirement matchExpressions = 2;
+}
+
+// A label selector requirement is a selector that contains values, a key, and an operator that
+// relates the key and values.
+message LabelSelectorRequirement {
+ // key is the label key that the selector applies to.
+ optional string key = 1;
+
+ // operator represents a key's relationship to a set of values.
+ // Valid operators ard In, NotIn, Exists and DoesNotExist.
+ optional string operator = 2;
+
+ // 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.
+ repeated string values = 3;
+}
+
+// ListMeta describes metadata that synthetic resources must have, including lists and
+// various status objects. A resource may have only one of {ObjectMeta, ListMeta}.
+message ListMeta {
+ // SelfLink is a URL representing this object.
+ // Populated by the system.
+ // Read-only.
+ optional string selfLink = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ optional string resourceVersion = 2;
+}
+
+// RootPaths lists the paths available at root.
+// For example: "/healthz", "/apis".
+message RootPaths {
+ // paths are the paths available at root.
+ repeated string paths = 1;
+}
+
+// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
+message ServerAddressByClientCIDR {
+ // The CIDR with which clients can match their IP to figure out the server address that they should use.
+ optional string clientCIDR = 1;
+
+ // Address of this server, suitable for a client that matches the above CIDR.
+ // This can be a hostname, hostname:port, IP or IP:port.
+ optional string serverAddress = 2;
+}
+
+// Status is a return value for calls that don't return other objects.
+message Status {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional ListMeta metadata = 1;
+
+ // Status of the operation.
+ // One of: "Success" or "Failure".
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional string status = 2;
+
+ // A human-readable description of the status of this operation.
+ optional string message = 3;
+
+ // 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.
+ optional string reason = 4;
+
+ // 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.
+ optional StatusDetails details = 5;
+
+ // Suggested HTTP return code for this status, 0 if not set.
+ optional int32 code = 6;
+}
+
+// StatusCause provides more information about an api.Status failure, including
+// cases when multiple errors are encountered.
+message StatusCause {
+ // A machine-readable description of the cause of the error. If this value is
+ // empty there is no information available.
+ optional string reason = 1;
+
+ // A human-readable description of the cause of the error. This field may be
+ // presented as-is to a reader.
+ optional string message = 2;
+
+ // 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"
+ optional string field = 3;
+}
+
+// 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.
+message StatusDetails {
+ // The name attribute of the resource associated with the status StatusReason
+ // (when there is a single name which can be described).
+ optional string name = 1;
+
+ // The group attribute of the resource associated with the status StatusReason.
+ optional string group = 2;
+
+ // The kind attribute of the resource associated with the status StatusReason.
+ // On some operations may differ from the requested resource Kind.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional string kind = 3;
+
+ // The Causes array includes more details associated with the StatusReason
+ // failure. Not all StatusReasons may provide detailed causes.
+ repeated StatusCause causes = 4;
+
+ // If specified, the time in seconds before the operation should be retried.
+ optional int32 retryAfterSeconds = 5;
+}
+
+// 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.
+//
+// +protobuf.options.marshal=false
+// +protobuf.as=Timestamp
+message Time {
+ // Represents seconds of UTC time since Unix epoch
+ // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+ // 9999-12-31T23:59:59Z inclusive.
+ optional int64 seconds = 1;
+
+ // Non-negative fractions of a second at nanosecond resolution. Negative
+ // second values with fractions must still have non-negative nanos values
+ // that count forward in time. Must be from 0 to 999,999,999
+ // inclusive. This field may be limited in precision depending on context.
+ optional int32 nanos = 2;
+}
+
+// Timestamp is a struct that is equivalent to Time, but intended for
+// protobuf marshalling/unmarshalling. It is generated into a serialization
+// that matches Time. Do not use in Go structs.
+message Timestamp {
+ // Represents seconds of UTC time since Unix epoch
+ // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+ // 9999-12-31T23:59:59Z inclusive.
+ optional int64 seconds = 1;
+
+ // Non-negative fractions of a second at nanosecond resolution. Negative
+ // second values with fractions must still have non-negative nanos values
+ // that count forward in time. Must be from 0 to 999,999,999
+ // inclusive. This field may be limited in precision depending on context.
+ optional int32 nanos = 2;
+}
+
+// TypeMeta describes an individual object in an API response or request
+// with strings representing the type of the object and its API schema version.
+// Structures that are versioned or persisted should inline TypeMeta.
+message TypeMeta {
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional string kind = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#resources
+ optional string apiVersion = 2;
+}
+
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/group_version.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/group_version.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/group_version.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/group_version.go
index 5d350432c3ba8e217bf988bc7ca870e91ba5fa7a..167002c3fc711a180f60a229e2b935587bcccb88 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/group_version.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/group_version.go
@@ -29,8 +29,8 @@ import (
// `resource.group.com` -> `group=com, version=group, resource=resource` and `group=group.com, resource=resource`
func ParseResourceArg(arg string) (*GroupVersionResource, GroupResource) {
var gvr *GroupVersionResource
- s := strings.SplitN(arg, ".", 3)
- if len(s) == 3 {
+ if strings.Count(arg, ".") >= 2 {
+ s := strings.SplitN(arg, ".", 3)
gvr = &GroupVersionResource{Group: s[2], Version: s[1], Resource: s[0]}
}
@@ -42,8 +42,8 @@ func ParseResourceArg(arg string) (*GroupVersionResource, GroupResource) {
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupResource struct {
- Group string
- Resource string
+ Group string `protobuf:"bytes,1,opt,name=group"`
+ Resource string `protobuf:"bytes,2,opt,name=resource"`
}
func (gr GroupResource) WithVersion(version string) GroupVersionResource {
@@ -64,12 +64,11 @@ func (gr *GroupResource) String() string {
// ParseGroupResource turns "resource.group" string into a GroupResource struct. Empty strings are allowed
// for each field.
func ParseGroupResource(gr string) GroupResource {
- s := strings.SplitN(gr, ".", 2)
- if len(s) == 1 {
- return GroupResource{Resource: s[0]}
+ if i := strings.Index(gr, "."); i == -1 {
+ return GroupResource{Resource: gr}
+ } else {
+ return GroupResource{Group: gr[i+1:], Resource: gr[:i]}
}
-
- return GroupResource{Group: s[1], Resource: s[0]}
}
// GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion
@@ -77,9 +76,9 @@ func ParseGroupResource(gr string) GroupResource {
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupVersionResource struct {
- Group string
- Version string
- Resource string
+ Group string `protobuf:"bytes,1,opt,name=group"`
+ Version string `protobuf:"bytes,2,opt,name=version"`
+ Resource string `protobuf:"bytes,3,opt,name=resource"`
}
func (gvr GroupVersionResource) IsEmpty() bool {
@@ -103,8 +102,8 @@ func (gvr *GroupVersionResource) String() string {
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupKind struct {
- Group string
- Kind string
+ Group string `protobuf:"bytes,1,opt,name=group"`
+ Kind string `protobuf:"bytes,2,opt,name=kind"`
}
func (gk GroupKind) IsEmpty() bool {
@@ -127,9 +126,9 @@ func (gk *GroupKind) String() string {
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupVersionKind struct {
- Group string
- Version string
- Kind string
+ Group string `protobuf:"bytes,1,opt,name=group"`
+ Version string `protobuf:"bytes,2,opt,name=version"`
+ Kind string `protobuf:"bytes,3,opt,name=kind"`
}
// IsEmpty returns true if group, version, and kind are empty
@@ -153,8 +152,8 @@ func (gvk GroupVersionKind) String() string {
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupVersion struct {
- Group string
- Version string
+ Group string `protobuf:"bytes,1,opt,name=group"`
+ Version string `protobuf:"bytes,2,opt,name=version"`
}
// IsEmpty returns true if group and version are empty
@@ -189,18 +188,14 @@ func ParseGroupVersion(gv string) (GroupVersion, error) {
return GroupVersion{}, nil
}
- s := strings.Split(gv, "/")
- // "v1" is the only special case. Otherwise GroupVersion is expected to contain
- // one "/" dividing the string into two parts.
- switch {
- case len(s) == 1 && gv == "v1":
- return GroupVersion{"", "v1"}, nil
- case len(s) == 1:
- return GroupVersion{"", s[0]}, nil
- case len(s) == 2:
- return GroupVersion{s[0], s[1]}, nil
+ switch strings.Count(gv, "/") {
+ case 0:
+ return GroupVersion{"", gv}, nil
+ case 1:
+ i := strings.Index(gv, "/")
+ return GroupVersion{gv[:i], gv[i+1:]}, nil
default:
- return GroupVersion{}, fmt.Errorf("Unexpected GroupVersion string: %v", gv)
+ return GroupVersion{}, fmt.Errorf("unexpected GroupVersion string: %v", gv)
}
}
@@ -259,11 +254,11 @@ func (gvk *GroupVersionKind) ToAPIVersionAndKind() (string, string) {
// do not use TypeMeta. This method exists to support test types and legacy serializations
// that have a distinct group and kind.
// TODO: further reduce usage of this method.
-func FromAPIVersionAndKind(apiVersion, kind string) *GroupVersionKind {
+func FromAPIVersionAndKind(apiVersion, kind string) GroupVersionKind {
if gv, err := ParseGroupVersion(apiVersion); err == nil {
- return &GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
+ return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
}
- return &GroupVersionKind{Kind: kind}
+ return GroupVersionKind{Kind: kind}
}
// All objects that are serialized from a Scheme encode their type information. This interface is used
@@ -273,10 +268,10 @@ func FromAPIVersionAndKind(apiVersion, kind string) *GroupVersionKind {
type ObjectKind interface {
// SetGroupVersionKind sets or clears the intended serialized kind of an object. Passing kind nil
// should clear the current setting.
- SetGroupVersionKind(kind *GroupVersionKind)
+ SetGroupVersionKind(kind GroupVersionKind)
// GroupVersionKind returns the stored group, version, and kind of an object, or nil if the object does
// not expose or provide these fields.
- GroupVersionKind() *GroupVersionKind
+ GroupVersionKind() GroupVersionKind
}
// EmptyObjectKind implements the ObjectKind interface as a noop
@@ -286,7 +281,7 @@ var EmptyObjectKind = emptyObjectKind{}
type emptyObjectKind struct{}
// SetGroupVersionKind implements the ObjectKind interface
-func (emptyObjectKind) SetGroupVersionKind(gvk *GroupVersionKind) {}
+func (emptyObjectKind) SetGroupVersionKind(gvk GroupVersionKind) {}
// GroupVersionKind implements the ObjectKind interface
-func (emptyObjectKind) GroupVersionKind() *GroupVersionKind { return nil }
+func (emptyObjectKind) GroupVersionKind() GroupVersionKind { return GroupVersionKind{} }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/helpers.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/helpers.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/helpers.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/helpers.go
diff --git a/vendor/k8s.io/kubernetes/pkg/api/unversioned/meta.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/meta.go
new file mode 100644
index 0000000000000000000000000000000000000000..b82b1990e1ea0563c241d93ca1549d452dcb8f74
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/meta.go
@@ -0,0 +1,62 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+// ListMetaAccessor retrieves the list interface from an object
+// TODO: move this, and TypeMeta and ListMeta, to a different package
+type ListMetaAccessor interface {
+ GetListMeta() List
+}
+
+// List lets you work with list metadata from any of the versioned or
+// internal API objects. Attempting to set or retrieve a field on an object that does
+// not support that field will be a no-op and return a default value.
+// TODO: move this, and TypeMeta and ListMeta, to a different package
+type List interface {
+ GetResourceVersion() string
+ SetResourceVersion(version string)
+ GetSelfLink() string
+ SetSelfLink(selfLink string)
+}
+
+// Type exposes the type and APIVersion of versioned or internal API objects.
+// TODO: move this, and TypeMeta and ListMeta, to a different package
+type Type interface {
+ GetAPIVersion() string
+ SetAPIVersion(version string)
+ GetKind() string
+ SetKind(kind string)
+}
+
+func (meta *ListMeta) GetResourceVersion() string { return meta.ResourceVersion }
+func (meta *ListMeta) SetResourceVersion(version string) { meta.ResourceVersion = version }
+func (meta *ListMeta) GetSelfLink() string { return meta.SelfLink }
+func (meta *ListMeta) SetSelfLink(selfLink string) { meta.SelfLink = selfLink }
+
+func (obj *TypeMeta) GetObjectKind() ObjectKind { return obj }
+
+// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
+func (obj *TypeMeta) SetGroupVersionKind(gvk GroupVersionKind) {
+ obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
+}
+
+// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
+func (obj *TypeMeta) GroupVersionKind() GroupVersionKind {
+ return FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
+}
+
+func (obj *ListMeta) GetListMeta() List { return obj }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/register.go
similarity index 60%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/register.go
index 6c163b784aacc18bf2e7ca14a7f9bfae88d443fc..f8dbd83711ce6c9d37ef1a5050b1e8b68f402a42 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/register.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2014 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -16,7 +16,10 @@ limitations under the License.
package unversioned
-const LabelHostname = "kubernetes.io/hostname"
-const LabelZoneFailureDomain = "failure-domain.beta.kubernetes.io/zone"
-const LabelZoneRegion = "failure-domain.beta.kubernetes.io/region"
-const LabelInstanceType = "beta.kubernetes.io/instance-type"
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = GroupVersion{Group: "", Version: ""}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/time.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/time.go
index 1180e6bd14f4f6345965875dd1e740fc79d0b861..df94bbe72c89efe69fac87d0d574c43c55cb97fa 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/time.go
@@ -28,8 +28,9 @@ import (
// of the factory methods that the time package offers.
//
// +protobuf.options.marshal=false
+// +protobuf.as=Timestamp
type Time struct {
- time.Time `protobuf:"Timestamp,1,req,name=time"`
+ time.Time `protobuf:"-"`
}
// NewTime returns a wrapped instance of the provided time
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go
similarity index 67%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go
index 6d6fe5d4e7be94c6b42831827e87f06842667c9d..496d5d98ce2cc496f66313890385889e669fb281 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/time_proto.go
@@ -1,5 +1,3 @@
-// +build proto
-
/*
Copyright 2015 The Kubernetes Authors All rights reserved.
@@ -22,59 +20,66 @@ import (
"time"
)
-// ProtoTime is a struct that is equivalent to Time, but intended for
+// Timestamp is a struct that is equivalent to Time, but intended for
// protobuf marshalling/unmarshalling. It is generated into a serialization
// that matches Time. Do not use in Go structs.
-type ProtoTime struct {
- // Represents the time of an event.
- Timestamp Timestamp `json:"timestamp"`
-}
-
-// Timestamp is a protobuf Timestamp compatible representation of time.Time
type Timestamp struct {
// Represents seconds of UTC time since Unix epoch
// 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
// 9999-12-31T23:59:59Z inclusive.
- Seconds int64 `json:"seconds"`
+ Seconds int64 `json:"seconds" protobuf:"varint,1,opt,name=seconds"`
// Non-negative fractions of a second at nanosecond resolution. Negative
// second values with fractions must still have non-negative nanos values
// that count forward in time. Must be from 0 to 999,999,999
- // inclusive.
- Nanos int32 `json:"nanos"`
+ // inclusive. This field may be limited in precision depending on context.
+ Nanos int32 `json:"nanos" protobuf:"varint,2,opt,name=nanos"`
}
-// ProtoTime returns the Time as a new ProtoTime value.
-func (m *Time) ProtoTime() *ProtoTime {
+// Timestamp returns the Time as a new Timestamp value.
+func (m *Time) ProtoTime() *Timestamp {
if m == nil {
- return &ProtoTime{}
+ return &Timestamp{}
}
- return &ProtoTime{
- Timestamp: Timestamp{
- Seconds: m.Time.Unix(),
- Nanos: int32(m.Time.Nanosecond()),
- },
+ return &Timestamp{
+ Seconds: m.Time.Unix(),
+ Nanos: int32(m.Time.Nanosecond()),
}
}
// Size implements the protobuf marshalling interface.
-func (m *Time) Size() (n int) { return m.ProtoTime().Size() }
+func (m *Time) Size() (n int) {
+ if m == nil || m.Time.IsZero() {
+ return 0
+ }
+ return m.ProtoTime().Size()
+}
// Reset implements the protobuf marshalling interface.
func (m *Time) Unmarshal(data []byte) error {
- p := ProtoTime{}
+ if len(data) == 0 {
+ m.Time = time.Time{}
+ return nil
+ }
+ p := Timestamp{}
if err := p.Unmarshal(data); err != nil {
return err
}
- m.Time = time.Unix(p.Timestamp.Seconds, int64(p.Timestamp.Nanos))
+ m.Time = time.Unix(p.Seconds, int64(p.Nanos)).Local()
return nil
}
// Marshal implements the protobuf marshalling interface.
func (m *Time) Marshal() (data []byte, err error) {
+ if m == nil || m.Time.IsZero() {
+ return nil, nil
+ }
return m.ProtoTime().Marshal()
}
// MarshalTo implements the protobuf marshalling interface.
func (m *Time) MarshalTo(data []byte) (int, error) {
+ if m == nil || m.Time.IsZero() {
+ return 0, nil
+ }
return m.ProtoTime().MarshalTo(data)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/types.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/types.go
index 786be86cf55e927a9a85f379b98ea97b316c4687..11afcc2b783e46272d0e694189c74643cda9e344 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/types.go
@@ -35,14 +35,14 @@ type TypeMeta struct {
// Servers may infer this from the endpoint the client submits requests to.
// Cannot be updated.
// In CamelCase.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- Kind string `json:"kind,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
// 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#resources
- APIVersion string `json:"apiVersion,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#resources
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
}
// ListMeta describes metadata that synthetic resources must have, including lists and
@@ -51,51 +51,51 @@ type ListMeta struct {
// SelfLink is a URL representing this object.
// Populated by the system.
// Read-only.
- SelfLink string `json:"selfLink,omitempty"`
+ SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,1,opt,name=selfLink"`
// 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency
- ResourceVersion string `json:"resourceVersion,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,2,opt,name=resourceVersion"`
}
// ExportOptions is the query options to the standard REST get call.
type ExportOptions struct {
TypeMeta `json:",inline"`
// Should this value be exported. Export strips fields that a user can not specify.`
- Export bool `json:"export"`
+ Export bool `json:"export" protobuf:"varint,1,opt,name=export"`
// Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
- Exact bool `json:"exact"`
+ Exact bool `json:"exact" protobuf:"varint,2,opt,name=exact"`
}
// Status is a return value for calls that don't return other objects.
type Status struct {
TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Status of the operation.
// One of: "Success" or "Failure".
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status string `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status string `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"`
// A human-readable description of the status of this operation.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,3,opt,name=message"`
// 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.
- Reason StatusReason `json:"reason,omitempty"`
+ Reason StatusReason `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason,casttype=StatusReason"`
// 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.
- Details *StatusDetails `json:"details,omitempty"`
+ Details *StatusDetails `json:"details,omitempty" protobuf:"bytes,5,opt,name=details"`
// Suggested HTTP return code for this status, 0 if not set.
- Code int32 `json:"code,omitempty"`
+ Code int32 `json:"code,omitempty" protobuf:"varint,6,opt,name=code"`
}
// StatusDetails is a set of additional properties that MAY be set by the
@@ -107,18 +107,18 @@ type Status struct {
type StatusDetails struct {
// The name attribute of the resource associated with the status StatusReason
// (when there is a single name which can be described).
- Name string `json:"name,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
// The group attribute of the resource associated with the status StatusReason.
- Group string `json:"group,omitempty"`
+ Group string `json:"group,omitempty" protobuf:"bytes,2,opt,name=group"`
// The kind attribute of the resource associated with the status StatusReason.
// On some operations may differ from the requested resource Kind.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- Kind string `json:"kind,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind,omitempty" protobuf:"bytes,3,opt,name=kind"`
// The Causes array includes more details associated with the StatusReason
// failure. Not all StatusReasons may provide detailed causes.
- Causes []StatusCause `json:"causes,omitempty"`
+ Causes []StatusCause `json:"causes,omitempty" protobuf:"bytes,4,rep,name=causes"`
// If specified, the time in seconds before the operation should be retried.
- RetryAfterSeconds int32 `json:"retryAfterSeconds,omitempty"`
+ RetryAfterSeconds int32 `json:"retryAfterSeconds,omitempty" protobuf:"varint,5,opt,name=retryAfterSeconds"`
}
// Values of Status.Status
@@ -174,10 +174,10 @@ const (
// Status code 409
StatusReasonAlreadyExists StatusReason = "AlreadyExists"
- // StatusReasonConflict means the requested update operation cannot be completed
- // due to a conflict in the operation. The client may need to alter the request.
- // Each resource may define custom details that indicate the nature of the
- // conflict.
+ // StatusReasonConflict means the requested operation cannot be completed
+ // due to a conflict in the operation. The client may need to alter the
+ // request. Each resource may define custom details that indicate the
+ // nature of the conflict.
// Status code 409
StatusReasonConflict StatusReason = "Conflict"
@@ -257,10 +257,10 @@ const (
type StatusCause struct {
// A machine-readable description of the cause of the error. If this value is
// empty there is no information available.
- Type CauseType `json:"reason,omitempty"`
+ Type CauseType `json:"reason,omitempty" protobuf:"bytes,1,opt,name=reason,casttype=CauseType"`
// A human-readable description of the cause of the error. This field may be
// presented as-is to a reader.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"`
// 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
@@ -270,7 +270,7 @@ type StatusCause struct {
// Examples:
// "name" - the field "name" on the current resource
// "items[0].name" - the field "name" on the first array entry in "items"
- Field string `json:"field,omitempty"`
+ Field string `json:"field,omitempty" protobuf:"bytes,3,opt,name=field"`
}
// CauseType is a machine readable value providing more detail about what
@@ -307,7 +307,7 @@ const (
type APIVersions struct {
TypeMeta `json:",inline"`
// versions are the api versions that are available.
- Versions []string `json:"versions"`
+ Versions []string `json:"versions" protobuf:"bytes,1,rep,name=versions"`
// 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.
@@ -315,7 +315,7 @@ type APIVersions struct {
// 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.
- ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs"`
+ ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" protobuf:"bytes,2,rep,name=serverAddressByClientCIDRs"`
}
// APIGroupList is a list of APIGroup, to allow clients to discover the API at
@@ -323,7 +323,7 @@ type APIVersions struct {
type APIGroupList struct {
TypeMeta `json:",inline"`
// groups is a list of APIGroup.
- Groups []APIGroup `json:"groups"`
+ Groups []APIGroup `json:"groups" protobuf:"bytes,1,rep,name=groups"`
}
// APIGroup contains the name, the supported versions, and the preferred version
@@ -331,12 +331,12 @@ type APIGroupList struct {
type APIGroup struct {
TypeMeta `json:",inline"`
// name is the name of the group.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// versions are the versions supported in this group.
- Versions []GroupVersionForDiscovery `json:"versions"`
+ Versions []GroupVersionForDiscovery `json:"versions" protobuf:"bytes,2,rep,name=versions"`
// preferredVersion is the version preferred by the API server, which
// probably is the storage version.
- PreferredVersion GroupVersionForDiscovery `json:"preferredVersion,omitempty"`
+ PreferredVersion GroupVersionForDiscovery `json:"preferredVersion,omitempty" protobuf:"bytes,3,opt,name=preferredVersion"`
// 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.
@@ -344,36 +344,36 @@ type APIGroup struct {
// 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.
- ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs"`
+ ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" protobuf:"bytes,4,rep,name=serverAddressByClientCIDRs"`
}
// ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
type ServerAddressByClientCIDR struct {
// The CIDR with which clients can match their IP to figure out the server address that they should use.
- ClientCIDR string `json:"clientCIDR"`
+ ClientCIDR string `json:"clientCIDR" protobuf:"bytes,1,opt,name=clientCIDR"`
// Address of this server, suitable for a client that matches the above CIDR.
// This can be a hostname, hostname:port, IP or IP:port.
- ServerAddress string `json:"serverAddress"`
+ ServerAddress string `json:"serverAddress" protobuf:"bytes,2,opt,name=serverAddress"`
}
// GroupVersion contains the "group/version" and "version" string of a version.
// It is made a struct to keep extensiblity.
type GroupVersionForDiscovery struct {
// groupVersion specifies the API group and version in the form "group/version"
- GroupVersion string `json:"groupVersion"`
+ GroupVersion string `json:"groupVersion" protobuf:"bytes,1,opt,name=groupVersion"`
// version specifies the version in the form of "version". This is to save
// the clients the trouble of splitting the GroupVersion.
- Version string `json:"version"`
+ Version string `json:"version" protobuf:"bytes,2,opt,name=version"`
}
// APIResource specifies the name of a resource and whether it is namespaced.
type APIResource struct {
// name is the name of the resource.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// namespaced indicates if a resource is namespaced or not.
- Namespaced bool `json:"namespaced"`
+ Namespaced bool `json:"namespaced" protobuf:"varint,2,opt,name=namespaced"`
// kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')
- Kind string `json:"kind"`
+ Kind string `json:"kind" protobuf:"bytes,3,opt,name=kind"`
}
// APIResourceList is a list of APIResource, it is used to expose the name of the
@@ -382,16 +382,16 @@ type APIResource struct {
type APIResourceList struct {
TypeMeta `json:",inline"`
// groupVersion is the group and version this APIResourceList is for.
- GroupVersion string `json:"groupVersion"`
+ GroupVersion string `json:"groupVersion" protobuf:"bytes,1,opt,name=groupVersion"`
// resources contains the name of the resources and if they are namespaced.
- APIResources []APIResource `json:"resources"`
+ APIResources []APIResource `json:"resources" protobuf:"bytes,2,rep,name=resources"`
}
// RootPaths lists the paths available at root.
// For example: "/healthz", "/apis".
type RootPaths struct {
// paths are the paths available at root.
- Paths []string `json:"paths"`
+ Paths []string `json:"paths" protobuf:"bytes,1,rep,name=paths"`
}
// TODO: remove me when watch is refactored
@@ -429,24 +429,24 @@ type LabelSelector struct {
// 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.
- MatchLabels map[string]string `json:"matchLabels,omitempty"`
+ MatchLabels map[string]string `json:"matchLabels,omitempty" protobuf:"bytes,1,rep,name=matchLabels"`
// matchExpressions is a list of label selector requirements. The requirements are ANDed.
- MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty"`
+ MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,2,rep,name=matchExpressions"`
}
// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type LabelSelectorRequirement struct {
// key is the label key that the selector applies to.
- Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key"`
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
// operator represents a key's relationship to a set of values.
// Valid operators ard In, NotIn, Exists and DoesNotExist.
- Operator LabelSelectorOperator `json:"operator"`
+ Operator LabelSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=LabelSelectorOperator"`
// 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.
- Values []string `json:"values,omitempty"`
+ Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
}
// A label selector operator is the set of operators that can be used in a selector requirement.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go
index b45a46e625b10988b222ee437542082dd4924ea1..2cad1b535fe77ddbe7a3868b6d5475f38e138589 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -123,7 +123,7 @@ func (LabelSelectorRequirement) SwaggerDoc() map[string]string {
var map_ListMeta = map[string]string{
"": "ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.",
"selfLink": "SelfLink is a URL representing this object. Populated by the system. Read-only.",
- "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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency",
+ "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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency",
}
func (ListMeta) SwaggerDoc() map[string]string {
@@ -159,8 +159,8 @@ func (ServerAddressByClientCIDR) SwaggerDoc() map[string]string {
var map_Status = map[string]string{
"": "Status is a return value for calls that don't return other objects.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "status": "Status of the operation. One of: \"Success\" or \"Failure\". More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "status": "Status of the operation. One of: \"Success\" or \"Failure\". More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
"message": "A human-readable description of the status of this operation.",
"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.",
"details": "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.",
@@ -186,7 +186,7 @@ var map_StatusDetails = map[string]string{
"": "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.",
"name": "The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described).",
"group": "The group attribute of the resource associated with the status StatusReason.",
- "kind": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "kind": "The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"causes": "The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes.",
"retryAfterSeconds": "If specified, the time in seconds before the operation should be retried.",
}
@@ -197,8 +197,8 @@ func (StatusDetails) SwaggerDoc() map[string]string {
var map_TypeMeta = map[string]string{
"": "TypeMeta describes an individual object in an API response or request with strings representing the type of the object and its API schema version. Structures that are versioned or persisted should inline TypeMeta.",
- "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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#resources",
+ "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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#resources",
}
func (TypeMeta) SwaggerDoc() map[string]string {
diff --git a/vendor/k8s.io/kubernetes/pkg/api/unversioned/validation/validation.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/validation/validation.go
new file mode 100644
index 0000000000000000000000000000000000000000..47852e3e29f2a3bd006335cfdb3efe168f0a726c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/validation/validation.go
@@ -0,0 +1,74 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 validation
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/util/validation"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+func ValidateLabelSelector(ps *unversioned.LabelSelector, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if ps == nil {
+ return allErrs
+ }
+ allErrs = append(allErrs, ValidateLabels(ps.MatchLabels, fldPath.Child("matchLabels"))...)
+ for i, expr := range ps.MatchExpressions {
+ allErrs = append(allErrs, ValidateLabelSelectorRequirement(expr, fldPath.Child("matchExpressions").Index(i))...)
+ }
+ return allErrs
+}
+
+func ValidateLabelSelectorRequirement(sr unversioned.LabelSelectorRequirement, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ switch sr.Operator {
+ case unversioned.LabelSelectorOpIn, unversioned.LabelSelectorOpNotIn:
+ if len(sr.Values) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("values"), "must be specified when `operator` is 'In' or 'NotIn'"))
+ }
+ case unversioned.LabelSelectorOpExists, unversioned.LabelSelectorOpDoesNotExist:
+ if len(sr.Values) > 0 {
+ allErrs = append(allErrs, field.Forbidden(fldPath.Child("values"), "may not be specified when `operator` is 'Exists' or 'DoesNotExist'"))
+ }
+ default:
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), sr.Operator, "not a valid selector operator"))
+ }
+ allErrs = append(allErrs, ValidateLabelName(sr.Key, fldPath.Child("key"))...)
+ return allErrs
+}
+
+// ValidateLabelName validates that the label name is correctly defined.
+func ValidateLabelName(labelName string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ for _, msg := range validation.IsQualifiedName(labelName) {
+ allErrs = append(allErrs, field.Invalid(fldPath, labelName, msg))
+ }
+ return allErrs
+}
+
+// ValidateLabels validates that a set of labels are correctly defined.
+func ValidateLabels(labels map[string]string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ for k, v := range labels {
+ allErrs = append(allErrs, ValidateLabelName(k, fldPath)...)
+ for _, msg := range validation.IsValidLabelValue(v) {
+ allErrs = append(allErrs, field.Invalid(fldPath, v, msg))
+ }
+ }
+ return allErrs
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/parsers/parsers.go b/vendor/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go
similarity index 54%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/parsers/parsers.go
rename to vendor/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go
index f7c352ef50343d28dd20d5526d208e012339cea3..08e4f68892b713685db83f95033d9007a04c20da 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/parsers/parsers.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/unversioned/well_known_labels.go
@@ -14,23 +14,17 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package parsers
-
-import (
- "github.com/docker/docker/pkg/parsers"
-)
+package unversioned
const (
- defaultImageTag = "latest"
-)
+ // If you add a new topology domain here, also consider adding it to the set of default values
+ // for the scheduler's --failure-domain command-line argument.
+ LabelHostname = "kubernetes.io/hostname"
+ LabelZoneFailureDomain = "failure-domain.beta.kubernetes.io/zone"
+ LabelZoneRegion = "failure-domain.beta.kubernetes.io/region"
-// parseImageName parses a docker image string into two parts: repo and tag.
-// If tag is empty, return the defaultImageTag.
-func ParseImageName(image string) (string, string) {
- repoToPull, tag := parsers.ParseRepositoryTag(image)
- // If no tag was specified, use the default "latest".
- if len(tag) == 0 {
- tag = defaultImageTag
- }
- return repoToPull, tag
-}
+ LabelInstanceType = "beta.kubernetes.io/instance-type"
+
+ LabelOS = "beta.kubernetes.io/os"
+ LabelArch = "beta.kubernetes.io/arch"
+)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/util/group_version.go b/vendor/k8s.io/kubernetes/pkg/api/util/group_version.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/util/group_version.go
rename to vendor/k8s.io/kubernetes/pkg/api/util/group_version.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion.go b/vendor/k8s.io/kubernetes/pkg/api/v1/conversion.go
similarity index 63%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/conversion.go
index 56ca88f3677a8cfc471af2d5275460c35f58995e..98d8b7ed2ab5132f24a43d51cd01287eab681700 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/conversion.go
@@ -17,13 +17,12 @@ limitations under the License.
package v1
import (
+ "encoding/json"
"fmt"
- "reflect"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime"
- "speter.net/go/exp/math/dec/inf"
)
const (
@@ -200,19 +199,8 @@ func addConversionFuncs(scheme *runtime.Scheme) {
}
func Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *api.ReplicationControllerSpec, out *ReplicationControllerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ReplicationControllerSpec))(in)
- }
- out.Replicas = new(int32)
- *out.Replicas = int32(in.Replicas)
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
+ out.Replicas = &in.Replicas
+ out.Selector = in.Selector
//if in.TemplateRef != nil {
// out.TemplateRef = new(ObjectReference)
// if err := Convert_api_ObjectReference_To_v1_ObjectReference(in.TemplateRef, out.TemplateRef, s); err != nil {
@@ -233,18 +221,9 @@ func Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *a
}
func Convert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec(in *ReplicationControllerSpec, out *api.ReplicationControllerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationControllerSpec))(in)
- }
- out.Replicas = int(*in.Replicas)
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
+ out.Replicas = *in.Replicas
+ out.Selector = in.Selector
+
//if in.TemplateRef != nil {
// out.TemplateRef = new(api.ObjectReference)
// if err := Convert_v1_ObjectReference_To_api_ObjectReference(in.TemplateRef, out.TemplateRef, s); err != nil {
@@ -264,12 +243,122 @@ func Convert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec(in *R
return nil
}
+func Convert_api_PodStatusResult_To_v1_PodStatusResult(in *api.PodStatusResult, out *PodStatusResult, s conversion.Scope) error {
+ if err := autoConvert_api_PodStatusResult_To_v1_PodStatusResult(in, out, s); err != nil {
+ return err
+ }
+
+ if old := out.Annotations; old != nil {
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ }
+ if len(out.Status.InitContainerStatuses) > 0 {
+ if out.Annotations == nil {
+ out.Annotations = make(map[string]string)
+ }
+ value, err := json.Marshal(out.Status.InitContainerStatuses)
+ if err != nil {
+ return err
+ }
+ out.Annotations[PodInitContainerStatusesAnnotationKey] = string(value)
+ } else {
+ delete(out.Annotations, PodInitContainerStatusesAnnotationKey)
+ }
+ return nil
+}
+
+func Convert_v1_PodStatusResult_To_api_PodStatusResult(in *PodStatusResult, out *api.PodStatusResult, s conversion.Scope) error {
+ // TODO: when we move init container to beta, remove these conversions
+ if value, ok := in.Annotations[PodInitContainerStatusesAnnotationKey]; ok {
+ var values []ContainerStatus
+ if err := json.Unmarshal([]byte(value), &values); err != nil {
+ return err
+ }
+ // Conversion from external to internal version exists more to
+ // satisfy the needs of the decoder than it does to be a general
+ // purpose tool. And Decode always creates an intermediate object
+ // to decode to. Thus the caller of UnsafeConvertToVersion is
+ // taking responsibility to ensure mutation of in is not exposed
+ // back to the caller.
+ in.Status.InitContainerStatuses = values
+ }
+
+ if err := autoConvert_v1_PodStatusResult_To_api_PodStatusResult(in, out, s); err != nil {
+ return err
+ }
+ if len(out.Annotations) > 0 {
+ old := out.Annotations
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ delete(out.Annotations, PodInitContainerStatusesAnnotationKey)
+ }
+ return nil
+}
+
+func Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *PodTemplateSpec, s conversion.Scope) error {
+ if err := autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in, out, s); err != nil {
+ return err
+ }
+
+ // TODO: when we move init container to beta, remove these conversions
+ if old := out.Annotations; old != nil {
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ }
+ if len(out.Spec.InitContainers) > 0 {
+ if out.Annotations == nil {
+ out.Annotations = make(map[string]string)
+ }
+ value, err := json.Marshal(out.Spec.InitContainers)
+ if err != nil {
+ return err
+ }
+ out.Annotations[PodInitContainersAnnotationKey] = string(value)
+ } else {
+ delete(out.Annotations, PodInitContainersAnnotationKey)
+ }
+ return nil
+}
+
+func Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
+ // TODO: when we move init container to beta, remove these conversions
+ if value, ok := in.Annotations[PodInitContainersAnnotationKey]; ok {
+ var values []Container
+ if err := json.Unmarshal([]byte(value), &values); err != nil {
+ return err
+ }
+ // Conversion from external to internal version exists more to
+ // satisfy the needs of the decoder than it does to be a general
+ // purpose tool. And Decode always creates an intermediate object
+ // to decode to. Thus the caller of UnsafeConvertToVersion is
+ // taking responsibility to ensure mutation of in is not exposed
+ // back to the caller.
+ in.Spec.InitContainers = values
+ }
+
+ if err := autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in, out, s); err != nil {
+ return err
+ }
+ if len(out.Annotations) > 0 {
+ old := out.Annotations
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ delete(out.Annotations, PodInitContainersAnnotationKey)
+ }
+ return nil
+}
+
// The following two PodSpec conversions are done here to support ServiceAccount
// as an alias for ServiceAccountName.
func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodSpec))(in)
- }
if in.Volumes != nil {
out.Volumes = make([]Volume, len(in.Volumes))
for i := range in.Volumes {
@@ -280,6 +369,16 @@ func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversi
} else {
out.Volumes = nil
}
+ if in.InitContainers != nil {
+ out.InitContainers = make([]Container, len(in.InitContainers))
+ for i := range in.InitContainers {
+ if err := Convert_api_Container_To_v1_Container(&in.InitContainers[i], &out.InitContainers[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainers = nil
+ }
if in.Containers != nil {
out.Containers = make([]Container, len(in.Containers))
for i := range in.Containers {
@@ -290,28 +389,13 @@ func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversi
} else {
out.Containers = nil
}
+
out.RestartPolicy = RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
+ out.TerminationGracePeriodSeconds = in.TerminationGracePeriodSeconds
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
out.DNSPolicy = DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
+ out.NodeSelector = in.NodeSelector
+
out.ServiceAccountName = in.ServiceAccountName
// DeprecatedServiceAccount is an alias for ServiceAccountName.
out.DeprecatedServiceAccount = in.ServiceAccountName
@@ -338,13 +422,13 @@ func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversi
} else {
out.ImagePullSecrets = nil
}
+ out.Hostname = in.Hostname
+ out.Subdomain = in.Subdomain
return nil
}
func Convert_v1_PodSpec_To_api_PodSpec(in *PodSpec, out *api.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSpec))(in)
- }
+ SetDefaults_PodSpec(in)
if in.Volumes != nil {
out.Volumes = make([]api.Volume, len(in.Volumes))
for i := range in.Volumes {
@@ -355,6 +439,16 @@ func Convert_v1_PodSpec_To_api_PodSpec(in *PodSpec, out *api.PodSpec, s conversi
} else {
out.Volumes = nil
}
+ if in.InitContainers != nil {
+ out.InitContainers = make([]api.Container, len(in.InitContainers))
+ for i := range in.InitContainers {
+ if err := Convert_v1_Container_To_api_Container(&in.InitContainers[i], &out.InitContainers[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainers = nil
+ }
if in.Containers != nil {
out.Containers = make([]api.Container, len(in.Containers))
for i := range in.Containers {
@@ -366,27 +460,10 @@ func Convert_v1_PodSpec_To_api_PodSpec(in *PodSpec, out *api.PodSpec, s conversi
out.Containers = nil
}
out.RestartPolicy = api.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
+ out.TerminationGracePeriodSeconds = in.TerminationGracePeriodSeconds
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
out.DNSPolicy = api.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
- }
- } else {
- out.NodeSelector = nil
- }
+ out.NodeSelector = in.NodeSelector
// We support DeprecatedServiceAccount as an alias for ServiceAccountName.
// If both are specified, ServiceAccountName (the new field) wins.
out.ServiceAccountName = in.ServiceAccountName
@@ -419,7 +496,8 @@ func Convert_v1_PodSpec_To_api_PodSpec(in *PodSpec, out *api.PodSpec, s conversi
} else {
out.ImagePullSecrets = nil
}
-
+ out.Hostname = in.Hostname
+ out.Subdomain = in.Subdomain
return nil
}
@@ -427,6 +505,32 @@ func Convert_api_Pod_To_v1_Pod(in *api.Pod, out *Pod, s conversion.Scope) error
if err := autoConvert_api_Pod_To_v1_Pod(in, out, s); err != nil {
return err
}
+
+ // TODO: when we move init container to beta, remove these conversions
+ if len(out.Spec.InitContainers) > 0 || len(out.Status.InitContainerStatuses) > 0 {
+ old := out.Annotations
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ delete(out.Annotations, PodInitContainersAnnotationKey)
+ delete(out.Annotations, PodInitContainerStatusesAnnotationKey)
+ }
+ if len(out.Spec.InitContainers) > 0 {
+ value, err := json.Marshal(out.Spec.InitContainers)
+ if err != nil {
+ return err
+ }
+ out.Annotations[PodInitContainersAnnotationKey] = string(value)
+ }
+ if len(out.Status.InitContainerStatuses) > 0 {
+ value, err := json.Marshal(out.Status.InitContainerStatuses)
+ if err != nil {
+ return err
+ }
+ out.Annotations[PodInitContainerStatusesAnnotationKey] = string(value)
+ }
+
// We need to reset certain fields for mirror pods from pre-v1.1 kubelet
// (#15960).
// TODO: Remove this code after we drop support for v1.0 kubelets.
@@ -442,7 +546,47 @@ func Convert_api_Pod_To_v1_Pod(in *api.Pod, out *Pod, s conversion.Scope) error
}
func Convert_v1_Pod_To_api_Pod(in *Pod, out *api.Pod, s conversion.Scope) error {
- return autoConvert_v1_Pod_To_api_Pod(in, out, s)
+ // TODO: when we move init container to beta, remove these conversions
+ if value, ok := in.Annotations[PodInitContainersAnnotationKey]; ok {
+ var values []Container
+ if err := json.Unmarshal([]byte(value), &values); err != nil {
+ return err
+ }
+ // Conversion from external to internal version exists more to
+ // satisfy the needs of the decoder than it does to be a general
+ // purpose tool. And Decode always creates an intermediate object
+ // to decode to. Thus the caller of UnsafeConvertToVersion is
+ // taking responsibility to ensure mutation of in is not exposed
+ // back to the caller.
+ in.Spec.InitContainers = values
+ }
+ if value, ok := in.Annotations[PodInitContainerStatusesAnnotationKey]; ok {
+ var values []ContainerStatus
+ if err := json.Unmarshal([]byte(value), &values); err != nil {
+ return err
+ }
+ // Conversion from external to internal version exists more to
+ // satisfy the needs of the decoder than it does to be a general
+ // purpose tool. And Decode always creates an intermediate object
+ // to decode to. Thus the caller of UnsafeConvertToVersion is
+ // taking responsibility to ensure mutation of in is not exposed
+ // back to the caller.
+ in.Status.InitContainerStatuses = values
+ }
+
+ if err := autoConvert_v1_Pod_To_api_Pod(in, out, s); err != nil {
+ return err
+ }
+ if len(out.Annotations) > 0 {
+ old := out.Annotations
+ out.Annotations = make(map[string]string, len(old))
+ for k, v := range old {
+ out.Annotations[k] = v
+ }
+ delete(out.Annotations, PodInitContainersAnnotationKey)
+ delete(out.Annotations, PodInitContainerStatusesAnnotationKey)
+ }
+ return nil
}
func Convert_api_ServiceSpec_To_v1_ServiceSpec(in *api.ServiceSpec, out *ServiceSpec, s conversion.Scope) error {
@@ -450,9 +594,7 @@ func Convert_api_ServiceSpec_To_v1_ServiceSpec(in *api.ServiceSpec, out *Service
return err
}
// Publish both externalIPs and deprecatedPublicIPs fields in v1.
- for _, ip := range in.ExternalIPs {
- out.DeprecatedPublicIPs = append(out.DeprecatedPublicIPs, ip)
- }
+ out.DeprecatedPublicIPs = in.ExternalIPs
return nil
}
@@ -462,19 +604,12 @@ func Convert_v1_ServiceSpec_To_api_ServiceSpec(in *ServiceSpec, out *api.Service
}
// Prefer the legacy deprecatedPublicIPs field, if provided.
if len(in.DeprecatedPublicIPs) > 0 {
- out.ExternalIPs = nil
- for _, ip := range in.DeprecatedPublicIPs {
- out.ExternalIPs = append(out.ExternalIPs, ip)
- }
+ out.ExternalIPs = in.DeprecatedPublicIPs
}
return nil
}
func Convert_api_PodSecurityContext_To_v1_PodSecurityContext(in *api.PodSecurityContext, out *PodSecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodSecurityContext))(in)
- }
-
out.SupplementalGroups = in.SupplementalGroups
if in.SELinuxOptions != nil {
out.SELinuxOptions = new(SELinuxOptions)
@@ -484,32 +619,13 @@ func Convert_api_PodSecurityContext_To_v1_PodSecurityContext(in *api.PodSecurity
} else {
out.SELinuxOptions = nil
}
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.FSGroup != nil {
- out.FSGroup = new(int64)
- *out.FSGroup = *in.FSGroup
- } else {
- out.FSGroup = nil
- }
+ out.RunAsUser = in.RunAsUser
+ out.RunAsNonRoot = in.RunAsNonRoot
+ out.FSGroup = in.FSGroup
return nil
}
func Convert_v1_PodSecurityContext_To_api_PodSecurityContext(in *PodSecurityContext, out *api.PodSecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSecurityContext))(in)
- }
-
out.SupplementalGroups = in.SupplementalGroups
if in.SELinuxOptions != nil {
out.SELinuxOptions = new(api.SELinuxOptions)
@@ -519,47 +635,27 @@ func Convert_v1_PodSecurityContext_To_api_PodSecurityContext(in *PodSecurityCont
} else {
out.SELinuxOptions = nil
}
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.FSGroup != nil {
- out.FSGroup = new(int64)
- *out.FSGroup = *in.FSGroup
- } else {
- out.FSGroup = nil
- }
+ out.RunAsUser = in.RunAsUser
+ out.RunAsNonRoot = in.RunAsNonRoot
+ out.FSGroup = in.FSGroup
return nil
}
func Convert_v1_ResourceList_To_api_ResourceList(in *ResourceList, out *api.ResourceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceList))(in)
- }
if *in == nil {
return nil
}
- converted := make(api.ResourceList)
+ if *out == nil {
+ *out = make(api.ResourceList, len(*in))
+ }
for key, val := range *in {
- value := val.Copy()
-
// TODO(#18538): We round up resource values to milli scale to maintain API compatibility.
// In the future, we should instead reject values that need rounding.
- const milliScale = 3
- value.Amount.Round(value.Amount, milliScale, inf.RoundUp)
+ const milliScale = -3
+ val.RoundUp(milliScale)
- converted[api.ResourceName(key)] = *value
+ (*out)[api.ResourceName(key)] = val
}
-
- *out = converted
return nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go
similarity index 58%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go
index 687da425ad7d377652054da46421992df7d7b2e0..d3aad15522e40034bd8100bb3aa6d1af563dac0d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/conversion_generated.go
@@ -1,5 +1,7 @@
+// +build !ignore_autogenerated
+
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,27 +16,339 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
+// This file was autogenerated by conversion-gen. Do not edit it manually!
package v1
import (
- reflect "reflect"
-
api "k8s.io/kubernetes/pkg/api"
resource "k8s.io/kubernetes/pkg/api/resource"
- unversioned "k8s.io/kubernetes/pkg/api/unversioned"
conversion "k8s.io/kubernetes/pkg/conversion"
runtime "k8s.io/kubernetes/pkg/runtime"
)
-func autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AWSElasticBlockStoreVolumeSource))(in)
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource,
+ Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource,
+ Convert_v1_Affinity_To_api_Affinity,
+ Convert_api_Affinity_To_v1_Affinity,
+ Convert_v1_AttachedVolume_To_api_AttachedVolume,
+ Convert_api_AttachedVolume_To_v1_AttachedVolume,
+ Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource,
+ Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource,
+ Convert_v1_Binding_To_api_Binding,
+ Convert_api_Binding_To_v1_Binding,
+ Convert_v1_Capabilities_To_api_Capabilities,
+ Convert_api_Capabilities_To_v1_Capabilities,
+ Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource,
+ Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource,
+ Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource,
+ Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource,
+ Convert_v1_ComponentCondition_To_api_ComponentCondition,
+ Convert_api_ComponentCondition_To_v1_ComponentCondition,
+ Convert_v1_ComponentStatus_To_api_ComponentStatus,
+ Convert_api_ComponentStatus_To_v1_ComponentStatus,
+ Convert_v1_ComponentStatusList_To_api_ComponentStatusList,
+ Convert_api_ComponentStatusList_To_v1_ComponentStatusList,
+ Convert_v1_ConfigMap_To_api_ConfigMap,
+ Convert_api_ConfigMap_To_v1_ConfigMap,
+ Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector,
+ Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector,
+ Convert_v1_ConfigMapList_To_api_ConfigMapList,
+ Convert_api_ConfigMapList_To_v1_ConfigMapList,
+ Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource,
+ Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource,
+ Convert_v1_Container_To_api_Container,
+ Convert_api_Container_To_v1_Container,
+ Convert_v1_ContainerImage_To_api_ContainerImage,
+ Convert_api_ContainerImage_To_v1_ContainerImage,
+ Convert_v1_ContainerPort_To_api_ContainerPort,
+ Convert_api_ContainerPort_To_v1_ContainerPort,
+ Convert_v1_ContainerState_To_api_ContainerState,
+ Convert_api_ContainerState_To_v1_ContainerState,
+ Convert_v1_ContainerStateRunning_To_api_ContainerStateRunning,
+ Convert_api_ContainerStateRunning_To_v1_ContainerStateRunning,
+ Convert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated,
+ Convert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated,
+ Convert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting,
+ Convert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting,
+ Convert_v1_ContainerStatus_To_api_ContainerStatus,
+ Convert_api_ContainerStatus_To_v1_ContainerStatus,
+ Convert_v1_DaemonEndpoint_To_api_DaemonEndpoint,
+ Convert_api_DaemonEndpoint_To_v1_DaemonEndpoint,
+ Convert_v1_DeleteOptions_To_api_DeleteOptions,
+ Convert_api_DeleteOptions_To_v1_DeleteOptions,
+ Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile,
+ Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile,
+ Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource,
+ Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource,
+ Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource,
+ Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource,
+ Convert_v1_EndpointAddress_To_api_EndpointAddress,
+ Convert_api_EndpointAddress_To_v1_EndpointAddress,
+ Convert_v1_EndpointPort_To_api_EndpointPort,
+ Convert_api_EndpointPort_To_v1_EndpointPort,
+ Convert_v1_EndpointSubset_To_api_EndpointSubset,
+ Convert_api_EndpointSubset_To_v1_EndpointSubset,
+ Convert_v1_Endpoints_To_api_Endpoints,
+ Convert_api_Endpoints_To_v1_Endpoints,
+ Convert_v1_EndpointsList_To_api_EndpointsList,
+ Convert_api_EndpointsList_To_v1_EndpointsList,
+ Convert_v1_EnvVar_To_api_EnvVar,
+ Convert_api_EnvVar_To_v1_EnvVar,
+ Convert_v1_EnvVarSource_To_api_EnvVarSource,
+ Convert_api_EnvVarSource_To_v1_EnvVarSource,
+ Convert_v1_Event_To_api_Event,
+ Convert_api_Event_To_v1_Event,
+ Convert_v1_EventList_To_api_EventList,
+ Convert_api_EventList_To_v1_EventList,
+ Convert_v1_EventSource_To_api_EventSource,
+ Convert_api_EventSource_To_v1_EventSource,
+ Convert_v1_ExecAction_To_api_ExecAction,
+ Convert_api_ExecAction_To_v1_ExecAction,
+ Convert_v1_ExportOptions_To_api_ExportOptions,
+ Convert_api_ExportOptions_To_v1_ExportOptions,
+ Convert_v1_FCVolumeSource_To_api_FCVolumeSource,
+ Convert_api_FCVolumeSource_To_v1_FCVolumeSource,
+ Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource,
+ Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource,
+ Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource,
+ Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource,
+ Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource,
+ Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource,
+ Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource,
+ Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource,
+ Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource,
+ Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource,
+ Convert_v1_HTTPGetAction_To_api_HTTPGetAction,
+ Convert_api_HTTPGetAction_To_v1_HTTPGetAction,
+ Convert_v1_HTTPHeader_To_api_HTTPHeader,
+ Convert_api_HTTPHeader_To_v1_HTTPHeader,
+ Convert_v1_Handler_To_api_Handler,
+ Convert_api_Handler_To_v1_Handler,
+ Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource,
+ Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource,
+ Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource,
+ Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource,
+ Convert_v1_KeyToPath_To_api_KeyToPath,
+ Convert_api_KeyToPath_To_v1_KeyToPath,
+ Convert_v1_Lifecycle_To_api_Lifecycle,
+ Convert_api_Lifecycle_To_v1_Lifecycle,
+ Convert_v1_LimitRange_To_api_LimitRange,
+ Convert_api_LimitRange_To_v1_LimitRange,
+ Convert_v1_LimitRangeItem_To_api_LimitRangeItem,
+ Convert_api_LimitRangeItem_To_v1_LimitRangeItem,
+ Convert_v1_LimitRangeList_To_api_LimitRangeList,
+ Convert_api_LimitRangeList_To_v1_LimitRangeList,
+ Convert_v1_LimitRangeSpec_To_api_LimitRangeSpec,
+ Convert_api_LimitRangeSpec_To_v1_LimitRangeSpec,
+ Convert_v1_List_To_api_List,
+ Convert_api_List_To_v1_List,
+ Convert_v1_ListOptions_To_api_ListOptions,
+ Convert_api_ListOptions_To_v1_ListOptions,
+ Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress,
+ Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress,
+ Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus,
+ Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus,
+ Convert_v1_LocalObjectReference_To_api_LocalObjectReference,
+ Convert_api_LocalObjectReference_To_v1_LocalObjectReference,
+ Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource,
+ Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource,
+ Convert_v1_Namespace_To_api_Namespace,
+ Convert_api_Namespace_To_v1_Namespace,
+ Convert_v1_NamespaceList_To_api_NamespaceList,
+ Convert_api_NamespaceList_To_v1_NamespaceList,
+ Convert_v1_NamespaceSpec_To_api_NamespaceSpec,
+ Convert_api_NamespaceSpec_To_v1_NamespaceSpec,
+ Convert_v1_NamespaceStatus_To_api_NamespaceStatus,
+ Convert_api_NamespaceStatus_To_v1_NamespaceStatus,
+ Convert_v1_Node_To_api_Node,
+ Convert_api_Node_To_v1_Node,
+ Convert_v1_NodeAddress_To_api_NodeAddress,
+ Convert_api_NodeAddress_To_v1_NodeAddress,
+ Convert_v1_NodeAffinity_To_api_NodeAffinity,
+ Convert_api_NodeAffinity_To_v1_NodeAffinity,
+ Convert_v1_NodeCondition_To_api_NodeCondition,
+ Convert_api_NodeCondition_To_v1_NodeCondition,
+ Convert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints,
+ Convert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints,
+ Convert_v1_NodeList_To_api_NodeList,
+ Convert_api_NodeList_To_v1_NodeList,
+ Convert_v1_NodeProxyOptions_To_api_NodeProxyOptions,
+ Convert_api_NodeProxyOptions_To_v1_NodeProxyOptions,
+ Convert_v1_NodeSelector_To_api_NodeSelector,
+ Convert_api_NodeSelector_To_v1_NodeSelector,
+ Convert_v1_NodeSelectorRequirement_To_api_NodeSelectorRequirement,
+ Convert_api_NodeSelectorRequirement_To_v1_NodeSelectorRequirement,
+ Convert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm,
+ Convert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm,
+ Convert_v1_NodeSpec_To_api_NodeSpec,
+ Convert_api_NodeSpec_To_v1_NodeSpec,
+ Convert_v1_NodeStatus_To_api_NodeStatus,
+ Convert_api_NodeStatus_To_v1_NodeStatus,
+ Convert_v1_NodeSystemInfo_To_api_NodeSystemInfo,
+ Convert_api_NodeSystemInfo_To_v1_NodeSystemInfo,
+ Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector,
+ Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector,
+ Convert_v1_ObjectMeta_To_api_ObjectMeta,
+ Convert_api_ObjectMeta_To_v1_ObjectMeta,
+ Convert_v1_ObjectReference_To_api_ObjectReference,
+ Convert_api_ObjectReference_To_v1_ObjectReference,
+ Convert_v1_OwnerReference_To_api_OwnerReference,
+ Convert_api_OwnerReference_To_v1_OwnerReference,
+ Convert_v1_PersistentVolume_To_api_PersistentVolume,
+ Convert_api_PersistentVolume_To_v1_PersistentVolume,
+ Convert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim,
+ Convert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim,
+ Convert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList,
+ Convert_api_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList,
+ Convert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec,
+ Convert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec,
+ Convert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus,
+ Convert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus,
+ Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource,
+ Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource,
+ Convert_v1_PersistentVolumeList_To_api_PersistentVolumeList,
+ Convert_api_PersistentVolumeList_To_v1_PersistentVolumeList,
+ Convert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource,
+ Convert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource,
+ Convert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec,
+ Convert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec,
+ Convert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus,
+ Convert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus,
+ Convert_v1_Pod_To_api_Pod,
+ Convert_api_Pod_To_v1_Pod,
+ Convert_v1_PodAffinity_To_api_PodAffinity,
+ Convert_api_PodAffinity_To_v1_PodAffinity,
+ Convert_v1_PodAffinityTerm_To_api_PodAffinityTerm,
+ Convert_api_PodAffinityTerm_To_v1_PodAffinityTerm,
+ Convert_v1_PodAntiAffinity_To_api_PodAntiAffinity,
+ Convert_api_PodAntiAffinity_To_v1_PodAntiAffinity,
+ Convert_v1_PodAttachOptions_To_api_PodAttachOptions,
+ Convert_api_PodAttachOptions_To_v1_PodAttachOptions,
+ Convert_v1_PodCondition_To_api_PodCondition,
+ Convert_api_PodCondition_To_v1_PodCondition,
+ Convert_v1_PodExecOptions_To_api_PodExecOptions,
+ Convert_api_PodExecOptions_To_v1_PodExecOptions,
+ Convert_v1_PodList_To_api_PodList,
+ Convert_api_PodList_To_v1_PodList,
+ Convert_v1_PodLogOptions_To_api_PodLogOptions,
+ Convert_api_PodLogOptions_To_v1_PodLogOptions,
+ Convert_v1_PodProxyOptions_To_api_PodProxyOptions,
+ Convert_api_PodProxyOptions_To_v1_PodProxyOptions,
+ Convert_v1_PodSecurityContext_To_api_PodSecurityContext,
+ Convert_api_PodSecurityContext_To_v1_PodSecurityContext,
+ Convert_v1_PodSpec_To_api_PodSpec,
+ Convert_api_PodSpec_To_v1_PodSpec,
+ Convert_v1_PodStatus_To_api_PodStatus,
+ Convert_api_PodStatus_To_v1_PodStatus,
+ Convert_v1_PodStatusResult_To_api_PodStatusResult,
+ Convert_api_PodStatusResult_To_v1_PodStatusResult,
+ Convert_v1_PodTemplate_To_api_PodTemplate,
+ Convert_api_PodTemplate_To_v1_PodTemplate,
+ Convert_v1_PodTemplateList_To_api_PodTemplateList,
+ Convert_api_PodTemplateList_To_v1_PodTemplateList,
+ Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec,
+ Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec,
+ Convert_v1_Preconditions_To_api_Preconditions,
+ Convert_api_Preconditions_To_v1_Preconditions,
+ Convert_v1_PreferredSchedulingTerm_To_api_PreferredSchedulingTerm,
+ Convert_api_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm,
+ Convert_v1_Probe_To_api_Probe,
+ Convert_api_Probe_To_v1_Probe,
+ Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource,
+ Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource,
+ Convert_v1_RangeAllocation_To_api_RangeAllocation,
+ Convert_api_RangeAllocation_To_v1_RangeAllocation,
+ Convert_v1_ReplicationController_To_api_ReplicationController,
+ Convert_api_ReplicationController_To_v1_ReplicationController,
+ Convert_v1_ReplicationControllerList_To_api_ReplicationControllerList,
+ Convert_api_ReplicationControllerList_To_v1_ReplicationControllerList,
+ Convert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec,
+ Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec,
+ Convert_v1_ReplicationControllerStatus_To_api_ReplicationControllerStatus,
+ Convert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus,
+ Convert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector,
+ Convert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector,
+ Convert_v1_ResourceQuota_To_api_ResourceQuota,
+ Convert_api_ResourceQuota_To_v1_ResourceQuota,
+ Convert_v1_ResourceQuotaList_To_api_ResourceQuotaList,
+ Convert_api_ResourceQuotaList_To_v1_ResourceQuotaList,
+ Convert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec,
+ Convert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec,
+ Convert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus,
+ Convert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus,
+ Convert_v1_ResourceRequirements_To_api_ResourceRequirements,
+ Convert_api_ResourceRequirements_To_v1_ResourceRequirements,
+ Convert_v1_SELinuxOptions_To_api_SELinuxOptions,
+ Convert_api_SELinuxOptions_To_v1_SELinuxOptions,
+ Convert_v1_Secret_To_api_Secret,
+ Convert_api_Secret_To_v1_Secret,
+ Convert_v1_SecretKeySelector_To_api_SecretKeySelector,
+ Convert_api_SecretKeySelector_To_v1_SecretKeySelector,
+ Convert_v1_SecretList_To_api_SecretList,
+ Convert_api_SecretList_To_v1_SecretList,
+ Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource,
+ Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource,
+ Convert_v1_SecurityContext_To_api_SecurityContext,
+ Convert_api_SecurityContext_To_v1_SecurityContext,
+ Convert_v1_SerializedReference_To_api_SerializedReference,
+ Convert_api_SerializedReference_To_v1_SerializedReference,
+ Convert_v1_Service_To_api_Service,
+ Convert_api_Service_To_v1_Service,
+ Convert_v1_ServiceAccount_To_api_ServiceAccount,
+ Convert_api_ServiceAccount_To_v1_ServiceAccount,
+ Convert_v1_ServiceAccountList_To_api_ServiceAccountList,
+ Convert_api_ServiceAccountList_To_v1_ServiceAccountList,
+ Convert_v1_ServiceList_To_api_ServiceList,
+ Convert_api_ServiceList_To_v1_ServiceList,
+ Convert_v1_ServicePort_To_api_ServicePort,
+ Convert_api_ServicePort_To_v1_ServicePort,
+ Convert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions,
+ Convert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions,
+ Convert_v1_ServiceSpec_To_api_ServiceSpec,
+ Convert_api_ServiceSpec_To_v1_ServiceSpec,
+ Convert_v1_ServiceStatus_To_api_ServiceStatus,
+ Convert_api_ServiceStatus_To_v1_ServiceStatus,
+ Convert_v1_TCPSocketAction_To_api_TCPSocketAction,
+ Convert_api_TCPSocketAction_To_v1_TCPSocketAction,
+ Convert_v1_Taint_To_api_Taint,
+ Convert_api_Taint_To_v1_Taint,
+ Convert_v1_Toleration_To_api_Toleration,
+ Convert_api_Toleration_To_v1_Toleration,
+ Convert_v1_Volume_To_api_Volume,
+ Convert_api_Volume_To_v1_Volume,
+ Convert_v1_VolumeMount_To_api_VolumeMount,
+ Convert_api_VolumeMount_To_v1_VolumeMount,
+ Convert_v1_VolumeSource_To_api_VolumeSource,
+ Convert_api_VolumeSource_To_v1_VolumeSource,
+ Convert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource,
+ Convert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource,
+ Convert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm,
+ Convert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
}
+}
+
+func autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
+ out.VolumeID = in.VolumeID
+ out.FSType = in.FSType
+ out.Partition = in.Partition
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in, out, s)
+}
+
+func autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *api.AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
out.VolumeID = in.VolumeID
out.FSType = in.FSType
- out.Partition = int32(in.Partition)
+ out.Partition = in.Partition
out.ReadOnly = in.ReadOnly
return nil
}
@@ -43,10 +357,108 @@ func Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolu
return autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in, out, s)
}
-func autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.AzureFileVolumeSource))(in)
+func autoConvert_v1_Affinity_To_api_Affinity(in *Affinity, out *api.Affinity, s conversion.Scope) error {
+ if in.NodeAffinity != nil {
+ in, out := &in.NodeAffinity, &out.NodeAffinity
+ *out = new(api.NodeAffinity)
+ if err := Convert_v1_NodeAffinity_To_api_NodeAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NodeAffinity = nil
+ }
+ if in.PodAffinity != nil {
+ in, out := &in.PodAffinity, &out.PodAffinity
+ *out = new(api.PodAffinity)
+ if err := Convert_v1_PodAffinity_To_api_PodAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodAffinity = nil
+ }
+ if in.PodAntiAffinity != nil {
+ in, out := &in.PodAntiAffinity, &out.PodAntiAffinity
+ *out = new(api.PodAntiAffinity)
+ if err := Convert_v1_PodAntiAffinity_To_api_PodAntiAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodAntiAffinity = nil
+ }
+ return nil
+}
+
+func Convert_v1_Affinity_To_api_Affinity(in *Affinity, out *api.Affinity, s conversion.Scope) error {
+ return autoConvert_v1_Affinity_To_api_Affinity(in, out, s)
+}
+
+func autoConvert_api_Affinity_To_v1_Affinity(in *api.Affinity, out *Affinity, s conversion.Scope) error {
+ if in.NodeAffinity != nil {
+ in, out := &in.NodeAffinity, &out.NodeAffinity
+ *out = new(NodeAffinity)
+ if err := Convert_api_NodeAffinity_To_v1_NodeAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NodeAffinity = nil
+ }
+ if in.PodAffinity != nil {
+ in, out := &in.PodAffinity, &out.PodAffinity
+ *out = new(PodAffinity)
+ if err := Convert_api_PodAffinity_To_v1_PodAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodAffinity = nil
+ }
+ if in.PodAntiAffinity != nil {
+ in, out := &in.PodAntiAffinity, &out.PodAntiAffinity
+ *out = new(PodAntiAffinity)
+ if err := Convert_api_PodAntiAffinity_To_v1_PodAntiAffinity(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodAntiAffinity = nil
}
+ return nil
+}
+
+func Convert_api_Affinity_To_v1_Affinity(in *api.Affinity, out *Affinity, s conversion.Scope) error {
+ return autoConvert_api_Affinity_To_v1_Affinity(in, out, s)
+}
+
+func autoConvert_v1_AttachedVolume_To_api_AttachedVolume(in *AttachedVolume, out *api.AttachedVolume, s conversion.Scope) error {
+ out.Name = api.UniqueVolumeName(in.Name)
+ out.DevicePath = in.DevicePath
+ return nil
+}
+
+func Convert_v1_AttachedVolume_To_api_AttachedVolume(in *AttachedVolume, out *api.AttachedVolume, s conversion.Scope) error {
+ return autoConvert_v1_AttachedVolume_To_api_AttachedVolume(in, out, s)
+}
+
+func autoConvert_api_AttachedVolume_To_v1_AttachedVolume(in *api.AttachedVolume, out *AttachedVolume, s conversion.Scope) error {
+ out.Name = UniqueVolumeName(in.Name)
+ out.DevicePath = in.DevicePath
+ return nil
+}
+
+func Convert_api_AttachedVolume_To_v1_AttachedVolume(in *api.AttachedVolume, out *AttachedVolume, s conversion.Scope) error {
+ return autoConvert_api_AttachedVolume_To_v1_AttachedVolume(in, out, s)
+}
+
+func autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
+ out.SecretName = in.SecretName
+ out.ShareName = in.ShareName
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in, out, s)
+}
+
+func autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.AzureFileVolumeSource, out *AzureFileVolumeSource, s conversion.Scope) error {
out.SecretName = in.SecretName
out.ShareName = in.ShareName
out.ReadOnly = in.ReadOnly
@@ -57,9 +469,26 @@ func Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *api.Azure
return autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in, out, s)
}
+func autoConvert_v1_Binding_To_api_Binding(in *Binding, out *api.Binding, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.Target, &out.Target, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_Binding_To_api_Binding(in *Binding, out *api.Binding, s conversion.Scope) error {
+ return autoConvert_v1_Binding_To_api_Binding(in, out, s)
+}
+
func autoConvert_api_Binding_To_v1_Binding(in *api.Binding, out *Binding, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Binding))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -74,22 +503,47 @@ func Convert_api_Binding_To_v1_Binding(in *api.Binding, out *Binding, s conversi
return autoConvert_api_Binding_To_v1_Binding(in, out, s)
}
-func autoConvert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Capabilities))(in)
+func autoConvert_v1_Capabilities_To_api_Capabilities(in *Capabilities, out *api.Capabilities, s conversion.Scope) error {
+ if in.Add != nil {
+ in, out := &in.Add, &out.Add
+ *out = make([]api.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = api.Capability((*in)[i])
+ }
+ } else {
+ out.Add = nil
+ }
+ if in.Drop != nil {
+ in, out := &in.Drop, &out.Drop
+ *out = make([]api.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = api.Capability((*in)[i])
+ }
+ } else {
+ out.Drop = nil
}
+ return nil
+}
+
+func Convert_v1_Capabilities_To_api_Capabilities(in *Capabilities, out *api.Capabilities, s conversion.Scope) error {
+ return autoConvert_v1_Capabilities_To_api_Capabilities(in, out, s)
+}
+
+func autoConvert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *Capabilities, s conversion.Scope) error {
if in.Add != nil {
- out.Add = make([]Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = Capability(in.Add[i])
+ in, out := &in.Add, &out.Add
+ *out = make([]Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = Capability((*in)[i])
}
} else {
out.Add = nil
}
if in.Drop != nil {
- out.Drop = make([]Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = Capability(in.Drop[i])
+ in, out := &in.Drop, &out.Drop
+ *out = make([]Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = Capability((*in)[i])
}
} else {
out.Drop = nil
@@ -101,25 +555,37 @@ func Convert_api_Capabilities_To_v1_Capabilities(in *api.Capabilities, out *Capa
return autoConvert_api_Capabilities_To_v1_Capabilities(in, out, s)
}
-func autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
+func autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
+ out.Monitors = in.Monitors
+ out.Path = in.Path
+ out.User = in.User
+ out.SecretFile = in.SecretFile
+ if in.SecretRef != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(api.LocalObjectReference)
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Monitors = nil
+ out.SecretRef = nil
}
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in, out, s)
+}
+
+func autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolumeSource, out *CephFSVolumeSource, s conversion.Scope) error {
+ out.Monitors = in.Monitors
out.Path = in.Path
out.User = in.User
out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(*in, *out, s); err != nil {
return err
}
} else {
@@ -133,10 +599,18 @@ func Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *api.CephFSVolum
return autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in, out, s)
}
+func autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
+ out.VolumeID = in.VolumeID
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in, out, s)
+}
+
func autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolumeSource, out *CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.CinderVolumeSource))(in)
- }
out.VolumeID = in.VolumeID
out.FSType = in.FSType
out.ReadOnly = in.ReadOnly
@@ -147,10 +621,19 @@ func Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in *api.CinderVolum
return autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in, out, s)
}
+func autoConvert_v1_ComponentCondition_To_api_ComponentCondition(in *ComponentCondition, out *api.ComponentCondition, s conversion.Scope) error {
+ out.Type = api.ComponentConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ out.Message = in.Message
+ out.Error = in.Error
+ return nil
+}
+
+func Convert_v1_ComponentCondition_To_api_ComponentCondition(in *ComponentCondition, out *api.ComponentCondition, s conversion.Scope) error {
+ return autoConvert_v1_ComponentCondition_To_api_ComponentCondition(in, out, s)
+}
+
func autoConvert_api_ComponentCondition_To_v1_ComponentCondition(in *api.ComponentCondition, out *ComponentCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ComponentCondition))(in)
- }
out.Type = ComponentConditionType(in.Type)
out.Status = ConditionStatus(in.Status)
out.Message = in.Message
@@ -162,17 +645,43 @@ func Convert_api_ComponentCondition_To_v1_ComponentCondition(in *api.ComponentCo
return autoConvert_api_ComponentCondition_To_v1_ComponentCondition(in, out, s)
}
+func autoConvert_v1_ComponentStatus_To_api_ComponentStatus(in *ComponentStatus, out *api.ComponentStatus, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]api.ComponentCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ComponentCondition_To_api_ComponentCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ return nil
+}
+
+func Convert_v1_ComponentStatus_To_api_ComponentStatus(in *ComponentStatus, out *api.ComponentStatus, s conversion.Scope) error {
+ return autoConvert_v1_ComponentStatus_To_api_ComponentStatus(in, out, s)
+}
+
func autoConvert_api_ComponentStatus_To_v1_ComponentStatus(in *api.ComponentStatus, out *ComponentStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ComponentStatus))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
if in.Conditions != nil {
- out.Conditions = make([]ComponentCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_api_ComponentCondition_To_v1_ComponentCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]ComponentCondition, len(*in))
+ for i := range *in {
+ if err := Convert_api_ComponentCondition_To_v1_ComponentCondition(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -186,17 +695,43 @@ func Convert_api_ComponentStatus_To_v1_ComponentStatus(in *api.ComponentStatus,
return autoConvert_api_ComponentStatus_To_v1_ComponentStatus(in, out, s)
}
+func autoConvert_v1_ComponentStatusList_To_api_ComponentStatusList(in *ComponentStatusList, out *api.ComponentStatusList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.ComponentStatus, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ComponentStatus_To_api_ComponentStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_ComponentStatusList_To_api_ComponentStatusList(in *ComponentStatusList, out *api.ComponentStatusList, s conversion.Scope) error {
+ return autoConvert_v1_ComponentStatusList_To_api_ComponentStatusList(in, out, s)
+}
+
func autoConvert_api_ComponentStatusList_To_v1_ComponentStatusList(in *api.ComponentStatusList, out *ComponentStatusList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ComponentStatusList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]ComponentStatus, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_ComponentStatus_To_v1_ComponentStatus(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ComponentStatus, len(*in))
+ for i := range *in {
+ if err := Convert_api_ComponentStatus_To_v1_ComponentStatus(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -210,21 +745,30 @@ func Convert_api_ComponentStatusList_To_v1_ComponentStatusList(in *api.Component
return autoConvert_api_ComponentStatusList_To_v1_ComponentStatusList(in, out, s)
}
+func autoConvert_v1_ConfigMap_To_api_ConfigMap(in *ConfigMap, out *api.ConfigMap, s conversion.Scope) error {
+ SetDefaults_ConfigMap(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ out.Data = in.Data
+ return nil
+}
+
+func Convert_v1_ConfigMap_To_api_ConfigMap(in *ConfigMap, out *api.ConfigMap, s conversion.Scope) error {
+ return autoConvert_v1_ConfigMap_To_api_ConfigMap(in, out, s)
+}
+
func autoConvert_api_ConfigMap_To_v1_ConfigMap(in *api.ConfigMap, out *ConfigMap, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMap))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if in.Data != nil {
- out.Data = make(map[string]string)
- for key, val := range in.Data {
- out.Data[key] = val
- }
- } else {
- out.Data = nil
- }
+ out.Data = in.Data
return nil
}
@@ -232,10 +776,19 @@ func Convert_api_ConfigMap_To_v1_ConfigMap(in *api.ConfigMap, out *ConfigMap, s
return autoConvert_api_ConfigMap_To_v1_ConfigMap(in, out, s)
}
-func autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapKeySelector))(in)
+func autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
+ return err
}
+ out.Key = in.Key
+ return nil
+}
+
+func Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
+ return autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in, out, s)
+}
+
+func autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigMapKeySelector, out *ConfigMapKeySelector, s conversion.Scope) error {
if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
return err
}
@@ -247,17 +800,18 @@ func Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *api.ConfigM
return autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in, out, s)
}
-func autoConvert_api_ConfigMapList_To_v1_ConfigMapList(in *api.ConfigMapList, out *ConfigMapList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapList))(in)
+func autoConvert_v1_ConfigMapList_To_api_ConfigMapList(in *ConfigMapList, out *api.ConfigMapList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]ConfigMap, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_ConfigMap_To_v1_ConfigMap(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.ConfigMap, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ConfigMap_To_api_ConfigMap(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -267,21 +821,22 @@ func autoConvert_api_ConfigMapList_To_v1_ConfigMapList(in *api.ConfigMapList, ou
return nil
}
-func Convert_api_ConfigMapList_To_v1_ConfigMapList(in *api.ConfigMapList, out *ConfigMapList, s conversion.Scope) error {
- return autoConvert_api_ConfigMapList_To_v1_ConfigMapList(in, out, s)
+func Convert_v1_ConfigMapList_To_api_ConfigMapList(in *ConfigMapList, out *api.ConfigMapList, s conversion.Scope) error {
+ return autoConvert_v1_ConfigMapList_To_api_ConfigMapList(in, out, s)
}
-func autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ConfigMapVolumeSource))(in)
+func autoConvert_api_ConfigMapList_To_v1_ConfigMapList(in *api.ConfigMapList, out *ConfigMapList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_KeyToPath_To_v1_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ConfigMap, len(*in))
+ for i := range *in {
+ if err := Convert_api_ConfigMap_To_v1_ConfigMap(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -291,37 +846,156 @@ func autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.C
return nil
}
-func Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in, out, s)
+func Convert_api_ConfigMapList_To_v1_ConfigMapList(in *api.ConfigMapList, out *ConfigMapList, s conversion.Scope) error {
+ return autoConvert_api_ConfigMapList_To_v1_ConfigMapList(in, out, s)
}
-func autoConvert_api_Container_To_v1_Container(in *api.Container, out *Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
+func autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
+ return err
}
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.KeyToPath, len(*in))
+ for i := range *in {
+ if err := Convert_v1_KeyToPath_To_api_KeyToPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.Args = nil
+ out.Items = nil
}
- out.WorkingDir = in.WorkingDir
+ return nil
+}
+
+func Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in, out, s)
+}
+
+func autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *ConfigMapVolumeSource, s conversion.Scope) error {
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]KeyToPath, len(*in))
+ for i := range *in {
+ if err := Convert_api_KeyToPath_To_v1_KeyToPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *api.ConfigMapVolumeSource, out *ConfigMapVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in, out, s)
+}
+
+func autoConvert_v1_Container_To_api_Container(in *Container, out *api.Container, s conversion.Scope) error {
+ SetDefaults_Container(in)
+ out.Name = in.Name
+ out.Image = in.Image
+ out.Command = in.Command
+ out.Args = in.Args
+ out.WorkingDir = in.WorkingDir
+ if in.Ports != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]api.ContainerPort, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ContainerPort_To_api_ContainerPort(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.Env != nil {
+ in, out := &in.Env, &out.Env
+ *out = make([]api.EnvVar, len(*in))
+ for i := range *in {
+ if err := Convert_v1_EnvVar_To_api_EnvVar(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Env = nil
+ }
+ if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
+ return err
+ }
+ if in.VolumeMounts != nil {
+ in, out := &in.VolumeMounts, &out.VolumeMounts
+ *out = make([]api.VolumeMount, len(*in))
+ for i := range *in {
+ if err := Convert_v1_VolumeMount_To_api_VolumeMount(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeMounts = nil
+ }
+ if in.LivenessProbe != nil {
+ in, out := &in.LivenessProbe, &out.LivenessProbe
+ *out = new(api.Probe)
+ if err := Convert_v1_Probe_To_api_Probe(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.LivenessProbe = nil
+ }
+ if in.ReadinessProbe != nil {
+ in, out := &in.ReadinessProbe, &out.ReadinessProbe
+ *out = new(api.Probe)
+ if err := Convert_v1_Probe_To_api_Probe(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ReadinessProbe = nil
+ }
+ if in.Lifecycle != nil {
+ in, out := &in.Lifecycle, &out.Lifecycle
+ *out = new(api.Lifecycle)
+ if err := Convert_v1_Lifecycle_To_api_Lifecycle(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Lifecycle = nil
+ }
+ out.TerminationMessagePath = in.TerminationMessagePath
+ out.ImagePullPolicy = api.PullPolicy(in.ImagePullPolicy)
+ if in.SecurityContext != nil {
+ in, out := &in.SecurityContext, &out.SecurityContext
+ *out = new(api.SecurityContext)
+ if err := Convert_v1_SecurityContext_To_api_SecurityContext(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.SecurityContext = nil
+ }
+ out.Stdin = in.Stdin
+ out.StdinOnce = in.StdinOnce
+ out.TTY = in.TTY
+ return nil
+}
+
+func Convert_v1_Container_To_api_Container(in *Container, out *api.Container, s conversion.Scope) error {
+ return autoConvert_v1_Container_To_api_Container(in, out, s)
+}
+
+func autoConvert_api_Container_To_v1_Container(in *api.Container, out *Container, s conversion.Scope) error {
+ out.Name = in.Name
+ out.Image = in.Image
+ out.Command = in.Command
+ out.Args = in.Args
+ out.WorkingDir = in.WorkingDir
if in.Ports != nil {
- out.Ports = make([]ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_api_ContainerPort_To_v1_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]ContainerPort, len(*in))
+ for i := range *in {
+ if err := Convert_api_ContainerPort_To_v1_ContainerPort(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -329,9 +1003,10 @@ func autoConvert_api_Container_To_v1_Container(in *api.Container, out *Container
out.Ports = nil
}
if in.Env != nil {
- out.Env = make([]EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_api_EnvVar_To_v1_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
+ in, out := &in.Env, &out.Env
+ *out = make([]EnvVar, len(*in))
+ for i := range *in {
+ if err := Convert_api_EnvVar_To_v1_EnvVar(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -342,37 +1017,38 @@ func autoConvert_api_Container_To_v1_Container(in *api.Container, out *Container
return err
}
if in.VolumeMounts != nil {
- out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_api_VolumeMount_To_v1_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
+ in, out := &in.VolumeMounts, &out.VolumeMounts
+ *out = make([]VolumeMount, len(*in))
+ for i := range *in {
+ if err := Convert_api_VolumeMount_To_v1_VolumeMount(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
out.VolumeMounts = nil
}
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
if in.LivenessProbe != nil {
- out.LivenessProbe = new(Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
+ in, out := &in.LivenessProbe, &out.LivenessProbe
+ *out = new(Probe)
+ if err := Convert_api_Probe_To_v1_Probe(*in, *out, s); err != nil {
return err
}
} else {
out.LivenessProbe = nil
}
- // unable to generate simple pointer conversion for api.Probe -> v1.Probe
if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(Probe)
- if err := Convert_api_Probe_To_v1_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
+ in, out := &in.ReadinessProbe, &out.ReadinessProbe
+ *out = new(Probe)
+ if err := Convert_api_Probe_To_v1_Probe(*in, *out, s); err != nil {
return err
}
} else {
out.ReadinessProbe = nil
}
- // unable to generate simple pointer conversion for api.Lifecycle -> v1.Lifecycle
if in.Lifecycle != nil {
- out.Lifecycle = new(Lifecycle)
- if err := Convert_api_Lifecycle_To_v1_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
+ in, out := &in.Lifecycle, &out.Lifecycle
+ *out = new(Lifecycle)
+ if err := Convert_api_Lifecycle_To_v1_Lifecycle(*in, *out, s); err != nil {
return err
}
} else {
@@ -380,10 +1056,10 @@ func autoConvert_api_Container_To_v1_Container(in *api.Container, out *Container
}
out.TerminationMessagePath = in.TerminationMessagePath
out.ImagePullPolicy = PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for api.SecurityContext -> v1.SecurityContext
if in.SecurityContext != nil {
- out.SecurityContext = new(SecurityContext)
- if err := Convert_api_SecurityContext_To_v1_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
+ in, out := &in.SecurityContext, &out.SecurityContext
+ *out = new(SecurityContext)
+ if err := Convert_api_SecurityContext_To_v1_SecurityContext(*in, *out, s); err != nil {
return err
}
} else {
@@ -399,18 +1075,18 @@ func Convert_api_Container_To_v1_Container(in *api.Container, out *Container, s
return autoConvert_api_Container_To_v1_Container(in, out, s)
}
+func autoConvert_v1_ContainerImage_To_api_ContainerImage(in *ContainerImage, out *api.ContainerImage, s conversion.Scope) error {
+ out.Names = in.Names
+ out.SizeBytes = in.SizeBytes
+ return nil
+}
+
+func Convert_v1_ContainerImage_To_api_ContainerImage(in *ContainerImage, out *api.ContainerImage, s conversion.Scope) error {
+ return autoConvert_v1_ContainerImage_To_api_ContainerImage(in, out, s)
+}
+
func autoConvert_api_ContainerImage_To_v1_ContainerImage(in *api.ContainerImage, out *ContainerImage, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerImage))(in)
- }
- if in.Names != nil {
- out.Names = make([]string, len(in.Names))
- for i := range in.Names {
- out.Names[i] = in.Names[i]
- }
- } else {
- out.Names = nil
- }
+ out.Names = in.Names
out.SizeBytes = in.SizeBytes
return nil
}
@@ -419,13 +1095,24 @@ func Convert_api_ContainerImage_To_v1_ContainerImage(in *api.ContainerImage, out
return autoConvert_api_ContainerImage_To_v1_ContainerImage(in, out, s)
}
+func autoConvert_v1_ContainerPort_To_api_ContainerPort(in *ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
+ SetDefaults_ContainerPort(in)
+ out.Name = in.Name
+ out.HostPort = in.HostPort
+ out.ContainerPort = in.ContainerPort
+ out.Protocol = api.Protocol(in.Protocol)
+ out.HostIP = in.HostIP
+ return nil
+}
+
+func Convert_v1_ContainerPort_To_api_ContainerPort(in *ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
+ return autoConvert_v1_ContainerPort_To_api_ContainerPort(in, out, s)
+}
+
func autoConvert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerPort))(in)
- }
out.Name = in.Name
- out.HostPort = int32(in.HostPort)
- out.ContainerPort = int32(in.ContainerPort)
+ out.HostPort = in.HostPort
+ out.ContainerPort = in.ContainerPort
out.Protocol = Protocol(in.Protocol)
out.HostIP = in.HostIP
return nil
@@ -435,32 +1122,64 @@ func Convert_api_ContainerPort_To_v1_ContainerPort(in *api.ContainerPort, out *C
return autoConvert_api_ContainerPort_To_v1_ContainerPort(in, out, s)
}
-func autoConvert_api_ContainerState_To_v1_ContainerState(in *api.ContainerState, out *ContainerState, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerState))(in)
+func autoConvert_v1_ContainerState_To_api_ContainerState(in *ContainerState, out *api.ContainerState, s conversion.Scope) error {
+ if in.Waiting != nil {
+ in, out := &in.Waiting, &out.Waiting
+ *out = new(api.ContainerStateWaiting)
+ if err := Convert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Waiting = nil
+ }
+ if in.Running != nil {
+ in, out := &in.Running, &out.Running
+ *out = new(api.ContainerStateRunning)
+ if err := Convert_v1_ContainerStateRunning_To_api_ContainerStateRunning(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Running = nil
+ }
+ if in.Terminated != nil {
+ in, out := &in.Terminated, &out.Terminated
+ *out = new(api.ContainerStateTerminated)
+ if err := Convert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Terminated = nil
}
- // unable to generate simple pointer conversion for api.ContainerStateWaiting -> v1.ContainerStateWaiting
+ return nil
+}
+
+func Convert_v1_ContainerState_To_api_ContainerState(in *ContainerState, out *api.ContainerState, s conversion.Scope) error {
+ return autoConvert_v1_ContainerState_To_api_ContainerState(in, out, s)
+}
+
+func autoConvert_api_ContainerState_To_v1_ContainerState(in *api.ContainerState, out *ContainerState, s conversion.Scope) error {
if in.Waiting != nil {
- out.Waiting = new(ContainerStateWaiting)
- if err := Convert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting(in.Waiting, out.Waiting, s); err != nil {
+ in, out := &in.Waiting, &out.Waiting
+ *out = new(ContainerStateWaiting)
+ if err := Convert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting(*in, *out, s); err != nil {
return err
}
} else {
out.Waiting = nil
}
- // unable to generate simple pointer conversion for api.ContainerStateRunning -> v1.ContainerStateRunning
if in.Running != nil {
- out.Running = new(ContainerStateRunning)
- if err := Convert_api_ContainerStateRunning_To_v1_ContainerStateRunning(in.Running, out.Running, s); err != nil {
+ in, out := &in.Running, &out.Running
+ *out = new(ContainerStateRunning)
+ if err := Convert_api_ContainerStateRunning_To_v1_ContainerStateRunning(*in, *out, s); err != nil {
return err
}
} else {
out.Running = nil
}
- // unable to generate simple pointer conversion for api.ContainerStateTerminated -> v1.ContainerStateTerminated
if in.Terminated != nil {
- out.Terminated = new(ContainerStateTerminated)
- if err := Convert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(in.Terminated, out.Terminated, s); err != nil {
+ in, out := &in.Terminated, &out.Terminated
+ *out = new(ContainerStateTerminated)
+ if err := Convert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(*in, *out, s); err != nil {
return err
}
} else {
@@ -473,10 +1192,18 @@ func Convert_api_ContainerState_To_v1_ContainerState(in *api.ContainerState, out
return autoConvert_api_ContainerState_To_v1_ContainerState(in, out, s)
}
-func autoConvert_api_ContainerStateRunning_To_v1_ContainerStateRunning(in *api.ContainerStateRunning, out *ContainerStateRunning, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerStateRunning))(in)
+func autoConvert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in *ContainerStateRunning, out *api.ContainerStateRunning, s conversion.Scope) error {
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in *ContainerStateRunning, out *api.ContainerStateRunning, s conversion.Scope) error {
+ return autoConvert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in, out, s)
+}
+
+func autoConvert_api_ContainerStateRunning_To_v1_ContainerStateRunning(in *api.ContainerStateRunning, out *ContainerStateRunning, s conversion.Scope) error {
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
return err
}
@@ -487,12 +1214,28 @@ func Convert_api_ContainerStateRunning_To_v1_ContainerStateRunning(in *api.Conta
return autoConvert_api_ContainerStateRunning_To_v1_ContainerStateRunning(in, out, s)
}
-func autoConvert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(in *api.ContainerStateTerminated, out *ContainerStateTerminated, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerStateTerminated))(in)
+func autoConvert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in *ContainerStateTerminated, out *api.ContainerStateTerminated, s conversion.Scope) error {
+ out.ExitCode = in.ExitCode
+ out.Signal = in.Signal
+ out.Reason = in.Reason
+ out.Message = in.Message
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.FinishedAt, &out.FinishedAt, s); err != nil {
+ return err
}
- out.ExitCode = int32(in.ExitCode)
- out.Signal = int32(in.Signal)
+ out.ContainerID = in.ContainerID
+ return nil
+}
+
+func Convert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in *ContainerStateTerminated, out *api.ContainerStateTerminated, s conversion.Scope) error {
+ return autoConvert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in, out, s)
+}
+
+func autoConvert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(in *api.ContainerStateTerminated, out *ContainerStateTerminated, s conversion.Scope) error {
+ out.ExitCode = in.ExitCode
+ out.Signal = in.Signal
out.Reason = in.Reason
out.Message = in.Message
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
@@ -509,10 +1252,17 @@ func Convert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(in *api
return autoConvert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated(in, out, s)
}
+func autoConvert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in *ContainerStateWaiting, out *api.ContainerStateWaiting, s conversion.Scope) error {
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in *ContainerStateWaiting, out *api.ContainerStateWaiting, s conversion.Scope) error {
+ return autoConvert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in, out, s)
+}
+
func autoConvert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting(in *api.ContainerStateWaiting, out *ContainerStateWaiting, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerStateWaiting))(in)
- }
out.Reason = in.Reason
out.Message = in.Message
return nil
@@ -522,10 +1272,27 @@ func Convert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting(in *api.Conta
return autoConvert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting(in, out, s)
}
-func autoConvert_api_ContainerStatus_To_v1_ContainerStatus(in *api.ContainerStatus, out *ContainerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ContainerStatus))(in)
+func autoConvert_v1_ContainerStatus_To_api_ContainerStatus(in *ContainerStatus, out *api.ContainerStatus, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := Convert_v1_ContainerState_To_api_ContainerState(&in.State, &out.State, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ContainerState_To_api_ContainerState(&in.LastTerminationState, &out.LastTerminationState, s); err != nil {
+ return err
}
+ out.Ready = in.Ready
+ out.RestartCount = in.RestartCount
+ out.Image = in.Image
+ out.ImageID = in.ImageID
+ out.ContainerID = in.ContainerID
+ return nil
+}
+
+func Convert_v1_ContainerStatus_To_api_ContainerStatus(in *ContainerStatus, out *api.ContainerStatus, s conversion.Scope) error {
+ return autoConvert_v1_ContainerStatus_To_api_ContainerStatus(in, out, s)
+}
+
+func autoConvert_api_ContainerStatus_To_v1_ContainerStatus(in *api.ContainerStatus, out *ContainerStatus, s conversion.Scope) error {
out.Name = in.Name
if err := Convert_api_ContainerState_To_v1_ContainerState(&in.State, &out.State, s); err != nil {
return err
@@ -534,7 +1301,7 @@ func autoConvert_api_ContainerStatus_To_v1_ContainerStatus(in *api.ContainerStat
return err
}
out.Ready = in.Ready
- out.RestartCount = int32(in.RestartCount)
+ out.RestartCount = in.RestartCount
out.Image = in.Image
out.ImageID = in.ImageID
out.ContainerID = in.ContainerID
@@ -545,11 +1312,17 @@ func Convert_api_ContainerStatus_To_v1_ContainerStatus(in *api.ContainerStatus,
return autoConvert_api_ContainerStatus_To_v1_ContainerStatus(in, out, s)
}
+func autoConvert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in *DaemonEndpoint, out *api.DaemonEndpoint, s conversion.Scope) error {
+ out.Port = in.Port
+ return nil
+}
+
+func Convert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in *DaemonEndpoint, out *api.DaemonEndpoint, s conversion.Scope) error {
+ return autoConvert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in, out, s)
+}
+
func autoConvert_api_DaemonEndpoint_To_v1_DaemonEndpoint(in *api.DaemonEndpoint, out *DaemonEndpoint, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DaemonEndpoint))(in)
- }
- out.Port = int32(in.Port)
+ out.Port = in.Port
return nil
}
@@ -557,64 +1330,153 @@ func Convert_api_DaemonEndpoint_To_v1_DaemonEndpoint(in *api.DaemonEndpoint, out
return autoConvert_api_DaemonEndpoint_To_v1_DaemonEndpoint(in, out, s)
}
-func autoConvert_api_DeleteOptions_To_v1_DeleteOptions(in *api.DeleteOptions, out *DeleteOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DeleteOptions))(in)
+func autoConvert_v1_DeleteOptions_To_api_DeleteOptions(in *DeleteOptions, out *api.DeleteOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- if in.GracePeriodSeconds != nil {
- out.GracePeriodSeconds = new(int64)
- *out.GracePeriodSeconds = *in.GracePeriodSeconds
+ out.GracePeriodSeconds = in.GracePeriodSeconds
+ if in.Preconditions != nil {
+ in, out := &in.Preconditions, &out.Preconditions
+ *out = new(api.Preconditions)
+ if err := Convert_v1_Preconditions_To_api_Preconditions(*in, *out, s); err != nil {
+ return err
+ }
} else {
- out.GracePeriodSeconds = nil
+ out.Preconditions = nil
}
+ out.OrphanDependents = in.OrphanDependents
return nil
}
-func Convert_api_DeleteOptions_To_v1_DeleteOptions(in *api.DeleteOptions, out *DeleteOptions, s conversion.Scope) error {
- return autoConvert_api_DeleteOptions_To_v1_DeleteOptions(in, out, s)
+func Convert_v1_DeleteOptions_To_api_DeleteOptions(in *DeleteOptions, out *api.DeleteOptions, s conversion.Scope) error {
+ return autoConvert_v1_DeleteOptions_To_api_DeleteOptions(in, out, s)
}
-func autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
+func autoConvert_api_DeleteOptions_To_v1_DeleteOptions(in *api.DeleteOptions, out *DeleteOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
return err
}
+ out.GracePeriodSeconds = in.GracePeriodSeconds
+ if in.Preconditions != nil {
+ in, out := &in.Preconditions, &out.Preconditions
+ *out = new(Preconditions)
+ if err := Convert_api_Preconditions_To_v1_Preconditions(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Preconditions = nil
+ }
+ out.OrphanDependents = in.OrphanDependents
return nil
}
-func Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in, out, s)
+func Convert_api_DeleteOptions_To_v1_DeleteOptions(in *api.DeleteOptions, out *DeleteOptions, s conversion.Scope) error {
+ return autoConvert_api_DeleteOptions_To_v1_DeleteOptions(in, out, s)
}
-func autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.DownwardAPIVolumeSource))(in)
+func autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
+ out.Path = in.Path
+ if in.FieldRef != nil {
+ in, out := &in.FieldRef, &out.FieldRef
+ *out = new(api.ObjectFieldSelector)
+ if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
}
- if in.Items != nil {
- out.Items = make([]DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
+ if in.ResourceFieldRef != nil {
+ in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(api.ResourceFieldSelector)
+ if err := Convert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Items = nil
+ out.ResourceFieldRef = nil
}
return nil
}
-func Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in, out, s)
+func Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
+ return autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in, out, s)
}
-func autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EmptyDirVolumeSource))(in)
- }
- out.Medium = StorageMedium(in.Medium)
+func autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, s conversion.Scope) error {
+ out.Path = in.Path
+ if in.FieldRef != nil {
+ in, out := &in.FieldRef, &out.FieldRef
+ *out = new(ObjectFieldSelector)
+ if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
+ }
+ if in.ResourceFieldRef != nil {
+ in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := Convert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
+ return nil
+}
+
+func Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *api.DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, s conversion.Scope) error {
+ return autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in, out, s)
+}
+
+func autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.DownwardAPIVolumeFile, len(*in))
+ for i := range *in {
+ if err := Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in, out, s)
+}
+
+func autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]DownwardAPIVolumeFile, len(*in))
+ for i := range *in {
+ if err := Convert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *api.DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in, out, s)
+}
+
+func autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
+ out.Medium = api.StorageMedium(in.Medium)
+ return nil
+}
+
+func Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in, out, s)
+}
+
+func autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDirVolumeSource, out *EmptyDirVolumeSource, s conversion.Scope) error {
+ out.Medium = StorageMedium(in.Medium)
return nil
}
@@ -622,15 +1484,32 @@ func Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *api.EmptyDi
return autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in, out, s)
}
-func autoConvert_api_EndpointAddress_To_v1_EndpointAddress(in *api.EndpointAddress, out *EndpointAddress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EndpointAddress))(in)
+func autoConvert_v1_EndpointAddress_To_api_EndpointAddress(in *EndpointAddress, out *api.EndpointAddress, s conversion.Scope) error {
+ out.IP = in.IP
+ out.Hostname = in.Hostname
+ if in.TargetRef != nil {
+ in, out := &in.TargetRef, &out.TargetRef
+ *out = new(api.ObjectReference)
+ if err := Convert_v1_ObjectReference_To_api_ObjectReference(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.TargetRef = nil
}
+ return nil
+}
+
+func Convert_v1_EndpointAddress_To_api_EndpointAddress(in *EndpointAddress, out *api.EndpointAddress, s conversion.Scope) error {
+ return autoConvert_v1_EndpointAddress_To_api_EndpointAddress(in, out, s)
+}
+
+func autoConvert_api_EndpointAddress_To_v1_EndpointAddress(in *api.EndpointAddress, out *EndpointAddress, s conversion.Scope) error {
out.IP = in.IP
- // unable to generate simple pointer conversion for api.ObjectReference -> v1.ObjectReference
+ out.Hostname = in.Hostname
if in.TargetRef != nil {
- out.TargetRef = new(ObjectReference)
- if err := Convert_api_ObjectReference_To_v1_ObjectReference(in.TargetRef, out.TargetRef, s); err != nil {
+ in, out := &in.TargetRef, &out.TargetRef
+ *out = new(ObjectReference)
+ if err := Convert_api_ObjectReference_To_v1_ObjectReference(*in, *out, s); err != nil {
return err
}
} else {
@@ -643,12 +1522,20 @@ func Convert_api_EndpointAddress_To_v1_EndpointAddress(in *api.EndpointAddress,
return autoConvert_api_EndpointAddress_To_v1_EndpointAddress(in, out, s)
}
+func autoConvert_v1_EndpointPort_To_api_EndpointPort(in *EndpointPort, out *api.EndpointPort, s conversion.Scope) error {
+ out.Name = in.Name
+ out.Port = in.Port
+ out.Protocol = api.Protocol(in.Protocol)
+ return nil
+}
+
+func Convert_v1_EndpointPort_To_api_EndpointPort(in *EndpointPort, out *api.EndpointPort, s conversion.Scope) error {
+ return autoConvert_v1_EndpointPort_To_api_EndpointPort(in, out, s)
+}
+
func autoConvert_api_EndpointPort_To_v1_EndpointPort(in *api.EndpointPort, out *EndpointPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EndpointPort))(in)
- }
out.Name = in.Name
- out.Port = int32(in.Port)
+ out.Port = in.Port
out.Protocol = Protocol(in.Protocol)
return nil
}
@@ -657,14 +1544,53 @@ func Convert_api_EndpointPort_To_v1_EndpointPort(in *api.EndpointPort, out *Endp
return autoConvert_api_EndpointPort_To_v1_EndpointPort(in, out, s)
}
-func autoConvert_api_EndpointSubset_To_v1_EndpointSubset(in *api.EndpointSubset, out *EndpointSubset, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EndpointSubset))(in)
+func autoConvert_v1_EndpointSubset_To_api_EndpointSubset(in *EndpointSubset, out *api.EndpointSubset, s conversion.Scope) error {
+ if in.Addresses != nil {
+ in, out := &in.Addresses, &out.Addresses
+ *out = make([]api.EndpointAddress, len(*in))
+ for i := range *in {
+ if err := Convert_v1_EndpointAddress_To_api_EndpointAddress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Addresses = nil
+ }
+ if in.NotReadyAddresses != nil {
+ in, out := &in.NotReadyAddresses, &out.NotReadyAddresses
+ *out = make([]api.EndpointAddress, len(*in))
+ for i := range *in {
+ if err := Convert_v1_EndpointAddress_To_api_EndpointAddress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.NotReadyAddresses = nil
}
+ if in.Ports != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]api.EndpointPort, len(*in))
+ for i := range *in {
+ if err := Convert_v1_EndpointPort_To_api_EndpointPort(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ return nil
+}
+
+func Convert_v1_EndpointSubset_To_api_EndpointSubset(in *EndpointSubset, out *api.EndpointSubset, s conversion.Scope) error {
+ return autoConvert_v1_EndpointSubset_To_api_EndpointSubset(in, out, s)
+}
+
+func autoConvert_api_EndpointSubset_To_v1_EndpointSubset(in *api.EndpointSubset, out *EndpointSubset, s conversion.Scope) error {
if in.Addresses != nil {
- out.Addresses = make([]EndpointAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := Convert_api_EndpointAddress_To_v1_EndpointAddress(&in.Addresses[i], &out.Addresses[i], s); err != nil {
+ in, out := &in.Addresses, &out.Addresses
+ *out = make([]EndpointAddress, len(*in))
+ for i := range *in {
+ if err := Convert_api_EndpointAddress_To_v1_EndpointAddress(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -672,9 +1598,10 @@ func autoConvert_api_EndpointSubset_To_v1_EndpointSubset(in *api.EndpointSubset,
out.Addresses = nil
}
if in.NotReadyAddresses != nil {
- out.NotReadyAddresses = make([]EndpointAddress, len(in.NotReadyAddresses))
- for i := range in.NotReadyAddresses {
- if err := Convert_api_EndpointAddress_To_v1_EndpointAddress(&in.NotReadyAddresses[i], &out.NotReadyAddresses[i], s); err != nil {
+ in, out := &in.NotReadyAddresses, &out.NotReadyAddresses
+ *out = make([]EndpointAddress, len(*in))
+ for i := range *in {
+ if err := Convert_api_EndpointAddress_To_v1_EndpointAddress(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -682,9 +1609,10 @@ func autoConvert_api_EndpointSubset_To_v1_EndpointSubset(in *api.EndpointSubset,
out.NotReadyAddresses = nil
}
if in.Ports != nil {
- out.Ports = make([]EndpointPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_api_EndpointPort_To_v1_EndpointPort(&in.Ports[i], &out.Ports[i], s); err != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]EndpointPort, len(*in))
+ for i := range *in {
+ if err := Convert_api_EndpointPort_To_v1_EndpointPort(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -698,17 +1626,44 @@ func Convert_api_EndpointSubset_To_v1_EndpointSubset(in *api.EndpointSubset, out
return autoConvert_api_EndpointSubset_To_v1_EndpointSubset(in, out, s)
}
+func autoConvert_v1_Endpoints_To_api_Endpoints(in *Endpoints, out *api.Endpoints, s conversion.Scope) error {
+ SetDefaults_Endpoints(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if in.Subsets != nil {
+ in, out := &in.Subsets, &out.Subsets
+ *out = make([]api.EndpointSubset, len(*in))
+ for i := range *in {
+ if err := Convert_v1_EndpointSubset_To_api_EndpointSubset(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subsets = nil
+ }
+ return nil
+}
+
+func Convert_v1_Endpoints_To_api_Endpoints(in *Endpoints, out *api.Endpoints, s conversion.Scope) error {
+ return autoConvert_v1_Endpoints_To_api_Endpoints(in, out, s)
+}
+
func autoConvert_api_Endpoints_To_v1_Endpoints(in *api.Endpoints, out *Endpoints, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Endpoints))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
if in.Subsets != nil {
- out.Subsets = make([]EndpointSubset, len(in.Subsets))
- for i := range in.Subsets {
- if err := Convert_api_EndpointSubset_To_v1_EndpointSubset(&in.Subsets[i], &out.Subsets[i], s); err != nil {
+ in, out := &in.Subsets, &out.Subsets
+ *out = make([]EndpointSubset, len(*in))
+ for i := range *in {
+ if err := Convert_api_EndpointSubset_To_v1_EndpointSubset(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -722,17 +1677,43 @@ func Convert_api_Endpoints_To_v1_Endpoints(in *api.Endpoints, out *Endpoints, s
return autoConvert_api_Endpoints_To_v1_Endpoints(in, out, s)
}
+func autoConvert_v1_EndpointsList_To_api_EndpointsList(in *EndpointsList, out *api.EndpointsList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Endpoints, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Endpoints_To_api_Endpoints(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_EndpointsList_To_api_EndpointsList(in *EndpointsList, out *api.EndpointsList, s conversion.Scope) error {
+ return autoConvert_v1_EndpointsList_To_api_EndpointsList(in, out, s)
+}
+
func autoConvert_api_EndpointsList_To_v1_EndpointsList(in *api.EndpointsList, out *EndpointsList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EndpointsList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]Endpoints, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Endpoints_To_v1_Endpoints(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Endpoints, len(*in))
+ for i := range *in {
+ if err := Convert_api_Endpoints_To_v1_Endpoints(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -746,16 +1727,32 @@ func Convert_api_EndpointsList_To_v1_EndpointsList(in *api.EndpointsList, out *E
return autoConvert_api_EndpointsList_To_v1_EndpointsList(in, out, s)
}
-func autoConvert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVar))(in)
+func autoConvert_v1_EnvVar_To_api_EnvVar(in *EnvVar, out *api.EnvVar, s conversion.Scope) error {
+ out.Name = in.Name
+ out.Value = in.Value
+ if in.ValueFrom != nil {
+ in, out := &in.ValueFrom, &out.ValueFrom
+ *out = new(api.EnvVarSource)
+ if err := Convert_v1_EnvVarSource_To_api_EnvVarSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ValueFrom = nil
}
+ return nil
+}
+
+func Convert_v1_EnvVar_To_api_EnvVar(in *EnvVar, out *api.EnvVar, s conversion.Scope) error {
+ return autoConvert_v1_EnvVar_To_api_EnvVar(in, out, s)
+}
+
+func autoConvert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *EnvVar, s conversion.Scope) error {
out.Name = in.Name
out.Value = in.Value
- // unable to generate simple pointer conversion for api.EnvVarSource -> v1.EnvVarSource
if in.ValueFrom != nil {
- out.ValueFrom = new(EnvVarSource)
- if err := Convert_api_EnvVarSource_To_v1_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
+ in, out := &in.ValueFrom, &out.ValueFrom
+ *out = new(EnvVarSource)
+ if err := Convert_api_EnvVarSource_To_v1_EnvVarSource(*in, *out, s); err != nil {
return err
}
} else {
@@ -768,32 +1765,82 @@ func Convert_api_EnvVar_To_v1_EnvVar(in *api.EnvVar, out *EnvVar, s conversion.S
return autoConvert_api_EnvVar_To_v1_EnvVar(in, out, s)
}
-func autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EnvVarSource))(in)
+func autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in *EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
+ if in.FieldRef != nil {
+ in, out := &in.FieldRef, &out.FieldRef
+ *out = new(api.ObjectFieldSelector)
+ if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
+ }
+ if in.ResourceFieldRef != nil {
+ in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(api.ResourceFieldSelector)
+ if err := Convert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
+ if in.ConfigMapKeyRef != nil {
+ in, out := &in.ConfigMapKeyRef, &out.ConfigMapKeyRef
+ *out = new(api.ConfigMapKeySelector)
+ if err := Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ConfigMapKeyRef = nil
+ }
+ if in.SecretKeyRef != nil {
+ in, out := &in.SecretKeyRef, &out.SecretKeyRef
+ *out = new(api.SecretKeySelector)
+ if err := Convert_v1_SecretKeySelector_To_api_SecretKeySelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.SecretKeyRef = nil
}
- // unable to generate simple pointer conversion for api.ObjectFieldSelector -> v1.ObjectFieldSelector
+ return nil
+}
+
+func Convert_v1_EnvVarSource_To_api_EnvVarSource(in *EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
+ return autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in, out, s)
+}
+
+func autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *EnvVarSource, s conversion.Scope) error {
if in.FieldRef != nil {
- out.FieldRef = new(ObjectFieldSelector)
- if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
+ in, out := &in.FieldRef, &out.FieldRef
+ *out = new(ObjectFieldSelector)
+ if err := Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(*in, *out, s); err != nil {
return err
}
} else {
out.FieldRef = nil
}
- // unable to generate simple pointer conversion for api.ConfigMapKeySelector -> v1.ConfigMapKeySelector
+ if in.ResourceFieldRef != nil {
+ in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := Convert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(ConfigMapKeySelector)
- if err := Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
+ in, out := &in.ConfigMapKeyRef, &out.ConfigMapKeyRef
+ *out = new(ConfigMapKeySelector)
+ if err := Convert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(*in, *out, s); err != nil {
return err
}
} else {
out.ConfigMapKeyRef = nil
}
- // unable to generate simple pointer conversion for api.SecretKeySelector -> v1.SecretKeySelector
if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(SecretKeySelector)
- if err := Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
+ in, out := &in.SecretKeyRef, &out.SecretKeyRef
+ *out = new(SecretKeySelector)
+ if err := Convert_api_SecretKeySelector_To_v1_SecretKeySelector(*in, *out, s); err != nil {
return err
}
} else {
@@ -806,9 +1853,39 @@ func Convert_api_EnvVarSource_To_v1_EnvVarSource(in *api.EnvVarSource, out *EnvV
return autoConvert_api_EnvVarSource_To_v1_EnvVarSource(in, out, s)
}
+func autoConvert_v1_Event_To_api_Event(in *Event, out *api.Event, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.InvolvedObject, &out.InvolvedObject, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ if err := Convert_v1_EventSource_To_api_EventSource(&in.Source, &out.Source, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.FirstTimestamp, &out.FirstTimestamp, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTimestamp, &out.LastTimestamp, s); err != nil {
+ return err
+ }
+ out.Count = in.Count
+ out.Type = in.Type
+ return nil
+}
+
+func Convert_v1_Event_To_api_Event(in *Event, out *api.Event, s conversion.Scope) error {
+ return autoConvert_v1_Event_To_api_Event(in, out, s)
+}
+
func autoConvert_api_Event_To_v1_Event(in *api.Event, out *Event, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Event))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -827,7 +1904,7 @@ func autoConvert_api_Event_To_v1_Event(in *api.Event, out *Event, s conversion.S
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTimestamp, &out.LastTimestamp, s); err != nil {
return err
}
- out.Count = int32(in.Count)
+ out.Count = in.Count
out.Type = in.Type
return nil
}
@@ -836,17 +1913,18 @@ func Convert_api_Event_To_v1_Event(in *api.Event, out *Event, s conversion.Scope
return autoConvert_api_Event_To_v1_Event(in, out, s)
}
-func autoConvert_api_EventList_To_v1_EventList(in *api.EventList, out *EventList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EventList))(in)
+func autoConvert_v1_EventList_To_api_EventList(in *EventList, out *api.EventList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]Event, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Event_To_v1_Event(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Event, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Event_To_api_Event(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -856,35 +1934,66 @@ func autoConvert_api_EventList_To_v1_EventList(in *api.EventList, out *EventList
return nil
}
-func Convert_api_EventList_To_v1_EventList(in *api.EventList, out *EventList, s conversion.Scope) error {
- return autoConvert_api_EventList_To_v1_EventList(in, out, s)
+func Convert_v1_EventList_To_api_EventList(in *EventList, out *api.EventList, s conversion.Scope) error {
+ return autoConvert_v1_EventList_To_api_EventList(in, out, s)
}
-func autoConvert_api_EventSource_To_v1_EventSource(in *api.EventSource, out *EventSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.EventSource))(in)
+func autoConvert_api_EventList_To_v1_EventList(in *api.EventList, out *EventList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- out.Component = in.Component
- out.Host = in.Host
- return nil
-}
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Event, len(*in))
+ for i := range *in {
+ if err := Convert_api_Event_To_v1_Event(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_EventList_To_v1_EventList(in *api.EventList, out *EventList, s conversion.Scope) error {
+ return autoConvert_api_EventList_To_v1_EventList(in, out, s)
+}
+
+func autoConvert_v1_EventSource_To_api_EventSource(in *EventSource, out *api.EventSource, s conversion.Scope) error {
+ out.Component = in.Component
+ out.Host = in.Host
+ return nil
+}
+
+func Convert_v1_EventSource_To_api_EventSource(in *EventSource, out *api.EventSource, s conversion.Scope) error {
+ return autoConvert_v1_EventSource_To_api_EventSource(in, out, s)
+}
+
+func autoConvert_api_EventSource_To_v1_EventSource(in *api.EventSource, out *EventSource, s conversion.Scope) error {
+ out.Component = in.Component
+ out.Host = in.Host
+ return nil
+}
func Convert_api_EventSource_To_v1_EventSource(in *api.EventSource, out *EventSource, s conversion.Scope) error {
return autoConvert_api_EventSource_To_v1_EventSource(in, out, s)
}
+func autoConvert_v1_ExecAction_To_api_ExecAction(in *ExecAction, out *api.ExecAction, s conversion.Scope) error {
+ out.Command = in.Command
+ return nil
+}
+
+func Convert_v1_ExecAction_To_api_ExecAction(in *ExecAction, out *api.ExecAction, s conversion.Scope) error {
+ return autoConvert_v1_ExecAction_To_api_ExecAction(in, out, s)
+}
+
func autoConvert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
+ out.Command = in.Command
return nil
}
@@ -892,24 +2001,47 @@ func Convert_api_ExecAction_To_v1_ExecAction(in *api.ExecAction, out *ExecAction
return autoConvert_api_ExecAction_To_v1_ExecAction(in, out, s)
}
-func autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
+func autoConvert_v1_ExportOptions_To_api_ExportOptions(in *ExportOptions, out *api.ExportOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- if in.Lun != nil {
- out.Lun = new(int32)
- *out.Lun = int32(*in.Lun)
- } else {
- out.Lun = nil
+ out.Export = in.Export
+ out.Exact = in.Exact
+ return nil
+}
+
+func Convert_v1_ExportOptions_To_api_ExportOptions(in *ExportOptions, out *api.ExportOptions, s conversion.Scope) error {
+ return autoConvert_v1_ExportOptions_To_api_ExportOptions(in, out, s)
+}
+
+func autoConvert_api_ExportOptions_To_v1_ExportOptions(in *api.ExportOptions, out *ExportOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
+ out.Export = in.Export
+ out.Exact = in.Exact
+ return nil
+}
+
+func Convert_api_ExportOptions_To_v1_ExportOptions(in *api.ExportOptions, out *ExportOptions, s conversion.Scope) error {
+ return autoConvert_api_ExportOptions_To_v1_ExportOptions(in, out, s)
+}
+
+func autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in *FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
+ out.TargetWWNs = in.TargetWWNs
+ out.Lun = in.Lun
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in *FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in, out, s)
+}
+
+func autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out *FCVolumeSource, s conversion.Scope) error {
+ out.TargetWWNs = in.TargetWWNs
+ out.Lun = in.Lun
out.FSType = in.FSType
out.ReadOnly = in.ReadOnly
return nil
@@ -919,30 +2051,41 @@ func Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in *api.FCVolumeSource, out
return autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource(in, out, s)
}
-func autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlexVolumeSource))(in)
- }
+func autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
out.Driver = in.Driver
out.FSType = in.FSType
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(api.LocalObjectReference)
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(*in, *out, s); err != nil {
return err
}
} else {
out.SecretRef = nil
}
out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
+ out.Options = in.Options
+ return nil
+}
+
+func Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in, out, s)
+}
+
+func autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSource, out *FlexVolumeSource, s conversion.Scope) error {
+ out.Driver = in.Driver
+ out.FSType = in.FSType
+ if in.SecretRef != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Options = nil
+ out.SecretRef = nil
}
+ out.ReadOnly = in.ReadOnly
+ out.Options = in.Options
return nil
}
@@ -950,10 +2093,16 @@ func Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in *api.FlexVolumeSourc
return autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in, out, s)
}
+func autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
+ out.DatasetName = in.DatasetName
+ return nil
+}
+
+func Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in, out, s)
+}
+
func autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVolumeSource, out *FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.FlockerVolumeSource))(in)
- }
out.DatasetName = in.DatasetName
return nil
}
@@ -962,13 +2111,22 @@ func Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *api.FlockerVo
return autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in, out, s)
}
+func autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
+ out.PDName = in.PDName
+ out.FSType = in.FSType
+ out.Partition = in.Partition
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in, out, s)
+}
+
func autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *api.GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GCEPersistentDiskVolumeSource))(in)
- }
out.PDName = in.PDName
out.FSType = in.FSType
- out.Partition = int32(in.Partition)
+ out.Partition = in.Partition
out.ReadOnly = in.ReadOnly
return nil
}
@@ -977,10 +2135,18 @@ func Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSour
return autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in, out, s)
}
+func autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
+ out.Repository = in.Repository
+ out.Revision = in.Revision
+ out.Directory = in.Directory
+ return nil
+}
+
+func Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in, out, s)
+}
+
func autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVolumeSource, out *GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GitRepoVolumeSource))(in)
- }
out.Repository = in.Repository
out.Revision = in.Revision
out.Directory = in.Directory
@@ -991,10 +2157,18 @@ func Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *api.GitRepoVo
return autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in, out, s)
}
+func autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
+ out.EndpointsName = in.EndpointsName
+ out.Path = in.Path
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in, out, s)
+}
+
func autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.GlusterfsVolumeSource, out *GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.GlusterfsVolumeSource))(in)
- }
out.EndpointsName = in.EndpointsName
out.Path = in.Path
out.ReadOnly = in.ReadOnly
@@ -1005,10 +2179,33 @@ func Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *api.Glust
return autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in, out, s)
}
-func autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPGetAction))(in)
+func autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in *HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
+ SetDefaults_HTTPGetAction(in)
+ out.Path = in.Path
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
+ return err
}
+ out.Host = in.Host
+ out.Scheme = api.URIScheme(in.Scheme)
+ if in.HTTPHeaders != nil {
+ in, out := &in.HTTPHeaders, &out.HTTPHeaders
+ *out = make([]api.HTTPHeader, len(*in))
+ for i := range *in {
+ if err := Convert_v1_HTTPHeader_To_api_HTTPHeader(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HTTPHeaders = nil
+ }
+ return nil
+}
+
+func Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in *HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
+ return autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in, out, s)
+}
+
+func autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *HTTPGetAction, s conversion.Scope) error {
out.Path = in.Path
if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
return err
@@ -1016,9 +2213,10 @@ func autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, ou
out.Host = in.Host
out.Scheme = URIScheme(in.Scheme)
if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_api_HTTPHeader_To_v1_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
+ in, out := &in.HTTPHeaders, &out.HTTPHeaders
+ *out = make([]HTTPHeader, len(*in))
+ for i := range *in {
+ if err := Convert_api_HTTPHeader_To_v1_HTTPHeader(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1032,10 +2230,17 @@ func Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in *api.HTTPGetAction, out *H
return autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction(in, out, s)
}
+func autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in *HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
+ out.Name = in.Name
+ out.Value = in.Value
+ return nil
+}
+
+func Convert_v1_HTTPHeader_To_api_HTTPHeader(in *HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
+ return autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in, out, s)
+}
+
func autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HTTPHeader))(in)
- }
out.Name = in.Name
out.Value = in.Value
return nil
@@ -1045,32 +2250,64 @@ func Convert_api_HTTPHeader_To_v1_HTTPHeader(in *api.HTTPHeader, out *HTTPHeader
return autoConvert_api_HTTPHeader_To_v1_HTTPHeader(in, out, s)
}
-func autoConvert_api_Handler_To_v1_Handler(in *api.Handler, out *Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Handler))(in)
+func autoConvert_v1_Handler_To_api_Handler(in *Handler, out *api.Handler, s conversion.Scope) error {
+ if in.Exec != nil {
+ in, out := &in.Exec, &out.Exec
+ *out = new(api.ExecAction)
+ if err := Convert_v1_ExecAction_To_api_ExecAction(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Exec = nil
+ }
+ if in.HTTPGet != nil {
+ in, out := &in.HTTPGet, &out.HTTPGet
+ *out = new(api.HTTPGetAction)
+ if err := Convert_v1_HTTPGetAction_To_api_HTTPGetAction(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.HTTPGet = nil
+ }
+ if in.TCPSocket != nil {
+ in, out := &in.TCPSocket, &out.TCPSocket
+ *out = new(api.TCPSocketAction)
+ if err := Convert_v1_TCPSocketAction_To_api_TCPSocketAction(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.TCPSocket = nil
}
- // unable to generate simple pointer conversion for api.ExecAction -> v1.ExecAction
+ return nil
+}
+
+func Convert_v1_Handler_To_api_Handler(in *Handler, out *api.Handler, s conversion.Scope) error {
+ return autoConvert_v1_Handler_To_api_Handler(in, out, s)
+}
+
+func autoConvert_api_Handler_To_v1_Handler(in *api.Handler, out *Handler, s conversion.Scope) error {
if in.Exec != nil {
- out.Exec = new(ExecAction)
- if err := Convert_api_ExecAction_To_v1_ExecAction(in.Exec, out.Exec, s); err != nil {
+ in, out := &in.Exec, &out.Exec
+ *out = new(ExecAction)
+ if err := Convert_api_ExecAction_To_v1_ExecAction(*in, *out, s); err != nil {
return err
}
} else {
out.Exec = nil
}
- // unable to generate simple pointer conversion for api.HTTPGetAction -> v1.HTTPGetAction
if in.HTTPGet != nil {
- out.HTTPGet = new(HTTPGetAction)
- if err := Convert_api_HTTPGetAction_To_v1_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
+ in, out := &in.HTTPGet, &out.HTTPGet
+ *out = new(HTTPGetAction)
+ if err := Convert_api_HTTPGetAction_To_v1_HTTPGetAction(*in, *out, s); err != nil {
return err
}
} else {
out.HTTPGet = nil
}
- // unable to generate simple pointer conversion for api.TCPSocketAction -> v1.TCPSocketAction
if in.TCPSocket != nil {
- out.TCPSocket = new(TCPSocketAction)
- if err := Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
+ in, out := &in.TCPSocket, &out.TCPSocket
+ *out = new(TCPSocketAction)
+ if err := Convert_api_TCPSocketAction_To_v1_TCPSocketAction(*in, *out, s); err != nil {
return err
}
} else {
@@ -1083,10 +2320,16 @@ func Convert_api_Handler_To_v1_Handler(in *api.Handler, out *Handler, s conversi
return autoConvert_api_Handler_To_v1_Handler(in, out, s)
}
+func autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
+ out.Path = in.Path
+ return nil
+}
+
+func Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in, out, s)
+}
+
func autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPathVolumeSource, out *HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.HostPathVolumeSource))(in)
- }
out.Path = in.Path
return nil
}
@@ -1095,13 +2338,25 @@ func Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *api.HostPat
return autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in, out, s)
}
+func autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
+ SetDefaults_ISCSIVolumeSource(in)
+ out.TargetPortal = in.TargetPortal
+ out.IQN = in.IQN
+ out.Lun = in.Lun
+ out.ISCSIInterface = in.ISCSIInterface
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in, out, s)
+}
+
func autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSource, out *ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ISCSIVolumeSource))(in)
- }
out.TargetPortal = in.TargetPortal
out.IQN = in.IQN
- out.Lun = int32(in.Lun)
+ out.Lun = in.Lun
out.ISCSIInterface = in.ISCSIInterface
out.FSType = in.FSType
out.ReadOnly = in.ReadOnly
@@ -1112,10 +2367,17 @@ func Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *api.ISCSIVolumeSo
return autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in, out, s)
}
+func autoConvert_v1_KeyToPath_To_api_KeyToPath(in *KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Path = in.Path
+ return nil
+}
+
+func Convert_v1_KeyToPath_To_api_KeyToPath(in *KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
+ return autoConvert_v1_KeyToPath_To_api_KeyToPath(in, out, s)
+}
+
func autoConvert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.KeyToPath))(in)
- }
out.Key = in.Key
out.Path = in.Path
return nil
@@ -1125,23 +2387,46 @@ func Convert_api_KeyToPath_To_v1_KeyToPath(in *api.KeyToPath, out *KeyToPath, s
return autoConvert_api_KeyToPath_To_v1_KeyToPath(in, out, s)
}
-func autoConvert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Lifecycle))(in)
+func autoConvert_v1_Lifecycle_To_api_Lifecycle(in *Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
+ if in.PostStart != nil {
+ in, out := &in.PostStart, &out.PostStart
+ *out = new(api.Handler)
+ if err := Convert_v1_Handler_To_api_Handler(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PostStart = nil
+ }
+ if in.PreStop != nil {
+ in, out := &in.PreStop, &out.PreStop
+ *out = new(api.Handler)
+ if err := Convert_v1_Handler_To_api_Handler(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PreStop = nil
}
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
+ return nil
+}
+
+func Convert_v1_Lifecycle_To_api_Lifecycle(in *Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
+ return autoConvert_v1_Lifecycle_To_api_Lifecycle(in, out, s)
+}
+
+func autoConvert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *Lifecycle, s conversion.Scope) error {
if in.PostStart != nil {
- out.PostStart = new(Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PostStart, out.PostStart, s); err != nil {
+ in, out := &in.PostStart, &out.PostStart
+ *out = new(Handler)
+ if err := Convert_api_Handler_To_v1_Handler(*in, *out, s); err != nil {
return err
}
} else {
out.PostStart = nil
}
- // unable to generate simple pointer conversion for api.Handler -> v1.Handler
if in.PreStop != nil {
- out.PreStop = new(Handler)
- if err := Convert_api_Handler_To_v1_Handler(in.PreStop, out.PreStop, s); err != nil {
+ in, out := &in.PreStop, &out.PreStop
+ *out = new(Handler)
+ if err := Convert_api_Handler_To_v1_Handler(*in, *out, s); err != nil {
return err
}
} else {
@@ -1154,9 +2439,26 @@ func Convert_api_Lifecycle_To_v1_Lifecycle(in *api.Lifecycle, out *Lifecycle, s
return autoConvert_api_Lifecycle_To_v1_Lifecycle(in, out, s)
}
-func autoConvert_api_LimitRange_To_v1_LimitRange(in *api.LimitRange, out *LimitRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LimitRange))(in)
+func autoConvert_v1_LimitRange_To_api_LimitRange(in *LimitRange, out *api.LimitRange, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_LimitRangeSpec_To_api_LimitRangeSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_LimitRange_To_api_LimitRange(in *LimitRange, out *api.LimitRange, s conversion.Scope) error {
+ return autoConvert_v1_LimitRange_To_api_LimitRange(in, out, s)
+}
+
+func autoConvert_api_LimitRange_To_v1_LimitRange(in *api.LimitRange, out *LimitRange, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -1171,67 +2473,94 @@ func Convert_api_LimitRange_To_v1_LimitRange(in *api.LimitRange, out *LimitRange
return autoConvert_api_LimitRange_To_v1_LimitRange(in, out, s)
}
-func autoConvert_api_LimitRangeItem_To_v1_LimitRangeItem(in *api.LimitRangeItem, out *LimitRangeItem, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LimitRangeItem))(in)
+func autoConvert_v1_LimitRangeItem_To_api_LimitRangeItem(in *LimitRangeItem, out *api.LimitRangeItem, s conversion.Scope) error {
+ SetDefaults_LimitRangeItem(in)
+ out.Type = api.LimitType(in.Type)
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Max, &out.Max, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Min, &out.Min, s); err != nil {
+ return err
}
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Default, &out.Default, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.DefaultRequest, &out.DefaultRequest, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_LimitRangeItem_To_api_LimitRangeItem(in *LimitRangeItem, out *api.LimitRangeItem, s conversion.Scope) error {
+ return autoConvert_v1_LimitRangeItem_To_api_LimitRangeItem(in, out, s)
+}
+
+func autoConvert_api_LimitRangeItem_To_v1_LimitRangeItem(in *api.LimitRangeItem, out *LimitRangeItem, s conversion.Scope) error {
out.Type = LimitType(in.Type)
if in.Max != nil {
- out.Max = make(ResourceList)
- for key, val := range in.Max {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Max, &out.Max
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Max[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Max = nil
}
if in.Min != nil {
- out.Min = make(ResourceList)
- for key, val := range in.Min {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Min, &out.Min
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Min[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Min = nil
}
if in.Default != nil {
- out.Default = make(ResourceList)
- for key, val := range in.Default {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Default, &out.Default
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Default[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Default = nil
}
if in.DefaultRequest != nil {
- out.DefaultRequest = make(ResourceList)
- for key, val := range in.DefaultRequest {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.DefaultRequest, &out.DefaultRequest
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.DefaultRequest[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.DefaultRequest = nil
}
if in.MaxLimitRequestRatio != nil {
- out.MaxLimitRequestRatio = make(ResourceList)
- for key, val := range in.MaxLimitRequestRatio {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.MaxLimitRequestRatio[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.MaxLimitRequestRatio = nil
@@ -1243,17 +2572,43 @@ func Convert_api_LimitRangeItem_To_v1_LimitRangeItem(in *api.LimitRangeItem, out
return autoConvert_api_LimitRangeItem_To_v1_LimitRangeItem(in, out, s)
}
+func autoConvert_v1_LimitRangeList_To_api_LimitRangeList(in *LimitRangeList, out *api.LimitRangeList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.LimitRange, len(*in))
+ for i := range *in {
+ if err := Convert_v1_LimitRange_To_api_LimitRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_LimitRangeList_To_api_LimitRangeList(in *LimitRangeList, out *api.LimitRangeList, s conversion.Scope) error {
+ return autoConvert_v1_LimitRangeList_To_api_LimitRangeList(in, out, s)
+}
+
func autoConvert_api_LimitRangeList_To_v1_LimitRangeList(in *api.LimitRangeList, out *LimitRangeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LimitRangeList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]LimitRange, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_LimitRange_To_v1_LimitRange(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]LimitRange, len(*in))
+ for i := range *in {
+ if err := Convert_api_LimitRange_To_v1_LimitRange(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1267,14 +2622,31 @@ func Convert_api_LimitRangeList_To_v1_LimitRangeList(in *api.LimitRangeList, out
return autoConvert_api_LimitRangeList_To_v1_LimitRangeList(in, out, s)
}
-func autoConvert_api_LimitRangeSpec_To_v1_LimitRangeSpec(in *api.LimitRangeSpec, out *LimitRangeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LimitRangeSpec))(in)
+func autoConvert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in *LimitRangeSpec, out *api.LimitRangeSpec, s conversion.Scope) error {
+ if in.Limits != nil {
+ in, out := &in.Limits, &out.Limits
+ *out = make([]api.LimitRangeItem, len(*in))
+ for i := range *in {
+ if err := Convert_v1_LimitRangeItem_To_api_LimitRangeItem(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Limits = nil
}
+ return nil
+}
+
+func Convert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in *LimitRangeSpec, out *api.LimitRangeSpec, s conversion.Scope) error {
+ return autoConvert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in, out, s)
+}
+
+func autoConvert_api_LimitRangeSpec_To_v1_LimitRangeSpec(in *api.LimitRangeSpec, out *LimitRangeSpec, s conversion.Scope) error {
if in.Limits != nil {
- out.Limits = make([]LimitRangeItem, len(in.Limits))
- for i := range in.Limits {
- if err := Convert_api_LimitRangeItem_To_v1_LimitRangeItem(&in.Limits[i], &out.Limits[i], s); err != nil {
+ in, out := &in.Limits, &out.Limits
+ *out = make([]LimitRangeItem, len(*in))
+ for i := range *in {
+ if err := Convert_api_LimitRangeItem_To_v1_LimitRangeItem(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1288,17 +2660,43 @@ func Convert_api_LimitRangeSpec_To_v1_LimitRangeSpec(in *api.LimitRangeSpec, out
return autoConvert_api_LimitRangeSpec_To_v1_LimitRangeSpec(in, out, s)
}
+func autoConvert_v1_List_To_api_List(in *List, out *api.List, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]runtime.Object, len(*in))
+ for i := range *in {
+ if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_List_To_api_List(in *List, out *api.List, s conversion.Scope) error {
+ return autoConvert_v1_List_To_api_List(in, out, s)
+}
+
func autoConvert_api_List_To_v1_List(in *api.List, out *List, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.List))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]runtime.RawExtension, len(in.Items))
- for i := range in.Items {
- if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]runtime.RawExtension, len(*in))
+ for i := range *in {
+ if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1312,9 +2710,29 @@ func Convert_api_List_To_v1_List(in *api.List, out *List, s conversion.Scope) er
return autoConvert_api_List_To_v1_List(in, out, s)
}
+func autoConvert_v1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_string_To_labels_Selector(&in.LabelSelector, &out.LabelSelector, s); err != nil {
+ return err
+ }
+ if err := api.Convert_string_To_fields_Selector(&in.FieldSelector, &out.FieldSelector, s); err != nil {
+ return err
+ }
+ out.Watch = in.Watch
+ out.ResourceVersion = in.ResourceVersion
+ out.TimeoutSeconds = in.TimeoutSeconds
+ return nil
+}
+
+func Convert_v1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
+ return autoConvert_v1_ListOptions_To_api_ListOptions(in, out, s)
+}
+
func autoConvert_api_ListOptions_To_v1_ListOptions(in *api.ListOptions, out *ListOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ListOptions))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_labels_Selector_To_string(&in.LabelSelector, &out.LabelSelector, s); err != nil {
return err
@@ -1324,12 +2742,7 @@ func autoConvert_api_ListOptions_To_v1_ListOptions(in *api.ListOptions, out *Lis
}
out.Watch = in.Watch
out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
+ out.TimeoutSeconds = in.TimeoutSeconds
return nil
}
@@ -1337,10 +2750,17 @@ func Convert_api_ListOptions_To_v1_ListOptions(in *api.ListOptions, out *ListOpt
return autoConvert_api_ListOptions_To_v1_ListOptions(in, out, s)
}
+func autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
+ out.IP = in.IP
+ out.Hostname = in.Hostname
+ return nil
+}
+
+func Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
+ return autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in, out, s)
+}
+
func autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *api.LoadBalancerIngress, out *LoadBalancerIngress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LoadBalancerIngress))(in)
- }
out.IP = in.IP
out.Hostname = in.Hostname
return nil
@@ -1350,14 +2770,31 @@ func Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *api.LoadBalan
return autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(in, out, s)
}
-func autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *api.LoadBalancerStatus, out *LoadBalancerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LoadBalancerStatus))(in)
+func autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
+ if in.Ingress != nil {
+ in, out := &in.Ingress, &out.Ingress
+ *out = make([]api.LoadBalancerIngress, len(*in))
+ for i := range *in {
+ if err := Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
}
+ return nil
+}
+
+func Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
+ return autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in, out, s)
+}
+
+func autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *api.LoadBalancerStatus, out *LoadBalancerStatus, s conversion.Scope) error {
if in.Ingress != nil {
- out.Ingress = make([]LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
+ in, out := &in.Ingress, &out.Ingress
+ *out = make([]LoadBalancerIngress, len(*in))
+ for i := range *in {
+ if err := Convert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1371,10 +2808,16 @@ func Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *api.LoadBalance
return autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(in, out, s)
}
+func autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in *LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
+ out.Name = in.Name
+ return nil
+}
+
+func Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in *LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
+ return autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in, out, s)
+}
+
func autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalObjectReference, out *LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.LocalObjectReference))(in)
- }
out.Name = in.Name
return nil
}
@@ -1383,10 +2826,18 @@ func Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in *api.LocalOb
return autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference(in, out, s)
}
+func autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
+ out.Server = in.Server
+ out.Path = in.Path
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in, out, s)
+}
+
func autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource, out *NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NFSVolumeSource))(in)
- }
out.Server = in.Server
out.Path = in.Path
out.ReadOnly = in.ReadOnly
@@ -1397,9 +2848,29 @@ func Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in *api.NFSVolumeSource,
return autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in, out, s)
}
+func autoConvert_v1_Namespace_To_api_Namespace(in *Namespace, out *api.Namespace, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_NamespaceSpec_To_api_NamespaceSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_NamespaceStatus_To_api_NamespaceStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_Namespace_To_api_Namespace(in *Namespace, out *api.Namespace, s conversion.Scope) error {
+ return autoConvert_v1_Namespace_To_api_Namespace(in, out, s)
+}
+
func autoConvert_api_Namespace_To_v1_Namespace(in *api.Namespace, out *Namespace, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Namespace))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -1417,17 +2888,43 @@ func Convert_api_Namespace_To_v1_Namespace(in *api.Namespace, out *Namespace, s
return autoConvert_api_Namespace_To_v1_Namespace(in, out, s)
}
+func autoConvert_v1_NamespaceList_To_api_NamespaceList(in *NamespaceList, out *api.NamespaceList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Namespace, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Namespace_To_api_Namespace(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_NamespaceList_To_api_NamespaceList(in *NamespaceList, out *api.NamespaceList, s conversion.Scope) error {
+ return autoConvert_v1_NamespaceList_To_api_NamespaceList(in, out, s)
+}
+
func autoConvert_api_NamespaceList_To_v1_NamespaceList(in *api.NamespaceList, out *NamespaceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NamespaceList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]Namespace, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Namespace_To_v1_Namespace(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Namespace, len(*in))
+ for i := range *in {
+ if err := Convert_api_Namespace_To_v1_Namespace(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1441,14 +2938,29 @@ func Convert_api_NamespaceList_To_v1_NamespaceList(in *api.NamespaceList, out *N
return autoConvert_api_NamespaceList_To_v1_NamespaceList(in, out, s)
}
-func autoConvert_api_NamespaceSpec_To_v1_NamespaceSpec(in *api.NamespaceSpec, out *NamespaceSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NamespaceSpec))(in)
+func autoConvert_v1_NamespaceSpec_To_api_NamespaceSpec(in *NamespaceSpec, out *api.NamespaceSpec, s conversion.Scope) error {
+ if in.Finalizers != nil {
+ in, out := &in.Finalizers, &out.Finalizers
+ *out = make([]api.FinalizerName, len(*in))
+ for i := range *in {
+ (*out)[i] = api.FinalizerName((*in)[i])
+ }
+ } else {
+ out.Finalizers = nil
}
+ return nil
+}
+
+func Convert_v1_NamespaceSpec_To_api_NamespaceSpec(in *NamespaceSpec, out *api.NamespaceSpec, s conversion.Scope) error {
+ return autoConvert_v1_NamespaceSpec_To_api_NamespaceSpec(in, out, s)
+}
+
+func autoConvert_api_NamespaceSpec_To_v1_NamespaceSpec(in *api.NamespaceSpec, out *NamespaceSpec, s conversion.Scope) error {
if in.Finalizers != nil {
- out.Finalizers = make([]FinalizerName, len(in.Finalizers))
- for i := range in.Finalizers {
- out.Finalizers[i] = FinalizerName(in.Finalizers[i])
+ in, out := &in.Finalizers, &out.Finalizers
+ *out = make([]FinalizerName, len(*in))
+ for i := range *in {
+ (*out)[i] = FinalizerName((*in)[i])
}
} else {
out.Finalizers = nil
@@ -1460,10 +2972,17 @@ func Convert_api_NamespaceSpec_To_v1_NamespaceSpec(in *api.NamespaceSpec, out *N
return autoConvert_api_NamespaceSpec_To_v1_NamespaceSpec(in, out, s)
}
+func autoConvert_v1_NamespaceStatus_To_api_NamespaceStatus(in *NamespaceStatus, out *api.NamespaceStatus, s conversion.Scope) error {
+ SetDefaults_NamespaceStatus(in)
+ out.Phase = api.NamespacePhase(in.Phase)
+ return nil
+}
+
+func Convert_v1_NamespaceStatus_To_api_NamespaceStatus(in *NamespaceStatus, out *api.NamespaceStatus, s conversion.Scope) error {
+ return autoConvert_v1_NamespaceStatus_To_api_NamespaceStatus(in, out, s)
+}
+
func autoConvert_api_NamespaceStatus_To_v1_NamespaceStatus(in *api.NamespaceStatus, out *NamespaceStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NamespaceStatus))(in)
- }
out.Phase = NamespacePhase(in.Phase)
return nil
}
@@ -1472,9 +2991,30 @@ func Convert_api_NamespaceStatus_To_v1_NamespaceStatus(in *api.NamespaceStatus,
return autoConvert_api_NamespaceStatus_To_v1_NamespaceStatus(in, out, s)
}
+func autoConvert_v1_Node_To_api_Node(in *Node, out *api.Node, s conversion.Scope) error {
+ SetDefaults_Node(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_NodeSpec_To_api_NodeSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_NodeStatus_To_api_NodeStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_Node_To_api_Node(in *Node, out *api.Node, s conversion.Scope) error {
+ return autoConvert_v1_Node_To_api_Node(in, out, s)
+}
+
func autoConvert_api_Node_To_v1_Node(in *api.Node, out *Node, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Node))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -1492,11 +3032,18 @@ func Convert_api_Node_To_v1_Node(in *api.Node, out *Node, s conversion.Scope) er
return autoConvert_api_Node_To_v1_Node(in, out, s)
}
-func autoConvert_api_NodeAddress_To_v1_NodeAddress(in *api.NodeAddress, out *NodeAddress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeAddress))(in)
- }
- out.Type = NodeAddressType(in.Type)
+func autoConvert_v1_NodeAddress_To_api_NodeAddress(in *NodeAddress, out *api.NodeAddress, s conversion.Scope) error {
+ out.Type = api.NodeAddressType(in.Type)
+ out.Address = in.Address
+ return nil
+}
+
+func Convert_v1_NodeAddress_To_api_NodeAddress(in *NodeAddress, out *api.NodeAddress, s conversion.Scope) error {
+ return autoConvert_v1_NodeAddress_To_api_NodeAddress(in, out, s)
+}
+
+func autoConvert_api_NodeAddress_To_v1_NodeAddress(in *api.NodeAddress, out *NodeAddress, s conversion.Scope) error {
+ out.Type = NodeAddressType(in.Type)
out.Address = in.Address
return nil
}
@@ -1505,10 +3052,81 @@ func Convert_api_NodeAddress_To_v1_NodeAddress(in *api.NodeAddress, out *NodeAdd
return autoConvert_api_NodeAddress_To_v1_NodeAddress(in, out, s)
}
-func autoConvert_api_NodeCondition_To_v1_NodeCondition(in *api.NodeCondition, out *NodeCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeCondition))(in)
+func autoConvert_v1_NodeAffinity_To_api_NodeAffinity(in *NodeAffinity, out *api.NodeAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = new(api.NodeSelector)
+ if err := Convert_v1_NodeSelector_To_api_NodeSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]api.PreferredSchedulingTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PreferredSchedulingTerm_To_api_PreferredSchedulingTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func Convert_v1_NodeAffinity_To_api_NodeAffinity(in *NodeAffinity, out *api.NodeAffinity, s conversion.Scope) error {
+ return autoConvert_v1_NodeAffinity_To_api_NodeAffinity(in, out, s)
+}
+
+func autoConvert_api_NodeAffinity_To_v1_NodeAffinity(in *api.NodeAffinity, out *NodeAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = new(NodeSelector)
+ if err := Convert_api_NodeSelector_To_v1_NodeSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PreferredSchedulingTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func Convert_api_NodeAffinity_To_v1_NodeAffinity(in *api.NodeAffinity, out *NodeAffinity, s conversion.Scope) error {
+ return autoConvert_api_NodeAffinity_To_v1_NodeAffinity(in, out, s)
+}
+
+func autoConvert_v1_NodeCondition_To_api_NodeCondition(in *NodeCondition, out *api.NodeCondition, s conversion.Scope) error {
+ out.Type = api.NodeConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastHeartbeatTime, &out.LastHeartbeatTime, s); err != nil {
+ return err
}
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v1_NodeCondition_To_api_NodeCondition(in *NodeCondition, out *api.NodeCondition, s conversion.Scope) error {
+ return autoConvert_v1_NodeCondition_To_api_NodeCondition(in, out, s)
+}
+
+func autoConvert_api_NodeCondition_To_v1_NodeCondition(in *api.NodeCondition, out *NodeCondition, s conversion.Scope) error {
out.Type = NodeConditionType(in.Type)
out.Status = ConditionStatus(in.Status)
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastHeartbeatTime, &out.LastHeartbeatTime, s); err != nil {
@@ -1526,10 +3144,18 @@ func Convert_api_NodeCondition_To_v1_NodeCondition(in *api.NodeCondition, out *N
return autoConvert_api_NodeCondition_To_v1_NodeCondition(in, out, s)
}
-func autoConvert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in *api.NodeDaemonEndpoints, out *NodeDaemonEndpoints, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeDaemonEndpoints))(in)
+func autoConvert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in *NodeDaemonEndpoints, out *api.NodeDaemonEndpoints, s conversion.Scope) error {
+ if err := Convert_v1_DaemonEndpoint_To_api_DaemonEndpoint(&in.KubeletEndpoint, &out.KubeletEndpoint, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in *NodeDaemonEndpoints, out *api.NodeDaemonEndpoints, s conversion.Scope) error {
+ return autoConvert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in, out, s)
+}
+
+func autoConvert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in *api.NodeDaemonEndpoints, out *NodeDaemonEndpoints, s conversion.Scope) error {
if err := Convert_api_DaemonEndpoint_To_v1_DaemonEndpoint(&in.KubeletEndpoint, &out.KubeletEndpoint, s); err != nil {
return err
}
@@ -1540,17 +3166,43 @@ func Convert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in *api.NodeDaemo
return autoConvert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in, out, s)
}
+func autoConvert_v1_NodeList_To_api_NodeList(in *NodeList, out *api.NodeList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Node, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Node_To_api_Node(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_NodeList_To_api_NodeList(in *NodeList, out *api.NodeList, s conversion.Scope) error {
+ return autoConvert_v1_NodeList_To_api_NodeList(in, out, s)
+}
+
func autoConvert_api_NodeList_To_v1_NodeList(in *api.NodeList, out *NodeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]Node, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Node_To_v1_Node(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Node, len(*in))
+ for i := range *in {
+ if err := Convert_api_Node_To_v1_Node(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1564,9 +3216,21 @@ func Convert_api_NodeList_To_v1_NodeList(in *api.NodeList, out *NodeList, s conv
return autoConvert_api_NodeList_To_v1_NodeList(in, out, s)
}
+func autoConvert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in *NodeProxyOptions, out *api.NodeProxyOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func Convert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in *NodeProxyOptions, out *api.NodeProxyOptions, s conversion.Scope) error {
+ return autoConvert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in, out, s)
+}
+
func autoConvert_api_NodeProxyOptions_To_v1_NodeProxyOptions(in *api.NodeProxyOptions, out *NodeProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeProxyOptions))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
out.Path = in.Path
return nil
@@ -1576,10 +3240,117 @@ func Convert_api_NodeProxyOptions_To_v1_NodeProxyOptions(in *api.NodeProxyOption
return autoConvert_api_NodeProxyOptions_To_v1_NodeProxyOptions(in, out, s)
}
-func autoConvert_api_NodeSpec_To_v1_NodeSpec(in *api.NodeSpec, out *NodeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeSpec))(in)
+func autoConvert_v1_NodeSelector_To_api_NodeSelector(in *NodeSelector, out *api.NodeSelector, s conversion.Scope) error {
+ if in.NodeSelectorTerms != nil {
+ in, out := &in.NodeSelectorTerms, &out.NodeSelectorTerms
+ *out = make([]api.NodeSelectorTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.NodeSelectorTerms = nil
+ }
+ return nil
+}
+
+func Convert_v1_NodeSelector_To_api_NodeSelector(in *NodeSelector, out *api.NodeSelector, s conversion.Scope) error {
+ return autoConvert_v1_NodeSelector_To_api_NodeSelector(in, out, s)
+}
+
+func autoConvert_api_NodeSelector_To_v1_NodeSelector(in *api.NodeSelector, out *NodeSelector, s conversion.Scope) error {
+ if in.NodeSelectorTerms != nil {
+ in, out := &in.NodeSelectorTerms, &out.NodeSelectorTerms
+ *out = make([]NodeSelectorTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.NodeSelectorTerms = nil
+ }
+ return nil
+}
+
+func Convert_api_NodeSelector_To_v1_NodeSelector(in *api.NodeSelector, out *NodeSelector, s conversion.Scope) error {
+ return autoConvert_api_NodeSelector_To_v1_NodeSelector(in, out, s)
+}
+
+func autoConvert_v1_NodeSelectorRequirement_To_api_NodeSelectorRequirement(in *NodeSelectorRequirement, out *api.NodeSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = api.NodeSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_v1_NodeSelectorRequirement_To_api_NodeSelectorRequirement(in *NodeSelectorRequirement, out *api.NodeSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_v1_NodeSelectorRequirement_To_api_NodeSelectorRequirement(in, out, s)
+}
+
+func autoConvert_api_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in *api.NodeSelectorRequirement, out *NodeSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = NodeSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_api_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in *api.NodeSelectorRequirement, out *NodeSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_api_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in, out, s)
+}
+
+func autoConvert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm(in *NodeSelectorTerm, out *api.NodeSelectorTerm, s conversion.Scope) error {
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]api.NodeSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_v1_NodeSelectorRequirement_To_api_NodeSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm(in *NodeSelectorTerm, out *api.NodeSelectorTerm, s conversion.Scope) error {
+ return autoConvert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm(in, out, s)
+}
+
+func autoConvert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm(in *api.NodeSelectorTerm, out *NodeSelectorTerm, s conversion.Scope) error {
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]NodeSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_api_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
}
+ return nil
+}
+
+func Convert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm(in *api.NodeSelectorTerm, out *NodeSelectorTerm, s conversion.Scope) error {
+ return autoConvert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm(in, out, s)
+}
+
+func autoConvert_v1_NodeSpec_To_api_NodeSpec(in *NodeSpec, out *api.NodeSpec, s conversion.Scope) error {
+ out.PodCIDR = in.PodCIDR
+ out.ExternalID = in.ExternalID
+ out.ProviderID = in.ProviderID
+ out.Unschedulable = in.Unschedulable
+ return nil
+}
+
+func Convert_v1_NodeSpec_To_api_NodeSpec(in *NodeSpec, out *api.NodeSpec, s conversion.Scope) error {
+ return autoConvert_v1_NodeSpec_To_api_NodeSpec(in, out, s)
+}
+
+func autoConvert_api_NodeSpec_To_v1_NodeSpec(in *api.NodeSpec, out *NodeSpec, s conversion.Scope) error {
out.PodCIDR = in.PodCIDR
out.ExternalID = in.ExternalID
out.ProviderID = in.ProviderID
@@ -1591,39 +3362,114 @@ func Convert_api_NodeSpec_To_v1_NodeSpec(in *api.NodeSpec, out *NodeSpec, s conv
return autoConvert_api_NodeSpec_To_v1_NodeSpec(in, out, s)
}
-func autoConvert_api_NodeStatus_To_v1_NodeStatus(in *api.NodeStatus, out *NodeStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeStatus))(in)
+func autoConvert_v1_NodeStatus_To_api_NodeStatus(in *NodeStatus, out *api.NodeStatus, s conversion.Scope) error {
+ SetDefaults_NodeStatus(in)
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Capacity, &out.Capacity, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Allocatable, &out.Allocatable, s); err != nil {
+ return err
+ }
+ out.Phase = api.NodePhase(in.Phase)
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]api.NodeCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1_NodeCondition_To_api_NodeCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.Addresses != nil {
+ in, out := &in.Addresses, &out.Addresses
+ *out = make([]api.NodeAddress, len(*in))
+ for i := range *in {
+ if err := Convert_v1_NodeAddress_To_api_NodeAddress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Addresses = nil
+ }
+ if err := Convert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(&in.DaemonEndpoints, &out.DaemonEndpoints, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_NodeSystemInfo_To_api_NodeSystemInfo(&in.NodeInfo, &out.NodeInfo, s); err != nil {
+ return err
+ }
+ if in.Images != nil {
+ in, out := &in.Images, &out.Images
+ *out = make([]api.ContainerImage, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ContainerImage_To_api_ContainerImage(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Images = nil
+ }
+ if in.VolumesInUse != nil {
+ in, out := &in.VolumesInUse, &out.VolumesInUse
+ *out = make([]api.UniqueVolumeName, len(*in))
+ for i := range *in {
+ (*out)[i] = api.UniqueVolumeName((*in)[i])
+ }
+ } else {
+ out.VolumesInUse = nil
+ }
+ if in.VolumesAttached != nil {
+ in, out := &in.VolumesAttached, &out.VolumesAttached
+ *out = make([]api.AttachedVolume, len(*in))
+ for i := range *in {
+ if err := Convert_v1_AttachedVolume_To_api_AttachedVolume(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumesAttached = nil
}
+ return nil
+}
+
+func Convert_v1_NodeStatus_To_api_NodeStatus(in *NodeStatus, out *api.NodeStatus, s conversion.Scope) error {
+ return autoConvert_v1_NodeStatus_To_api_NodeStatus(in, out, s)
+}
+
+func autoConvert_api_NodeStatus_To_v1_NodeStatus(in *api.NodeStatus, out *NodeStatus, s conversion.Scope) error {
if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Capacity, &out.Capacity
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Capacity[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Capacity = nil
}
if in.Allocatable != nil {
- out.Allocatable = make(ResourceList)
- for key, val := range in.Allocatable {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Allocatable, &out.Allocatable
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Allocatable[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Allocatable = nil
}
out.Phase = NodePhase(in.Phase)
if in.Conditions != nil {
- out.Conditions = make([]NodeCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_api_NodeCondition_To_v1_NodeCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]NodeCondition, len(*in))
+ for i := range *in {
+ if err := Convert_api_NodeCondition_To_v1_NodeCondition(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1631,9 +3477,10 @@ func autoConvert_api_NodeStatus_To_v1_NodeStatus(in *api.NodeStatus, out *NodeSt
out.Conditions = nil
}
if in.Addresses != nil {
- out.Addresses = make([]NodeAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := Convert_api_NodeAddress_To_v1_NodeAddress(&in.Addresses[i], &out.Addresses[i], s); err != nil {
+ in, out := &in.Addresses, &out.Addresses
+ *out = make([]NodeAddress, len(*in))
+ for i := range *in {
+ if err := Convert_api_NodeAddress_To_v1_NodeAddress(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1647,15 +3494,36 @@ func autoConvert_api_NodeStatus_To_v1_NodeStatus(in *api.NodeStatus, out *NodeSt
return err
}
if in.Images != nil {
- out.Images = make([]ContainerImage, len(in.Images))
- for i := range in.Images {
- if err := Convert_api_ContainerImage_To_v1_ContainerImage(&in.Images[i], &out.Images[i], s); err != nil {
+ in, out := &in.Images, &out.Images
+ *out = make([]ContainerImage, len(*in))
+ for i := range *in {
+ if err := Convert_api_ContainerImage_To_v1_ContainerImage(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
out.Images = nil
}
+ if in.VolumesInUse != nil {
+ in, out := &in.VolumesInUse, &out.VolumesInUse
+ *out = make([]UniqueVolumeName, len(*in))
+ for i := range *in {
+ (*out)[i] = UniqueVolumeName((*in)[i])
+ }
+ } else {
+ out.VolumesInUse = nil
+ }
+ if in.VolumesAttached != nil {
+ in, out := &in.VolumesAttached, &out.VolumesAttached
+ *out = make([]AttachedVolume, len(*in))
+ for i := range *in {
+ if err := Convert_api_AttachedVolume_To_v1_AttachedVolume(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumesAttached = nil
+ }
return nil
}
@@ -1663,10 +3531,25 @@ func Convert_api_NodeStatus_To_v1_NodeStatus(in *api.NodeStatus, out *NodeStatus
return autoConvert_api_NodeStatus_To_v1_NodeStatus(in, out, s)
}
+func autoConvert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in *NodeSystemInfo, out *api.NodeSystemInfo, s conversion.Scope) error {
+ out.MachineID = in.MachineID
+ out.SystemUUID = in.SystemUUID
+ out.BootID = in.BootID
+ out.KernelVersion = in.KernelVersion
+ out.OSImage = in.OSImage
+ out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
+ out.KubeletVersion = in.KubeletVersion
+ out.KubeProxyVersion = in.KubeProxyVersion
+ out.OperatingSystem = in.OperatingSystem
+ out.Architecture = in.Architecture
+ return nil
+}
+
+func Convert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in *NodeSystemInfo, out *api.NodeSystemInfo, s conversion.Scope) error {
+ return autoConvert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in, out, s)
+}
+
func autoConvert_api_NodeSystemInfo_To_v1_NodeSystemInfo(in *api.NodeSystemInfo, out *NodeSystemInfo, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.NodeSystemInfo))(in)
- }
out.MachineID = in.MachineID
out.SystemUUID = in.SystemUUID
out.BootID = in.BootID
@@ -1675,6 +3558,8 @@ func autoConvert_api_NodeSystemInfo_To_v1_NodeSystemInfo(in *api.NodeSystemInfo,
out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
out.KubeletVersion = in.KubeletVersion
out.KubeProxyVersion = in.KubeProxyVersion
+ out.OperatingSystem = in.OperatingSystem
+ out.Architecture = in.Architecture
return nil
}
@@ -1682,10 +3567,18 @@ func Convert_api_NodeSystemInfo_To_v1_NodeSystemInfo(in *api.NodeSystemInfo, out
return autoConvert_api_NodeSystemInfo_To_v1_NodeSystemInfo(in, out, s)
}
+func autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
+ SetDefaults_ObjectFieldSelector(in)
+ out.APIVersion = in.APIVersion
+ out.FieldPath = in.FieldPath
+ return nil
+}
+
+func Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
+ return autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in, out, s)
+}
+
func autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFieldSelector, out *ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectFieldSelector))(in)
- }
out.APIVersion = in.APIVersion
out.FieldPath = in.FieldPath
return nil
@@ -1695,10 +3588,7 @@ func Convert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *api.ObjectFie
return autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector(in, out, s)
}
-func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectMeta))(in)
- }
+func autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in *ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
out.Name = in.Name
out.GenerateName = in.GenerateName
out.Namespace = in.Namespace
@@ -1709,37 +3599,56 @@ func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *Object
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
return err
}
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
+ out.DeletionTimestamp = in.DeletionTimestamp
+ out.DeletionGracePeriodSeconds = in.DeletionGracePeriodSeconds
+ out.Labels = in.Labels
+ out.Annotations = in.Annotations
+ if in.OwnerReferences != nil {
+ in, out := &in.OwnerReferences, &out.OwnerReferences
+ *out = make([]api.OwnerReference, len(*in))
+ for i := range *in {
+ if err := Convert_v1_OwnerReference_To_api_OwnerReference(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.DeletionTimestamp = nil
- }
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
+ out.OwnerReferences = nil
}
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
- }
- } else {
- out.Labels = nil
+ out.Finalizers = in.Finalizers
+ return nil
+}
+
+func Convert_v1_ObjectMeta_To_api_ObjectMeta(in *ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
+ return autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in, out, s)
+}
+
+func autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *ObjectMeta, s conversion.Scope) error {
+ out.Name = in.Name
+ out.GenerateName = in.GenerateName
+ out.Namespace = in.Namespace
+ out.SelfLink = in.SelfLink
+ out.UID = in.UID
+ out.ResourceVersion = in.ResourceVersion
+ out.Generation = in.Generation
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
+ return err
}
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
+ out.DeletionTimestamp = in.DeletionTimestamp
+ out.DeletionGracePeriodSeconds = in.DeletionGracePeriodSeconds
+ out.Labels = in.Labels
+ out.Annotations = in.Annotations
+ if in.OwnerReferences != nil {
+ in, out := &in.OwnerReferences, &out.OwnerReferences
+ *out = make([]OwnerReference, len(*in))
+ for i := range *in {
+ if err := Convert_api_OwnerReference_To_v1_OwnerReference(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.Annotations = nil
+ out.OwnerReferences = nil
}
+ out.Finalizers = in.Finalizers
return nil
}
@@ -1747,10 +3656,22 @@ func Convert_api_ObjectMeta_To_v1_ObjectMeta(in *api.ObjectMeta, out *ObjectMeta
return autoConvert_api_ObjectMeta_To_v1_ObjectMeta(in, out, s)
}
+func autoConvert_v1_ObjectReference_To_api_ObjectReference(in *ObjectReference, out *api.ObjectReference, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.Namespace = in.Namespace
+ out.Name = in.Name
+ out.UID = in.UID
+ out.APIVersion = in.APIVersion
+ out.ResourceVersion = in.ResourceVersion
+ out.FieldPath = in.FieldPath
+ return nil
+}
+
+func Convert_v1_ObjectReference_To_api_ObjectReference(in *ObjectReference, out *api.ObjectReference, s conversion.Scope) error {
+ return autoConvert_v1_ObjectReference_To_api_ObjectReference(in, out, s)
+}
+
func autoConvert_api_ObjectReference_To_v1_ObjectReference(in *api.ObjectReference, out *ObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ObjectReference))(in)
- }
out.Kind = in.Kind
out.Namespace = in.Namespace
out.Name = in.Name
@@ -1765,9 +3686,56 @@ func Convert_api_ObjectReference_To_v1_ObjectReference(in *api.ObjectReference,
return autoConvert_api_ObjectReference_To_v1_ObjectReference(in, out, s)
}
+func autoConvert_v1_OwnerReference_To_api_OwnerReference(in *OwnerReference, out *api.OwnerReference, s conversion.Scope) error {
+ out.APIVersion = in.APIVersion
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.UID = in.UID
+ out.Controller = in.Controller
+ return nil
+}
+
+func Convert_v1_OwnerReference_To_api_OwnerReference(in *OwnerReference, out *api.OwnerReference, s conversion.Scope) error {
+ return autoConvert_v1_OwnerReference_To_api_OwnerReference(in, out, s)
+}
+
+func autoConvert_api_OwnerReference_To_v1_OwnerReference(in *api.OwnerReference, out *OwnerReference, s conversion.Scope) error {
+ out.APIVersion = in.APIVersion
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.UID = in.UID
+ out.Controller = in.Controller
+ return nil
+}
+
+func Convert_api_OwnerReference_To_v1_OwnerReference(in *api.OwnerReference, out *OwnerReference, s conversion.Scope) error {
+ return autoConvert_api_OwnerReference_To_v1_OwnerReference(in, out, s)
+}
+
+func autoConvert_v1_PersistentVolume_To_api_PersistentVolume(in *PersistentVolume, out *api.PersistentVolume, s conversion.Scope) error {
+ SetDefaults_PersistentVolume(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_PersistentVolume_To_api_PersistentVolume(in *PersistentVolume, out *api.PersistentVolume, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolume_To_api_PersistentVolume(in, out, s)
+}
+
func autoConvert_api_PersistentVolume_To_v1_PersistentVolume(in *api.PersistentVolume, out *PersistentVolume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolume))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -1785,9 +3753,30 @@ func Convert_api_PersistentVolume_To_v1_PersistentVolume(in *api.PersistentVolum
return autoConvert_api_PersistentVolume_To_v1_PersistentVolume(in, out, s)
}
+func autoConvert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in *PersistentVolumeClaim, out *api.PersistentVolumeClaim, s conversion.Scope) error {
+ SetDefaults_PersistentVolumeClaim(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in *PersistentVolumeClaim, out *api.PersistentVolumeClaim, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in, out, s)
+}
+
func autoConvert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in *api.PersistentVolumeClaim, out *PersistentVolumeClaim, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaim))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -1805,17 +3794,43 @@ func Convert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in *api.Persi
return autoConvert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in, out, s)
}
+func autoConvert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in *PersistentVolumeClaimList, out *api.PersistentVolumeClaimList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.PersistentVolumeClaim, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in *PersistentVolumeClaimList, out *api.PersistentVolumeClaimList, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in, out, s)
+}
+
func autoConvert_api_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in *api.PersistentVolumeClaimList, out *PersistentVolumeClaimList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]PersistentVolumeClaim, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PersistentVolumeClaim, len(*in))
+ for i := range *in {
+ if err := Convert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1829,18 +3844,39 @@ func Convert_api_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in *a
return autoConvert_api_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in, out, s)
}
-func autoConvert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in *api.PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimSpec))(in)
+func autoConvert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in *PersistentVolumeClaimSpec, out *api.PersistentVolumeClaimSpec, s conversion.Scope) error {
+ if in.AccessModes != nil {
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]api.PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = api.PersistentVolumeAccessMode((*in)[i])
+ }
+ } else {
+ out.AccessModes = nil
+ }
+ out.Selector = in.Selector
+ if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
+ return err
}
+ out.VolumeName = in.VolumeName
+ return nil
+}
+
+func Convert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in *PersistentVolumeClaimSpec, out *api.PersistentVolumeClaimSpec, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in, out, s)
+}
+
+func autoConvert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in *api.PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, s conversion.Scope) error {
if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = PersistentVolumeAccessMode(in.AccessModes[i])
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = PersistentVolumeAccessMode((*in)[i])
}
} else {
out.AccessModes = nil
}
+ out.Selector = in.Selector
if err := Convert_api_ResourceRequirements_To_v1_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
return err
}
@@ -1852,27 +3888,47 @@ func Convert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in *a
return autoConvert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in, out, s)
}
-func autoConvert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in *api.PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimStatus))(in)
+func autoConvert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in *PersistentVolumeClaimStatus, out *api.PersistentVolumeClaimStatus, s conversion.Scope) error {
+ out.Phase = api.PersistentVolumeClaimPhase(in.Phase)
+ if in.AccessModes != nil {
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]api.PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = api.PersistentVolumeAccessMode((*in)[i])
+ }
+ } else {
+ out.AccessModes = nil
+ }
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Capacity, &out.Capacity, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in *PersistentVolumeClaimStatus, out *api.PersistentVolumeClaimStatus, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in, out, s)
+}
+
+func autoConvert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in *api.PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, s conversion.Scope) error {
out.Phase = PersistentVolumeClaimPhase(in.Phase)
if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = PersistentVolumeAccessMode(in.AccessModes[i])
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = PersistentVolumeAccessMode((*in)[i])
}
} else {
out.AccessModes = nil
}
if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
+ in, out := &in.Capacity, &out.Capacity
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
}
- out.Capacity[ResourceName(key)] = newVal
+ (*out)[ResourceName(key)] = *newVal
}
} else {
out.Capacity = nil
@@ -1884,10 +3940,17 @@ func Convert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(i
return autoConvert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in, out, s)
}
+func autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
+ out.ClaimName = in.ClaimName
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in, out, s)
+}
+
func autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *api.PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeClaimVolumeSource))(in)
- }
out.ClaimName = in.ClaimName
out.ReadOnly = in.ReadOnly
return nil
@@ -1897,17 +3960,43 @@ func Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVo
return autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in, out, s)
}
+func autoConvert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in *PersistentVolumeList, out *api.PersistentVolumeList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.PersistentVolume, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PersistentVolume_To_api_PersistentVolume(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in *PersistentVolumeList, out *api.PersistentVolumeList, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in, out, s)
+}
+
func autoConvert_api_PersistentVolumeList_To_v1_PersistentVolumeList(in *api.PersistentVolumeList, out *PersistentVolumeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]PersistentVolume, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_PersistentVolume_To_v1_PersistentVolume(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PersistentVolume, len(*in))
+ for i := range *in {
+ if err := Convert_api_PersistentVolume_To_v1_PersistentVolume(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -1921,3448 +4010,567 @@ func Convert_api_PersistentVolumeList_To_v1_PersistentVolumeList(in *api.Persist
return autoConvert_api_PersistentVolumeList_To_v1_PersistentVolumeList(in, out, s)
}
-func autoConvert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *api.PersistentVolumeSource, out *PersistentVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeSource))(in)
- }
- // unable to generate simple pointer conversion for api.GCEPersistentDiskVolumeSource -> v1.GCEPersistentDiskVolumeSource
+func autoConvert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in *PersistentVolumeSource, out *api.PersistentVolumeSource, s conversion.Scope) error {
if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
- if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
+ in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(api.GCEPersistentDiskVolumeSource)
+ if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.GCEPersistentDisk = nil
}
- // unable to generate simple pointer conversion for api.AWSElasticBlockStoreVolumeSource -> v1.AWSElasticBlockStoreVolumeSource
if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
- if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
+ in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(api.AWSElasticBlockStoreVolumeSource)
+ if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.AWSElasticBlockStore = nil
}
- // unable to generate simple pointer conversion for api.HostPathVolumeSource -> v1.HostPathVolumeSource
if in.HostPath != nil {
- out.HostPath = new(HostPathVolumeSource)
- if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
+ in, out := &in.HostPath, &out.HostPath
+ *out = new(api.HostPathVolumeSource)
+ if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.HostPath = nil
}
- // unable to generate simple pointer conversion for api.GlusterfsVolumeSource -> v1.GlusterfsVolumeSource
if in.Glusterfs != nil {
- out.Glusterfs = new(GlusterfsVolumeSource)
- if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
+ in, out := &in.Glusterfs, &out.Glusterfs
+ *out = new(api.GlusterfsVolumeSource)
+ if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Glusterfs = nil
}
- // unable to generate simple pointer conversion for api.NFSVolumeSource -> v1.NFSVolumeSource
if in.NFS != nil {
- out.NFS = new(NFSVolumeSource)
- if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
+ in, out := &in.NFS, &out.NFS
+ *out = new(api.NFSVolumeSource)
+ if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.NFS = nil
}
- // unable to generate simple pointer conversion for api.RBDVolumeSource -> v1.RBDVolumeSource
if in.RBD != nil {
- out.RBD = new(RBDVolumeSource)
- if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
+ in, out := &in.RBD, &out.RBD
+ *out = new(api.RBDVolumeSource)
+ if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.RBD = nil
}
- // unable to generate simple pointer conversion for api.ISCSIVolumeSource -> v1.ISCSIVolumeSource
if in.ISCSI != nil {
- out.ISCSI = new(ISCSIVolumeSource)
- if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
+ in, out := &in.ISCSI, &out.ISCSI
+ *out = new(api.ISCSIVolumeSource)
+ if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.ISCSI = nil
}
- // unable to generate simple pointer conversion for api.FlexVolumeSource -> v1.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(FlexVolumeSource)
- if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for api.CinderVolumeSource -> v1.CinderVolumeSource
if in.Cinder != nil {
- out.Cinder = new(CinderVolumeSource)
- if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
+ in, out := &in.Cinder, &out.Cinder
+ *out = new(api.CinderVolumeSource)
+ if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Cinder = nil
}
- // unable to generate simple pointer conversion for api.CephFSVolumeSource -> v1.CephFSVolumeSource
if in.CephFS != nil {
- out.CephFS = new(CephFSVolumeSource)
- if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
+ in, out := &in.CephFS, &out.CephFS
+ *out = new(api.CephFSVolumeSource)
+ if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.CephFS = nil
}
- // unable to generate simple pointer conversion for api.FCVolumeSource -> v1.FCVolumeSource
if in.FC != nil {
- out.FC = new(FCVolumeSource)
- if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in.FC, out.FC, s); err != nil {
+ in, out := &in.FC, &out.FC
+ *out = new(api.FCVolumeSource)
+ if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.FC = nil
}
- // unable to generate simple pointer conversion for api.FlockerVolumeSource -> v1.FlockerVolumeSource
if in.Flocker != nil {
- out.Flocker = new(FlockerVolumeSource)
- if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
+ in, out := &in.Flocker, &out.Flocker
+ *out = new(api.FlockerVolumeSource)
+ if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Flocker = nil
}
- // unable to generate simple pointer conversion for api.AzureFileVolumeSource -> v1.AzureFileVolumeSource
+ if in.FlexVolume != nil {
+ in, out := &in.FlexVolume, &out.FlexVolume
+ *out = new(api.FlexVolumeSource)
+ if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FlexVolume = nil
+ }
if in.AzureFile != nil {
- out.AzureFile = new(AzureFileVolumeSource)
- if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
+ in, out := &in.AzureFile, &out.AzureFile
+ *out = new(api.AzureFileVolumeSource)
+ if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.AzureFile = nil
}
+ if in.VsphereVolume != nil {
+ in, out := &in.VsphereVolume, &out.VsphereVolume
+ *out = new(api.VsphereVirtualDiskVolumeSource)
+ if err := Convert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
return nil
}
-func Convert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *api.PersistentVolumeSource, out *PersistentVolumeSource, s conversion.Scope) error {
- return autoConvert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in, out, s)
+func Convert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in *PersistentVolumeSource, out *api.PersistentVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in, out, s)
}
-func autoConvert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *api.PersistentVolumeSpec, out *PersistentVolumeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeSpec))(in)
+func autoConvert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *api.PersistentVolumeSource, out *PersistentVolumeSource, s conversion.Scope) error {
+ if in.GCEPersistentDisk != nil {
+ in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(GCEPersistentDiskVolumeSource)
+ if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.GCEPersistentDisk = nil
}
- if in.Capacity != nil {
- out.Capacity = make(ResourceList)
- for key, val := range in.Capacity {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Capacity[ResourceName(key)] = newVal
+ if in.AWSElasticBlockStore != nil {
+ in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(AWSElasticBlockStoreVolumeSource)
+ if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Capacity = nil
+ out.AWSElasticBlockStore = nil
}
- if err := Convert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
- return err
+ if in.HostPath != nil {
+ in, out := &in.HostPath, &out.HostPath
+ *out = new(HostPathVolumeSource)
+ if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.HostPath = nil
}
- if in.AccessModes != nil {
- out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = PersistentVolumeAccessMode(in.AccessModes[i])
+ if in.Glusterfs != nil {
+ in, out := &in.Glusterfs, &out.Glusterfs
+ *out = new(GlusterfsVolumeSource)
+ if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.AccessModes = nil
+ out.Glusterfs = nil
}
- // unable to generate simple pointer conversion for api.ObjectReference -> v1.ObjectReference
- if in.ClaimRef != nil {
- out.ClaimRef = new(ObjectReference)
- if err := Convert_api_ObjectReference_To_v1_ObjectReference(in.ClaimRef, out.ClaimRef, s); err != nil {
+ if in.NFS != nil {
+ in, out := &in.NFS, &out.NFS
+ *out = new(NFSVolumeSource)
+ if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
- out.ClaimRef = nil
+ out.NFS = nil
}
- out.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
- return nil
-}
-
-func Convert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *api.PersistentVolumeSpec, out *PersistentVolumeSpec, s conversion.Scope) error {
- return autoConvert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in, out, s)
-}
-
-func autoConvert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *api.PersistentVolumeStatus, out *PersistentVolumeStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PersistentVolumeStatus))(in)
+ if in.RBD != nil {
+ in, out := &in.RBD, &out.RBD
+ *out = new(RBDVolumeSource)
+ if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RBD = nil
}
- out.Phase = PersistentVolumePhase(in.Phase)
- out.Message = in.Message
- out.Reason = in.Reason
- return nil
-}
-
-func Convert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *api.PersistentVolumeStatus, out *PersistentVolumeStatus, s conversion.Scope) error {
- return autoConvert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in, out, s)
-}
-
-func autoConvert_api_Pod_To_v1_Pod(in *api.Pod, out *Pod, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Pod))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_api_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func autoConvert_api_PodAttachOptions_To_v1_PodAttachOptions(in *api.PodAttachOptions, out *PodAttachOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodAttachOptions))(in)
- }
- out.Stdin = in.Stdin
- out.Stdout = in.Stdout
- out.Stderr = in.Stderr
- out.TTY = in.TTY
- out.Container = in.Container
- return nil
-}
-
-func Convert_api_PodAttachOptions_To_v1_PodAttachOptions(in *api.PodAttachOptions, out *PodAttachOptions, s conversion.Scope) error {
- return autoConvert_api_PodAttachOptions_To_v1_PodAttachOptions(in, out, s)
-}
-
-func autoConvert_api_PodCondition_To_v1_PodCondition(in *api.PodCondition, out *PodCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodCondition))(in)
- }
- out.Type = PodConditionType(in.Type)
- out.Status = ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_api_PodCondition_To_v1_PodCondition(in *api.PodCondition, out *PodCondition, s conversion.Scope) error {
- return autoConvert_api_PodCondition_To_v1_PodCondition(in, out, s)
-}
-
-func autoConvert_api_PodExecOptions_To_v1_PodExecOptions(in *api.PodExecOptions, out *PodExecOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodExecOptions))(in)
- }
- out.Stdin = in.Stdin
- out.Stdout = in.Stdout
- out.Stderr = in.Stderr
- out.TTY = in.TTY
- out.Container = in.Container
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_api_PodExecOptions_To_v1_PodExecOptions(in *api.PodExecOptions, out *PodExecOptions, s conversion.Scope) error {
- return autoConvert_api_PodExecOptions_To_v1_PodExecOptions(in, out, s)
-}
-
-func autoConvert_api_PodList_To_v1_PodList(in *api.PodList, out *PodList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Pod, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Pod_To_v1_Pod(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_PodList_To_v1_PodList(in *api.PodList, out *PodList, s conversion.Scope) error {
- return autoConvert_api_PodList_To_v1_PodList(in, out, s)
-}
-
-func autoConvert_api_PodLogOptions_To_v1_PodLogOptions(in *api.PodLogOptions, out *PodLogOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodLogOptions))(in)
- }
- out.Container = in.Container
- out.Follow = in.Follow
- out.Previous = in.Previous
- if in.SinceSeconds != nil {
- out.SinceSeconds = new(int64)
- *out.SinceSeconds = *in.SinceSeconds
- } else {
- out.SinceSeconds = nil
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.SinceTime != nil {
- out.SinceTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.SinceTime, out.SinceTime, s); err != nil {
+ if in.ISCSI != nil {
+ in, out := &in.ISCSI, &out.ISCSI
+ *out = new(ISCSIVolumeSource)
+ if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
- out.SinceTime = nil
- }
- out.Timestamps = in.Timestamps
- if in.TailLines != nil {
- out.TailLines = new(int64)
- *out.TailLines = *in.TailLines
- } else {
- out.TailLines = nil
- }
- if in.LimitBytes != nil {
- out.LimitBytes = new(int64)
- *out.LimitBytes = *in.LimitBytes
- } else {
- out.LimitBytes = nil
- }
- return nil
-}
-
-func Convert_api_PodLogOptions_To_v1_PodLogOptions(in *api.PodLogOptions, out *PodLogOptions, s conversion.Scope) error {
- return autoConvert_api_PodLogOptions_To_v1_PodLogOptions(in, out, s)
-}
-
-func autoConvert_api_PodProxyOptions_To_v1_PodProxyOptions(in *api.PodProxyOptions, out *PodProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodProxyOptions))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_PodProxyOptions_To_v1_PodProxyOptions(in *api.PodProxyOptions, out *PodProxyOptions, s conversion.Scope) error {
- return autoConvert_api_PodProxyOptions_To_v1_PodProxyOptions(in, out, s)
-}
-
-func autoConvert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodSpec))(in)
- }
- if in.Volumes != nil {
- out.Volumes = make([]Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_api_Volume_To_v1_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Volumes = nil
+ out.ISCSI = nil
}
- if in.Containers != nil {
- out.Containers = make([]Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_api_Container_To_v1_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
- return err
- }
+ if in.FlexVolume != nil {
+ in, out := &in.FlexVolume, &out.FlexVolume
+ *out = new(FlexVolumeSource)
+ if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Containers = nil
- }
- out.RestartPolicy = RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
+ out.FlexVolume = nil
}
- out.DNSPolicy = DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
+ if in.Cinder != nil {
+ in, out := &in.Cinder, &out.Cinder
+ *out = new(CinderVolumeSource)
+ if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.NodeSelector = nil
+ out.Cinder = nil
}
- out.ServiceAccountName = in.ServiceAccountName
- out.NodeName = in.NodeName
- // unable to generate simple pointer conversion for api.PodSecurityContext -> v1.PodSecurityContext
- if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
+ if in.CephFS != nil {
+ in, out := &in.CephFS, &out.CephFS
+ *out = new(CephFSVolumeSource)
+ if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
- out.SecurityContext = nil
+ out.CephFS = nil
}
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
+ if in.FC != nil {
+ in, out := &in.FC, &out.FC
+ *out = new(FCVolumeSource)
+ if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func autoConvert_api_PodStatus_To_v1_PodStatus(in *api.PodStatus, out *PodStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodStatus))(in)
+ out.FC = nil
}
- out.Phase = PodPhase(in.Phase)
- if in.Conditions != nil {
- out.Conditions = make([]PodCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_api_PodCondition_To_v1_PodCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
+ if in.Flocker != nil {
+ in, out := &in.Flocker, &out.Flocker
+ *out = new(FlockerVolumeSource)
+ if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Conditions = nil
+ out.Flocker = nil
}
- out.Message = in.Message
- out.Reason = in.Reason
- out.HostIP = in.HostIP
- out.PodIP = in.PodIP
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
+ if in.AzureFile != nil {
+ in, out := &in.AzureFile, &out.AzureFile
+ *out = new(AzureFileVolumeSource)
+ if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
- out.StartTime = nil
+ out.AzureFile = nil
}
- if in.ContainerStatuses != nil {
- out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses))
- for i := range in.ContainerStatuses {
- if err := Convert_api_ContainerStatus_To_v1_ContainerStatus(&in.ContainerStatuses[i], &out.ContainerStatuses[i], s); err != nil {
- return err
- }
+ if in.VsphereVolume != nil {
+ in, out := &in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := Convert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(*in, *out, s); err != nil {
+ return err
}
} else {
- out.ContainerStatuses = nil
- }
- return nil
-}
-
-func Convert_api_PodStatus_To_v1_PodStatus(in *api.PodStatus, out *PodStatus, s conversion.Scope) error {
- return autoConvert_api_PodStatus_To_v1_PodStatus(in, out, s)
-}
-
-func autoConvert_api_PodStatusResult_To_v1_PodStatusResult(in *api.PodStatusResult, out *PodStatusResult, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodStatusResult))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
- return err
+ out.VsphereVolume = nil
}
return nil
}
-func Convert_api_PodStatusResult_To_v1_PodStatusResult(in *api.PodStatusResult, out *PodStatusResult, s conversion.Scope) error {
- return autoConvert_api_PodStatusResult_To_v1_PodStatusResult(in, out, s)
+func Convert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *api.PersistentVolumeSource, out *PersistentVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(in, out, s)
}
-func autoConvert_api_PodTemplate_To_v1_PodTemplate(in *api.PodTemplate, out *PodTemplate, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodTemplate))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+func autoConvert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in *PersistentVolumeSpec, out *api.PersistentVolumeSpec, s conversion.Scope) error {
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Capacity, &out.Capacity, s); err != nil {
return err
}
- return nil
-}
-
-func Convert_api_PodTemplate_To_v1_PodTemplate(in *api.PodTemplate, out *PodTemplate, s conversion.Scope) error {
- return autoConvert_api_PodTemplate_To_v1_PodTemplate(in, out, s)
-}
-
-func autoConvert_api_PodTemplateList_To_v1_PodTemplateList(in *api.PodTemplateList, out *PodTemplateList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodTemplateList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ if err := Convert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
return err
}
- if in.Items != nil {
- out.Items = make([]PodTemplate, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_PodTemplate_To_v1_PodTemplate(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
+ if in.AccessModes != nil {
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]api.PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = api.PersistentVolumeAccessMode((*in)[i])
}
} else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_PodTemplateList_To_v1_PodTemplateList(in *api.PodTemplateList, out *PodTemplateList, s conversion.Scope) error {
- return autoConvert_api_PodTemplateList_To_v1_PodTemplateList(in, out, s)
-}
-
-func autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.PodTemplateSpec))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
+ out.AccessModes = nil
}
- if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
+ if in.ClaimRef != nil {
+ in, out := &in.ClaimRef, &out.ClaimRef
+ *out = new(api.ObjectReference)
+ if err := Convert_v1_ObjectReference_To_api_ObjectReference(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ClaimRef = nil
}
+ out.PersistentVolumeReclaimPolicy = api.PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
return nil
}
-func Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in, out, s)
-}
-
-func autoConvert_api_Probe_To_v1_Probe(in *api.Probe, out *Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Probe))(in)
- }
- if err := Convert_api_Handler_To_v1_Handler(&in.Handler, &out.Handler, s); err != nil {
- return err
- }
- out.InitialDelaySeconds = int32(in.InitialDelaySeconds)
- out.TimeoutSeconds = int32(in.TimeoutSeconds)
- out.PeriodSeconds = int32(in.PeriodSeconds)
- out.SuccessThreshold = int32(in.SuccessThreshold)
- out.FailureThreshold = int32(in.FailureThreshold)
- return nil
+func Convert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in *PersistentVolumeSpec, out *api.PersistentVolumeSpec, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in, out, s)
}
-func Convert_api_Probe_To_v1_Probe(in *api.Probe, out *Probe, s conversion.Scope) error {
- return autoConvert_api_Probe_To_v1_Probe(in, out, s)
-}
-
-func autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.RBDVolumeSource))(in)
- }
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
- }
- } else {
- out.CephMonitors = nil
- }
- out.RBDImage = in.RBDImage
- out.FSType = in.FSType
- out.RBDPool = in.RBDPool
- out.RadosUser = in.RadosUser
- out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for api.LocalObjectReference -> v1.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(LocalObjectReference)
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in, out, s)
-}
-
-func autoConvert_api_RangeAllocation_To_v1_RangeAllocation(in *api.RangeAllocation, out *RangeAllocation, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.RangeAllocation))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- out.Range = in.Range
- if err := conversion.ByteSliceCopy(&in.Data, &out.Data, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_RangeAllocation_To_v1_RangeAllocation(in *api.RangeAllocation, out *RangeAllocation, s conversion.Scope) error {
- return autoConvert_api_RangeAllocation_To_v1_RangeAllocation(in, out, s)
-}
-
-func autoConvert_api_ReplicationController_To_v1_ReplicationController(in *api.ReplicationController, out *ReplicationController, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ReplicationController))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_ReplicationController_To_v1_ReplicationController(in *api.ReplicationController, out *ReplicationController, s conversion.Scope) error {
- return autoConvert_api_ReplicationController_To_v1_ReplicationController(in, out, s)
-}
-
-func autoConvert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in *api.ReplicationControllerList, out *ReplicationControllerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ReplicationControllerList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ReplicationController, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_ReplicationController_To_v1_ReplicationController(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in *api.ReplicationControllerList, out *ReplicationControllerList, s conversion.Scope) error {
- return autoConvert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in, out, s)
-}
-
-func autoConvert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *api.ReplicationControllerSpec, out *ReplicationControllerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ReplicationControllerSpec))(in)
- }
- if err := s.Convert(&in.Replicas, &out.Replicas, 0); err != nil {
- return err
- }
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
- // unable to generate simple pointer conversion for api.PodTemplateSpec -> v1.PodTemplateSpec
- if in.Template != nil {
- out.Template = new(PodTemplateSpec)
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in.Template, out.Template, s); err != nil {
- return err
- }
- } else {
- out.Template = nil
- }
- return nil
-}
-
-func autoConvert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *api.ReplicationControllerStatus, out *ReplicationControllerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ReplicationControllerStatus))(in)
- }
- out.Replicas = int32(in.Replicas)
- out.FullyLabeledReplicas = int32(in.FullyLabeledReplicas)
- out.ObservedGeneration = in.ObservedGeneration
- return nil
-}
-
-func Convert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *api.ReplicationControllerStatus, out *ReplicationControllerStatus, s conversion.Scope) error {
- return autoConvert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in, out, s)
-}
-
-func autoConvert_api_ResourceQuota_To_v1_ResourceQuota(in *api.ResourceQuota, out *ResourceQuota, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceQuota))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_ResourceQuota_To_v1_ResourceQuota(in *api.ResourceQuota, out *ResourceQuota, s conversion.Scope) error {
- return autoConvert_api_ResourceQuota_To_v1_ResourceQuota(in, out, s)
-}
-
-func autoConvert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in *api.ResourceQuotaList, out *ResourceQuotaList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceQuotaList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ResourceQuota, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_ResourceQuota_To_v1_ResourceQuota(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in *api.ResourceQuotaList, out *ResourceQuotaList, s conversion.Scope) error {
- return autoConvert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in, out, s)
-}
-
-func autoConvert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *api.ResourceQuotaSpec, out *ResourceQuotaSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceQuotaSpec))(in)
- }
- if in.Hard != nil {
- out.Hard = make(ResourceList)
- for key, val := range in.Hard {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Hard[ResourceName(key)] = newVal
- }
- } else {
- out.Hard = nil
- }
- if in.Scopes != nil {
- out.Scopes = make([]ResourceQuotaScope, len(in.Scopes))
- for i := range in.Scopes {
- out.Scopes[i] = ResourceQuotaScope(in.Scopes[i])
- }
- } else {
- out.Scopes = nil
- }
- return nil
-}
-
-func Convert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *api.ResourceQuotaSpec, out *ResourceQuotaSpec, s conversion.Scope) error {
- return autoConvert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in, out, s)
-}
-
-func autoConvert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *api.ResourceQuotaStatus, out *ResourceQuotaStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceQuotaStatus))(in)
- }
- if in.Hard != nil {
- out.Hard = make(ResourceList)
- for key, val := range in.Hard {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Hard[ResourceName(key)] = newVal
- }
- } else {
- out.Hard = nil
- }
- if in.Used != nil {
- out.Used = make(ResourceList)
- for key, val := range in.Used {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Used[ResourceName(key)] = newVal
- }
- } else {
- out.Used = nil
- }
- return nil
-}
-
-func Convert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *api.ResourceQuotaStatus, out *ResourceQuotaStatus, s conversion.Scope) error {
- return autoConvert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in, out, s)
-}
-
-func autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ResourceRequirements))(in)
- }
- if in.Limits != nil {
- out.Limits = make(ResourceList)
- for key, val := range in.Limits {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Limits[ResourceName(key)] = newVal
- }
- } else {
- out.Limits = nil
- }
- if in.Requests != nil {
- out.Requests = make(ResourceList)
- for key, val := range in.Requests {
- newVal := resource.Quantity{}
- if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, &newVal, s); err != nil {
- return err
- }
- out.Requests[ResourceName(key)] = newVal
- }
- } else {
- out.Requests = nil
- }
- return nil
-}
-
-func Convert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *ResourceRequirements, s conversion.Scope) error {
- return autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in, out, s)
-}
-
-func autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SELinuxOptions))(in)
- }
- out.User = in.User
- out.Role = in.Role
- out.Type = in.Type
- out.Level = in.Level
- return nil
-}
-
-func Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *SELinuxOptions, s conversion.Scope) error {
- return autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in, out, s)
-}
-
-func autoConvert_api_Secret_To_v1_Secret(in *api.Secret, out *Secret, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Secret))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if in.Data != nil {
- out.Data = make(map[string][]uint8)
- for key, val := range in.Data {
- newVal := []uint8{}
- if err := conversion.ByteSliceCopy(&val, &newVal, s); err != nil {
- return err
- }
- out.Data[key] = newVal
- }
- } else {
- out.Data = nil
- }
- out.Type = SecretType(in.Type)
- return nil
-}
-
-func Convert_api_Secret_To_v1_Secret(in *api.Secret, out *Secret, s conversion.Scope) error {
- return autoConvert_api_Secret_To_v1_Secret(in, out, s)
-}
-
-func autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretKeySelector))(in)
- }
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *SecretKeySelector, s conversion.Scope) error {
- return autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in, out, s)
-}
-
-func autoConvert_api_SecretList_To_v1_SecretList(in *api.SecretList, out *SecretList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Secret, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Secret_To_v1_Secret(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_SecretList_To_v1_SecretList(in *api.SecretList, out *SecretList, s conversion.Scope) error {
- return autoConvert_api_SecretList_To_v1_SecretList(in, out, s)
-}
-
-func autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecretVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- return nil
-}
-
-func Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *SecretVolumeSource, s conversion.Scope) error {
- return autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in, out, s)
-}
-
-func autoConvert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SecurityContext))(in)
- }
- // unable to generate simple pointer conversion for api.Capabilities -> v1.Capabilities
- if in.Capabilities != nil {
- out.Capabilities = new(Capabilities)
- if err := Convert_api_Capabilities_To_v1_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
- return err
- }
- } else {
- out.Capabilities = nil
- }
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for api.SELinuxOptions -> v1.SELinuxOptions
- if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(SELinuxOptions)
- if err := Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
- return err
- }
- } else {
- out.SELinuxOptions = nil
- }
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
- } else {
- out.RunAsNonRoot = nil
- }
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
- } else {
- out.ReadOnlyRootFilesystem = nil
- }
- return nil
-}
-
-func Convert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *SecurityContext, s conversion.Scope) error {
- return autoConvert_api_SecurityContext_To_v1_SecurityContext(in, out, s)
-}
-
-func autoConvert_api_SerializedReference_To_v1_SerializedReference(in *api.SerializedReference, out *SerializedReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.SerializedReference))(in)
- }
- if err := Convert_api_ObjectReference_To_v1_ObjectReference(&in.Reference, &out.Reference, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_SerializedReference_To_v1_SerializedReference(in *api.SerializedReference, out *SerializedReference, s conversion.Scope) error {
- return autoConvert_api_SerializedReference_To_v1_SerializedReference(in, out, s)
-}
-
-func autoConvert_api_Service_To_v1_Service(in *api.Service, out *Service, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Service))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_api_ServiceSpec_To_v1_ServiceSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_api_ServiceStatus_To_v1_ServiceStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_Service_To_v1_Service(in *api.Service, out *Service, s conversion.Scope) error {
- return autoConvert_api_Service_To_v1_Service(in, out, s)
-}
-
-func autoConvert_api_ServiceAccount_To_v1_ServiceAccount(in *api.ServiceAccount, out *ServiceAccount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceAccount))(in)
- }
- if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if in.Secrets != nil {
- out.Secrets = make([]ObjectReference, len(in.Secrets))
- for i := range in.Secrets {
- if err := Convert_api_ObjectReference_To_v1_ObjectReference(&in.Secrets[i], &out.Secrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Secrets = nil
- }
- if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.ImagePullSecrets = nil
- }
- return nil
-}
-
-func Convert_api_ServiceAccount_To_v1_ServiceAccount(in *api.ServiceAccount, out *ServiceAccount, s conversion.Scope) error {
- return autoConvert_api_ServiceAccount_To_v1_ServiceAccount(in, out, s)
-}
-
-func autoConvert_api_ServiceAccountList_To_v1_ServiceAccountList(in *api.ServiceAccountList, out *ServiceAccountList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceAccountList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]ServiceAccount, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_ServiceAccount_To_v1_ServiceAccount(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ServiceAccountList_To_v1_ServiceAccountList(in *api.ServiceAccountList, out *ServiceAccountList, s conversion.Scope) error {
- return autoConvert_api_ServiceAccountList_To_v1_ServiceAccountList(in, out, s)
-}
-
-func autoConvert_api_ServiceList_To_v1_ServiceList(in *api.ServiceList, out *ServiceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]Service, len(in.Items))
- for i := range in.Items {
- if err := Convert_api_Service_To_v1_Service(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_api_ServiceList_To_v1_ServiceList(in *api.ServiceList, out *ServiceList, s conversion.Scope) error {
- return autoConvert_api_ServiceList_To_v1_ServiceList(in, out, s)
-}
-
-func autoConvert_api_ServicePort_To_v1_ServicePort(in *api.ServicePort, out *ServicePort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServicePort))(in)
- }
- out.Name = in.Name
- out.Protocol = Protocol(in.Protocol)
- out.Port = int32(in.Port)
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.TargetPort, &out.TargetPort, s); err != nil {
- return err
- }
- out.NodePort = int32(in.NodePort)
- return nil
-}
-
-func Convert_api_ServicePort_To_v1_ServicePort(in *api.ServicePort, out *ServicePort, s conversion.Scope) error {
- return autoConvert_api_ServicePort_To_v1_ServicePort(in, out, s)
-}
-
-func autoConvert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *api.ServiceProxyOptions, out *ServiceProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceProxyOptions))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *api.ServiceProxyOptions, out *ServiceProxyOptions, s conversion.Scope) error {
- return autoConvert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in, out, s)
-}
-
-func autoConvert_api_ServiceSpec_To_v1_ServiceSpec(in *api.ServiceSpec, out *ServiceSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceSpec))(in)
- }
- out.Type = ServiceType(in.Type)
- if in.Ports != nil {
- out.Ports = make([]ServicePort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_api_ServicePort_To_v1_ServicePort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
- out.ClusterIP = in.ClusterIP
- if in.ExternalIPs != nil {
- out.ExternalIPs = make([]string, len(in.ExternalIPs))
- for i := range in.ExternalIPs {
- out.ExternalIPs[i] = in.ExternalIPs[i]
- }
- } else {
- out.ExternalIPs = nil
- }
- out.LoadBalancerIP = in.LoadBalancerIP
- out.SessionAffinity = ServiceAffinity(in.SessionAffinity)
- return nil
-}
-
-func autoConvert_api_ServiceStatus_To_v1_ServiceStatus(in *api.ServiceStatus, out *ServiceStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.ServiceStatus))(in)
- }
- if err := Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_ServiceStatus_To_v1_ServiceStatus(in *api.ServiceStatus, out *ServiceStatus, s conversion.Scope) error {
- return autoConvert_api_ServiceStatus_To_v1_ServiceStatus(in, out, s)
-}
-
-func autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.TCPSocketAction))(in)
- }
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *TCPSocketAction, s conversion.Scope) error {
- return autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in, out, s)
-}
-
-func autoConvert_api_Volume_To_v1_Volume(in *api.Volume, out *Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.Volume))(in)
- }
- out.Name = in.Name
- if err := Convert_api_VolumeSource_To_v1_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_api_Volume_To_v1_Volume(in *api.Volume, out *Volume, s conversion.Scope) error {
- return autoConvert_api_Volume_To_v1_Volume(in, out, s)
-}
-
-func autoConvert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeMount))(in)
- }
- out.Name = in.Name
- out.ReadOnly = in.ReadOnly
- out.MountPath = in.MountPath
- return nil
-}
-
-func Convert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *VolumeMount, s conversion.Scope) error {
- return autoConvert_api_VolumeMount_To_v1_VolumeMount(in, out, s)
-}
-
-func autoConvert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*api.VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for api.HostPathVolumeSource -> v1.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(HostPathVolumeSource)
- if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for api.EmptyDirVolumeSource -> v1.EmptyDirVolumeSource
- if in.EmptyDir != nil {
- out.EmptyDir = new(EmptyDirVolumeSource)
- if err := Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
- return err
- }
- } else {
- out.EmptyDir = nil
- }
- // unable to generate simple pointer conversion for api.GCEPersistentDiskVolumeSource -> v1.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
- if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for api.AWSElasticBlockStoreVolumeSource -> v1.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
- if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for api.GitRepoVolumeSource -> v1.GitRepoVolumeSource
- if in.GitRepo != nil {
- out.GitRepo = new(GitRepoVolumeSource)
- if err := Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
- return err
- }
- } else {
- out.GitRepo = nil
- }
- // unable to generate simple pointer conversion for api.SecretVolumeSource -> v1.SecretVolumeSource
- if in.Secret != nil {
- out.Secret = new(SecretVolumeSource)
- if err := Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
- return err
- }
- } else {
- out.Secret = nil
- }
- // unable to generate simple pointer conversion for api.NFSVolumeSource -> v1.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(NFSVolumeSource)
- if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for api.ISCSIVolumeSource -> v1.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(ISCSIVolumeSource)
- if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for api.GlusterfsVolumeSource -> v1.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(GlusterfsVolumeSource)
- if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for api.PersistentVolumeClaimVolumeSource -> v1.PersistentVolumeClaimVolumeSource
- if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(PersistentVolumeClaimVolumeSource)
- if err := Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
- return err
- }
- } else {
- out.PersistentVolumeClaim = nil
- }
- // unable to generate simple pointer conversion for api.RBDVolumeSource -> v1.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(RBDVolumeSource)
- if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for api.FlexVolumeSource -> v1.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(FlexVolumeSource)
- if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
- }
- } else {
- out.FlexVolume = nil
- }
- // unable to generate simple pointer conversion for api.CinderVolumeSource -> v1.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(CinderVolumeSource)
- if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for api.CephFSVolumeSource -> v1.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(CephFSVolumeSource)
- if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for api.FlockerVolumeSource -> v1.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(FlockerVolumeSource)
- if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for api.DownwardAPIVolumeSource -> v1.DownwardAPIVolumeSource
- if in.DownwardAPI != nil {
- out.DownwardAPI = new(DownwardAPIVolumeSource)
- if err := Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
- return err
- }
- } else {
- out.DownwardAPI = nil
- }
- // unable to generate simple pointer conversion for api.FCVolumeSource -> v1.FCVolumeSource
- if in.FC != nil {
- out.FC = new(FCVolumeSource)
- if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for api.AzureFileVolumeSource -> v1.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(AzureFileVolumeSource)
- if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
- }
- } else {
- out.AzureFile = nil
- }
- // unable to generate simple pointer conversion for api.ConfigMapVolumeSource -> v1.ConfigMapVolumeSource
- if in.ConfigMap != nil {
- out.ConfigMap = new(ConfigMapVolumeSource)
- if err := Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
- return err
- }
- } else {
- out.ConfigMap = nil
- }
- return nil
-}
-
-func Convert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *VolumeSource, s conversion.Scope) error {
- return autoConvert_api_VolumeSource_To_v1_VolumeSource(in, out, s)
-}
-
-func autoConvert_unversioned_ExportOptions_To_v1_ExportOptions(in *unversioned.ExportOptions, out *ExportOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*unversioned.ExportOptions))(in)
- }
- out.Export = in.Export
- out.Exact = in.Exact
- return nil
-}
-
-func Convert_unversioned_ExportOptions_To_v1_ExportOptions(in *unversioned.ExportOptions, out *ExportOptions, s conversion.Scope) error {
- return autoConvert_unversioned_ExportOptions_To_v1_ExportOptions(in, out, s)
-}
-
-func autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*AWSElasticBlockStoreVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in *AWSElasticBlockStoreVolumeSource, out *api.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*AzureFileVolumeSource))(in)
- }
- out.SecretName = in.SecretName
- out.ShareName = in.ShareName
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in *AzureFileVolumeSource, out *api.AzureFileVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Binding_To_api_Binding(in *Binding, out *api.Binding, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Binding))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.Target, &out.Target, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Binding_To_api_Binding(in *Binding, out *api.Binding, s conversion.Scope) error {
- return autoConvert_v1_Binding_To_api_Binding(in, out, s)
-}
-
-func autoConvert_v1_Capabilities_To_api_Capabilities(in *Capabilities, out *api.Capabilities, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Capabilities))(in)
- }
- if in.Add != nil {
- out.Add = make([]api.Capability, len(in.Add))
- for i := range in.Add {
- out.Add[i] = api.Capability(in.Add[i])
- }
- } else {
- out.Add = nil
- }
- if in.Drop != nil {
- out.Drop = make([]api.Capability, len(in.Drop))
- for i := range in.Drop {
- out.Drop[i] = api.Capability(in.Drop[i])
- }
- } else {
- out.Drop = nil
- }
- return nil
-}
-
-func Convert_v1_Capabilities_To_api_Capabilities(in *Capabilities, out *api.Capabilities, s conversion.Scope) error {
- return autoConvert_v1_Capabilities_To_api_Capabilities(in, out, s)
-}
-
-func autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*CephFSVolumeSource))(in)
- }
- if in.Monitors != nil {
- out.Monitors = make([]string, len(in.Monitors))
- for i := range in.Monitors {
- out.Monitors[i] = in.Monitors[i]
- }
- } else {
- out.Monitors = nil
- }
- out.Path = in.Path
- out.User = in.User
- out.SecretFile = in.SecretFile
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in *CephFSVolumeSource, out *api.CephFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*CinderVolumeSource))(in)
- }
- out.VolumeID = in.VolumeID
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in *CinderVolumeSource, out *api.CinderVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ComponentCondition_To_api_ComponentCondition(in *ComponentCondition, out *api.ComponentCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ComponentCondition))(in)
- }
- out.Type = api.ComponentConditionType(in.Type)
- out.Status = api.ConditionStatus(in.Status)
- out.Message = in.Message
- out.Error = in.Error
- return nil
-}
-
-func Convert_v1_ComponentCondition_To_api_ComponentCondition(in *ComponentCondition, out *api.ComponentCondition, s conversion.Scope) error {
- return autoConvert_v1_ComponentCondition_To_api_ComponentCondition(in, out, s)
-}
-
-func autoConvert_v1_ComponentStatus_To_api_ComponentStatus(in *ComponentStatus, out *api.ComponentStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ComponentStatus))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if in.Conditions != nil {
- out.Conditions = make([]api.ComponentCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_v1_ComponentCondition_To_api_ComponentCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- return nil
-}
-
-func Convert_v1_ComponentStatus_To_api_ComponentStatus(in *ComponentStatus, out *api.ComponentStatus, s conversion.Scope) error {
- return autoConvert_v1_ComponentStatus_To_api_ComponentStatus(in, out, s)
-}
-
-func autoConvert_v1_ComponentStatusList_To_api_ComponentStatusList(in *ComponentStatusList, out *api.ComponentStatusList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ComponentStatusList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.ComponentStatus, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_ComponentStatus_To_api_ComponentStatus(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_ComponentStatusList_To_api_ComponentStatusList(in *ComponentStatusList, out *api.ComponentStatusList, s conversion.Scope) error {
- return autoConvert_v1_ComponentStatusList_To_api_ComponentStatusList(in, out, s)
-}
-
-func autoConvert_v1_ConfigMap_To_api_ConfigMap(in *ConfigMap, out *api.ConfigMap, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ConfigMap))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if in.Data != nil {
- out.Data = make(map[string]string)
- for key, val := range in.Data {
- out.Data[key] = val
- }
- } else {
- out.Data = nil
- }
- return nil
-}
-
-func Convert_v1_ConfigMap_To_api_ConfigMap(in *ConfigMap, out *api.ConfigMap, s conversion.Scope) error {
- return autoConvert_v1_ConfigMap_To_api_ConfigMap(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ConfigMapKeySelector))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- out.Key = in.Key
- return nil
-}
-
-func Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in *ConfigMapKeySelector, out *api.ConfigMapKeySelector, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapList_To_api_ConfigMapList(in *ConfigMapList, out *api.ConfigMapList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ConfigMapList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.ConfigMap, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_ConfigMap_To_api_ConfigMap(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_ConfigMapList_To_api_ConfigMapList(in *ConfigMapList, out *api.ConfigMapList, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapList_To_api_ConfigMapList(in, out, s)
-}
-
-func autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ConfigMapVolumeSource))(in)
- }
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.KeyToPath, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_KeyToPath_To_api_KeyToPath(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in *ConfigMapVolumeSource, out *api.ConfigMapVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Container_To_api_Container(in *Container, out *api.Container, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Container))(in)
- }
- out.Name = in.Name
- out.Image = in.Image
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- if in.Args != nil {
- out.Args = make([]string, len(in.Args))
- for i := range in.Args {
- out.Args[i] = in.Args[i]
- }
- } else {
- out.Args = nil
- }
- out.WorkingDir = in.WorkingDir
- if in.Ports != nil {
- out.Ports = make([]api.ContainerPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_v1_ContainerPort_To_api_ContainerPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- if in.Env != nil {
- out.Env = make([]api.EnvVar, len(in.Env))
- for i := range in.Env {
- if err := Convert_v1_EnvVar_To_api_EnvVar(&in.Env[i], &out.Env[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Env = nil
- }
- if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
- }
- if in.VolumeMounts != nil {
- out.VolumeMounts = make([]api.VolumeMount, len(in.VolumeMounts))
- for i := range in.VolumeMounts {
- if err := Convert_v1_VolumeMount_To_api_VolumeMount(&in.VolumeMounts[i], &out.VolumeMounts[i], s); err != nil {
- return err
- }
- }
- } else {
- out.VolumeMounts = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.LivenessProbe != nil {
- out.LivenessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.LivenessProbe, out.LivenessProbe, s); err != nil {
- return err
- }
- } else {
- out.LivenessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Probe -> api.Probe
- if in.ReadinessProbe != nil {
- out.ReadinessProbe = new(api.Probe)
- if err := Convert_v1_Probe_To_api_Probe(in.ReadinessProbe, out.ReadinessProbe, s); err != nil {
- return err
- }
- } else {
- out.ReadinessProbe = nil
- }
- // unable to generate simple pointer conversion for v1.Lifecycle -> api.Lifecycle
- if in.Lifecycle != nil {
- out.Lifecycle = new(api.Lifecycle)
- if err := Convert_v1_Lifecycle_To_api_Lifecycle(in.Lifecycle, out.Lifecycle, s); err != nil {
- return err
- }
- } else {
- out.Lifecycle = nil
- }
- out.TerminationMessagePath = in.TerminationMessagePath
- out.ImagePullPolicy = api.PullPolicy(in.ImagePullPolicy)
- // unable to generate simple pointer conversion for v1.SecurityContext -> api.SecurityContext
- if in.SecurityContext != nil {
- out.SecurityContext = new(api.SecurityContext)
- if err := Convert_v1_SecurityContext_To_api_SecurityContext(in.SecurityContext, out.SecurityContext, s); err != nil {
- return err
- }
- } else {
- out.SecurityContext = nil
- }
- out.Stdin = in.Stdin
- out.StdinOnce = in.StdinOnce
- out.TTY = in.TTY
- return nil
-}
-
-func Convert_v1_Container_To_api_Container(in *Container, out *api.Container, s conversion.Scope) error {
- return autoConvert_v1_Container_To_api_Container(in, out, s)
-}
-
-func autoConvert_v1_ContainerImage_To_api_ContainerImage(in *ContainerImage, out *api.ContainerImage, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerImage))(in)
- }
- if in.Names != nil {
- out.Names = make([]string, len(in.Names))
- for i := range in.Names {
- out.Names[i] = in.Names[i]
- }
- } else {
- out.Names = nil
- }
- out.SizeBytes = in.SizeBytes
- return nil
-}
-
-func Convert_v1_ContainerImage_To_api_ContainerImage(in *ContainerImage, out *api.ContainerImage, s conversion.Scope) error {
- return autoConvert_v1_ContainerImage_To_api_ContainerImage(in, out, s)
-}
-
-func autoConvert_v1_ContainerPort_To_api_ContainerPort(in *ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerPort))(in)
- }
- out.Name = in.Name
- out.HostPort = int(in.HostPort)
- out.ContainerPort = int(in.ContainerPort)
- out.Protocol = api.Protocol(in.Protocol)
- out.HostIP = in.HostIP
- return nil
-}
-
-func Convert_v1_ContainerPort_To_api_ContainerPort(in *ContainerPort, out *api.ContainerPort, s conversion.Scope) error {
- return autoConvert_v1_ContainerPort_To_api_ContainerPort(in, out, s)
-}
-
-func autoConvert_v1_ContainerState_To_api_ContainerState(in *ContainerState, out *api.ContainerState, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerState))(in)
- }
- // unable to generate simple pointer conversion for v1.ContainerStateWaiting -> api.ContainerStateWaiting
- if in.Waiting != nil {
- out.Waiting = new(api.ContainerStateWaiting)
- if err := Convert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in.Waiting, out.Waiting, s); err != nil {
- return err
- }
- } else {
- out.Waiting = nil
- }
- // unable to generate simple pointer conversion for v1.ContainerStateRunning -> api.ContainerStateRunning
- if in.Running != nil {
- out.Running = new(api.ContainerStateRunning)
- if err := Convert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in.Running, out.Running, s); err != nil {
- return err
- }
- } else {
- out.Running = nil
- }
- // unable to generate simple pointer conversion for v1.ContainerStateTerminated -> api.ContainerStateTerminated
- if in.Terminated != nil {
- out.Terminated = new(api.ContainerStateTerminated)
- if err := Convert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in.Terminated, out.Terminated, s); err != nil {
- return err
- }
- } else {
- out.Terminated = nil
- }
- return nil
-}
-
-func Convert_v1_ContainerState_To_api_ContainerState(in *ContainerState, out *api.ContainerState, s conversion.Scope) error {
- return autoConvert_v1_ContainerState_To_api_ContainerState(in, out, s)
-}
-
-func autoConvert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in *ContainerStateRunning, out *api.ContainerStateRunning, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerStateRunning))(in)
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in *ContainerStateRunning, out *api.ContainerStateRunning, s conversion.Scope) error {
- return autoConvert_v1_ContainerStateRunning_To_api_ContainerStateRunning(in, out, s)
-}
-
-func autoConvert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in *ContainerStateTerminated, out *api.ContainerStateTerminated, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerStateTerminated))(in)
- }
- out.ExitCode = int(in.ExitCode)
- out.Signal = int(in.Signal)
- out.Reason = in.Reason
- out.Message = in.Message
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.StartedAt, &out.StartedAt, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.FinishedAt, &out.FinishedAt, s); err != nil {
- return err
- }
- out.ContainerID = in.ContainerID
- return nil
-}
-
-func Convert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in *ContainerStateTerminated, out *api.ContainerStateTerminated, s conversion.Scope) error {
- return autoConvert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated(in, out, s)
-}
-
-func autoConvert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in *ContainerStateWaiting, out *api.ContainerStateWaiting, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerStateWaiting))(in)
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in *ContainerStateWaiting, out *api.ContainerStateWaiting, s conversion.Scope) error {
- return autoConvert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting(in, out, s)
-}
-
-func autoConvert_v1_ContainerStatus_To_api_ContainerStatus(in *ContainerStatus, out *api.ContainerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ContainerStatus))(in)
- }
- out.Name = in.Name
- if err := Convert_v1_ContainerState_To_api_ContainerState(&in.State, &out.State, s); err != nil {
- return err
- }
- if err := Convert_v1_ContainerState_To_api_ContainerState(&in.LastTerminationState, &out.LastTerminationState, s); err != nil {
- return err
- }
- out.Ready = in.Ready
- out.RestartCount = int(in.RestartCount)
- out.Image = in.Image
- out.ImageID = in.ImageID
- out.ContainerID = in.ContainerID
- return nil
-}
-
-func Convert_v1_ContainerStatus_To_api_ContainerStatus(in *ContainerStatus, out *api.ContainerStatus, s conversion.Scope) error {
- return autoConvert_v1_ContainerStatus_To_api_ContainerStatus(in, out, s)
-}
-
-func autoConvert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in *DaemonEndpoint, out *api.DaemonEndpoint, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DaemonEndpoint))(in)
- }
- out.Port = int(in.Port)
- return nil
-}
-
-func Convert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in *DaemonEndpoint, out *api.DaemonEndpoint, s conversion.Scope) error {
- return autoConvert_v1_DaemonEndpoint_To_api_DaemonEndpoint(in, out, s)
-}
-
-func autoConvert_v1_DeleteOptions_To_api_DeleteOptions(in *DeleteOptions, out *api.DeleteOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeleteOptions))(in)
- }
- if in.GracePeriodSeconds != nil {
- out.GracePeriodSeconds = new(int64)
- *out.GracePeriodSeconds = *in.GracePeriodSeconds
- } else {
- out.GracePeriodSeconds = nil
- }
- return nil
-}
-
-func Convert_v1_DeleteOptions_To_api_DeleteOptions(in *DeleteOptions, out *api.DeleteOptions, s conversion.Scope) error {
- return autoConvert_v1_DeleteOptions_To_api_DeleteOptions(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DownwardAPIVolumeFile))(in)
- }
- out.Path = in.Path
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(&in.FieldRef, &out.FieldRef, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in *DownwardAPIVolumeFile, out *api.DownwardAPIVolumeFile, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(in, out, s)
-}
-
-func autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DownwardAPIVolumeSource))(in)
- }
- if in.Items != nil {
- out.Items = make([]api.DownwardAPIVolumeFile, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in *DownwardAPIVolumeSource, out *api.DownwardAPIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EmptyDirVolumeSource))(in)
- }
- out.Medium = api.StorageMedium(in.Medium)
- return nil
-}
-
-func Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in *EmptyDirVolumeSource, out *api.EmptyDirVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_EndpointAddress_To_api_EndpointAddress(in *EndpointAddress, out *api.EndpointAddress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EndpointAddress))(in)
- }
- out.IP = in.IP
- // unable to generate simple pointer conversion for v1.ObjectReference -> api.ObjectReference
- if in.TargetRef != nil {
- out.TargetRef = new(api.ObjectReference)
- if err := Convert_v1_ObjectReference_To_api_ObjectReference(in.TargetRef, out.TargetRef, s); err != nil {
- return err
- }
- } else {
- out.TargetRef = nil
- }
- return nil
-}
-
-func Convert_v1_EndpointAddress_To_api_EndpointAddress(in *EndpointAddress, out *api.EndpointAddress, s conversion.Scope) error {
- return autoConvert_v1_EndpointAddress_To_api_EndpointAddress(in, out, s)
-}
-
-func autoConvert_v1_EndpointPort_To_api_EndpointPort(in *EndpointPort, out *api.EndpointPort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EndpointPort))(in)
- }
- out.Name = in.Name
- out.Port = int(in.Port)
- out.Protocol = api.Protocol(in.Protocol)
- return nil
-}
-
-func Convert_v1_EndpointPort_To_api_EndpointPort(in *EndpointPort, out *api.EndpointPort, s conversion.Scope) error {
- return autoConvert_v1_EndpointPort_To_api_EndpointPort(in, out, s)
-}
-
-func autoConvert_v1_EndpointSubset_To_api_EndpointSubset(in *EndpointSubset, out *api.EndpointSubset, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EndpointSubset))(in)
- }
- if in.Addresses != nil {
- out.Addresses = make([]api.EndpointAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := Convert_v1_EndpointAddress_To_api_EndpointAddress(&in.Addresses[i], &out.Addresses[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Addresses = nil
- }
- if in.NotReadyAddresses != nil {
- out.NotReadyAddresses = make([]api.EndpointAddress, len(in.NotReadyAddresses))
- for i := range in.NotReadyAddresses {
- if err := Convert_v1_EndpointAddress_To_api_EndpointAddress(&in.NotReadyAddresses[i], &out.NotReadyAddresses[i], s); err != nil {
- return err
- }
- }
- } else {
- out.NotReadyAddresses = nil
- }
- if in.Ports != nil {
- out.Ports = make([]api.EndpointPort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_v1_EndpointPort_To_api_EndpointPort(&in.Ports[i], &out.Ports[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ports = nil
- }
- return nil
-}
-
-func Convert_v1_EndpointSubset_To_api_EndpointSubset(in *EndpointSubset, out *api.EndpointSubset, s conversion.Scope) error {
- return autoConvert_v1_EndpointSubset_To_api_EndpointSubset(in, out, s)
-}
-
-func autoConvert_v1_Endpoints_To_api_Endpoints(in *Endpoints, out *api.Endpoints, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Endpoints))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if in.Subsets != nil {
- out.Subsets = make([]api.EndpointSubset, len(in.Subsets))
- for i := range in.Subsets {
- if err := Convert_v1_EndpointSubset_To_api_EndpointSubset(&in.Subsets[i], &out.Subsets[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Subsets = nil
- }
- return nil
-}
-
-func Convert_v1_Endpoints_To_api_Endpoints(in *Endpoints, out *api.Endpoints, s conversion.Scope) error {
- return autoConvert_v1_Endpoints_To_api_Endpoints(in, out, s)
-}
-
-func autoConvert_v1_EndpointsList_To_api_EndpointsList(in *EndpointsList, out *api.EndpointsList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EndpointsList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.Endpoints, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Endpoints_To_api_Endpoints(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_EndpointsList_To_api_EndpointsList(in *EndpointsList, out *api.EndpointsList, s conversion.Scope) error {
- return autoConvert_v1_EndpointsList_To_api_EndpointsList(in, out, s)
-}
-
-func autoConvert_v1_EnvVar_To_api_EnvVar(in *EnvVar, out *api.EnvVar, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EnvVar))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- // unable to generate simple pointer conversion for v1.EnvVarSource -> api.EnvVarSource
- if in.ValueFrom != nil {
- out.ValueFrom = new(api.EnvVarSource)
- if err := Convert_v1_EnvVarSource_To_api_EnvVarSource(in.ValueFrom, out.ValueFrom, s); err != nil {
- return err
- }
- } else {
- out.ValueFrom = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVar_To_api_EnvVar(in *EnvVar, out *api.EnvVar, s conversion.Scope) error {
- return autoConvert_v1_EnvVar_To_api_EnvVar(in, out, s)
-}
-
-func autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in *EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EnvVarSource))(in)
- }
- // unable to generate simple pointer conversion for v1.ObjectFieldSelector -> api.ObjectFieldSelector
- if in.FieldRef != nil {
- out.FieldRef = new(api.ObjectFieldSelector)
- if err := Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in.FieldRef, out.FieldRef, s); err != nil {
- return err
- }
- } else {
- out.FieldRef = nil
- }
- // unable to generate simple pointer conversion for v1.ConfigMapKeySelector -> api.ConfigMapKeySelector
- if in.ConfigMapKeyRef != nil {
- out.ConfigMapKeyRef = new(api.ConfigMapKeySelector)
- if err := Convert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector(in.ConfigMapKeyRef, out.ConfigMapKeyRef, s); err != nil {
- return err
- }
- } else {
- out.ConfigMapKeyRef = nil
- }
- // unable to generate simple pointer conversion for v1.SecretKeySelector -> api.SecretKeySelector
- if in.SecretKeyRef != nil {
- out.SecretKeyRef = new(api.SecretKeySelector)
- if err := Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in.SecretKeyRef, out.SecretKeyRef, s); err != nil {
- return err
- }
- } else {
- out.SecretKeyRef = nil
- }
- return nil
-}
-
-func Convert_v1_EnvVarSource_To_api_EnvVarSource(in *EnvVarSource, out *api.EnvVarSource, s conversion.Scope) error {
- return autoConvert_v1_EnvVarSource_To_api_EnvVarSource(in, out, s)
-}
-
-func autoConvert_v1_Event_To_api_Event(in *Event, out *api.Event, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Event))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.InvolvedObject, &out.InvolvedObject, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- if err := Convert_v1_EventSource_To_api_EventSource(&in.Source, &out.Source, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.FirstTimestamp, &out.FirstTimestamp, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTimestamp, &out.LastTimestamp, s); err != nil {
- return err
- }
- out.Count = int(in.Count)
- out.Type = in.Type
- return nil
-}
-
-func Convert_v1_Event_To_api_Event(in *Event, out *api.Event, s conversion.Scope) error {
- return autoConvert_v1_Event_To_api_Event(in, out, s)
-}
-
-func autoConvert_v1_EventList_To_api_EventList(in *EventList, out *api.EventList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EventList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.Event, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Event_To_api_Event(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_EventList_To_api_EventList(in *EventList, out *api.EventList, s conversion.Scope) error {
- return autoConvert_v1_EventList_To_api_EventList(in, out, s)
-}
-
-func autoConvert_v1_EventSource_To_api_EventSource(in *EventSource, out *api.EventSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*EventSource))(in)
- }
- out.Component = in.Component
- out.Host = in.Host
- return nil
-}
-
-func Convert_v1_EventSource_To_api_EventSource(in *EventSource, out *api.EventSource, s conversion.Scope) error {
- return autoConvert_v1_EventSource_To_api_EventSource(in, out, s)
-}
-
-func autoConvert_v1_ExecAction_To_api_ExecAction(in *ExecAction, out *api.ExecAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ExecAction))(in)
- }
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
- return nil
-}
-
-func Convert_v1_ExecAction_To_api_ExecAction(in *ExecAction, out *api.ExecAction, s conversion.Scope) error {
- return autoConvert_v1_ExecAction_To_api_ExecAction(in, out, s)
-}
-
-func autoConvert_v1_ExportOptions_To_unversioned_ExportOptions(in *ExportOptions, out *unversioned.ExportOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ExportOptions))(in)
- }
- out.Export = in.Export
- out.Exact = in.Exact
- return nil
-}
-
-func Convert_v1_ExportOptions_To_unversioned_ExportOptions(in *ExportOptions, out *unversioned.ExportOptions, s conversion.Scope) error {
- return autoConvert_v1_ExportOptions_To_unversioned_ExportOptions(in, out, s)
-}
-
-func autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in *FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*FCVolumeSource))(in)
- }
- if in.TargetWWNs != nil {
- out.TargetWWNs = make([]string, len(in.TargetWWNs))
- for i := range in.TargetWWNs {
- out.TargetWWNs[i] = in.TargetWWNs[i]
- }
- } else {
- out.TargetWWNs = nil
- }
- if in.Lun != nil {
- out.Lun = new(int)
- *out.Lun = int(*in.Lun)
- } else {
- out.Lun = nil
- }
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in *FCVolumeSource, out *api.FCVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*FlexVolumeSource))(in)
- }
- out.Driver = in.Driver
- out.FSType = in.FSType
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
- if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
- return err
- }
- } else {
- out.SecretRef = nil
- }
- out.ReadOnly = in.ReadOnly
- if in.Options != nil {
- out.Options = make(map[string]string)
- for key, val := range in.Options {
- out.Options[key] = val
- }
- } else {
- out.Options = nil
- }
- return nil
-}
-
-func Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in *FlexVolumeSource, out *api.FlexVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*FlockerVolumeSource))(in)
- }
- out.DatasetName = in.DatasetName
- return nil
-}
-
-func Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in *FlockerVolumeSource, out *api.FlockerVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*GCEPersistentDiskVolumeSource))(in)
- }
- out.PDName = in.PDName
- out.FSType = in.FSType
- out.Partition = int(in.Partition)
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in *GCEPersistentDiskVolumeSource, out *api.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*GitRepoVolumeSource))(in)
- }
- out.Repository = in.Repository
- out.Revision = in.Revision
- out.Directory = in.Directory
- return nil
-}
-
-func Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in *GitRepoVolumeSource, out *api.GitRepoVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*GlusterfsVolumeSource))(in)
- }
- out.EndpointsName = in.EndpointsName
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in *GlusterfsVolumeSource, out *api.GlusterfsVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in *HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HTTPGetAction))(in)
- }
- out.Path = in.Path
- if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
- return err
- }
- out.Host = in.Host
- out.Scheme = api.URIScheme(in.Scheme)
- if in.HTTPHeaders != nil {
- out.HTTPHeaders = make([]api.HTTPHeader, len(in.HTTPHeaders))
- for i := range in.HTTPHeaders {
- if err := Convert_v1_HTTPHeader_To_api_HTTPHeader(&in.HTTPHeaders[i], &out.HTTPHeaders[i], s); err != nil {
- return err
- }
- }
- } else {
- out.HTTPHeaders = nil
- }
- return nil
-}
-
-func Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in *HTTPGetAction, out *api.HTTPGetAction, s conversion.Scope) error {
- return autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction(in, out, s)
-}
-
-func autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in *HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HTTPHeader))(in)
- }
- out.Name = in.Name
- out.Value = in.Value
- return nil
-}
-
-func Convert_v1_HTTPHeader_To_api_HTTPHeader(in *HTTPHeader, out *api.HTTPHeader, s conversion.Scope) error {
- return autoConvert_v1_HTTPHeader_To_api_HTTPHeader(in, out, s)
-}
-
-func autoConvert_v1_Handler_To_api_Handler(in *Handler, out *api.Handler, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Handler))(in)
- }
- // unable to generate simple pointer conversion for v1.ExecAction -> api.ExecAction
- if in.Exec != nil {
- out.Exec = new(api.ExecAction)
- if err := Convert_v1_ExecAction_To_api_ExecAction(in.Exec, out.Exec, s); err != nil {
- return err
- }
- } else {
- out.Exec = nil
- }
- // unable to generate simple pointer conversion for v1.HTTPGetAction -> api.HTTPGetAction
- if in.HTTPGet != nil {
- out.HTTPGet = new(api.HTTPGetAction)
- if err := Convert_v1_HTTPGetAction_To_api_HTTPGetAction(in.HTTPGet, out.HTTPGet, s); err != nil {
- return err
- }
- } else {
- out.HTTPGet = nil
- }
- // unable to generate simple pointer conversion for v1.TCPSocketAction -> api.TCPSocketAction
- if in.TCPSocket != nil {
- out.TCPSocket = new(api.TCPSocketAction)
- if err := Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in.TCPSocket, out.TCPSocket, s); err != nil {
- return err
- }
- } else {
- out.TCPSocket = nil
- }
- return nil
-}
-
-func Convert_v1_Handler_To_api_Handler(in *Handler, out *api.Handler, s conversion.Scope) error {
- return autoConvert_v1_Handler_To_api_Handler(in, out, s)
-}
-
-func autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*HostPathVolumeSource))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in *HostPathVolumeSource, out *api.HostPathVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ISCSIVolumeSource))(in)
- }
- out.TargetPortal = in.TargetPortal
- out.IQN = in.IQN
- out.Lun = int(in.Lun)
- out.ISCSIInterface = in.ISCSIInterface
- out.FSType = in.FSType
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in *ISCSIVolumeSource, out *api.ISCSIVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_KeyToPath_To_api_KeyToPath(in *KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*KeyToPath))(in)
- }
- out.Key = in.Key
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_KeyToPath_To_api_KeyToPath(in *KeyToPath, out *api.KeyToPath, s conversion.Scope) error {
- return autoConvert_v1_KeyToPath_To_api_KeyToPath(in, out, s)
-}
-
-func autoConvert_v1_Lifecycle_To_api_Lifecycle(in *Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Lifecycle))(in)
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PostStart != nil {
- out.PostStart = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PostStart, out.PostStart, s); err != nil {
- return err
- }
- } else {
- out.PostStart = nil
- }
- // unable to generate simple pointer conversion for v1.Handler -> api.Handler
- if in.PreStop != nil {
- out.PreStop = new(api.Handler)
- if err := Convert_v1_Handler_To_api_Handler(in.PreStop, out.PreStop, s); err != nil {
- return err
- }
- } else {
- out.PreStop = nil
- }
- return nil
-}
-
-func Convert_v1_Lifecycle_To_api_Lifecycle(in *Lifecycle, out *api.Lifecycle, s conversion.Scope) error {
- return autoConvert_v1_Lifecycle_To_api_Lifecycle(in, out, s)
-}
-
-func autoConvert_v1_LimitRange_To_api_LimitRange(in *LimitRange, out *api.LimitRange, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LimitRange))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_LimitRangeSpec_To_api_LimitRangeSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_LimitRange_To_api_LimitRange(in *LimitRange, out *api.LimitRange, s conversion.Scope) error {
- return autoConvert_v1_LimitRange_To_api_LimitRange(in, out, s)
-}
-
-func autoConvert_v1_LimitRangeItem_To_api_LimitRangeItem(in *LimitRangeItem, out *api.LimitRangeItem, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LimitRangeItem))(in)
- }
- out.Type = api.LimitType(in.Type)
- if err := s.Convert(&in.Max, &out.Max, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.Min, &out.Min, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.Default, &out.Default, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.DefaultRequest, &out.DefaultRequest, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio, 0); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_LimitRangeItem_To_api_LimitRangeItem(in *LimitRangeItem, out *api.LimitRangeItem, s conversion.Scope) error {
- return autoConvert_v1_LimitRangeItem_To_api_LimitRangeItem(in, out, s)
-}
-
-func autoConvert_v1_LimitRangeList_To_api_LimitRangeList(in *LimitRangeList, out *api.LimitRangeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LimitRangeList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.LimitRange, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_LimitRange_To_api_LimitRange(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_LimitRangeList_To_api_LimitRangeList(in *LimitRangeList, out *api.LimitRangeList, s conversion.Scope) error {
- return autoConvert_v1_LimitRangeList_To_api_LimitRangeList(in, out, s)
-}
-
-func autoConvert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in *LimitRangeSpec, out *api.LimitRangeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LimitRangeSpec))(in)
- }
- if in.Limits != nil {
- out.Limits = make([]api.LimitRangeItem, len(in.Limits))
- for i := range in.Limits {
- if err := Convert_v1_LimitRangeItem_To_api_LimitRangeItem(&in.Limits[i], &out.Limits[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Limits = nil
- }
- return nil
-}
-
-func Convert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in *LimitRangeSpec, out *api.LimitRangeSpec, s conversion.Scope) error {
- return autoConvert_v1_LimitRangeSpec_To_api_LimitRangeSpec(in, out, s)
-}
-
-func autoConvert_v1_List_To_api_List(in *List, out *api.List, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*List))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]runtime.Object, len(in.Items))
- for i := range in.Items {
- if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_List_To_api_List(in *List, out *api.List, s conversion.Scope) error {
- return autoConvert_v1_List_To_api_List(in, out, s)
-}
-
-func autoConvert_v1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ListOptions))(in)
- }
- if err := api.Convert_string_To_labels_Selector(&in.LabelSelector, &out.LabelSelector, s); err != nil {
- return err
- }
- if err := api.Convert_string_To_fields_Selector(&in.FieldSelector, &out.FieldSelector, s); err != nil {
- return err
- }
- out.Watch = in.Watch
- out.ResourceVersion = in.ResourceVersion
- if in.TimeoutSeconds != nil {
- out.TimeoutSeconds = new(int64)
- *out.TimeoutSeconds = *in.TimeoutSeconds
- } else {
- out.TimeoutSeconds = nil
- }
- return nil
-}
-
-func Convert_v1_ListOptions_To_api_ListOptions(in *ListOptions, out *api.ListOptions, s conversion.Scope) error {
- return autoConvert_v1_ListOptions_To_api_ListOptions(in, out, s)
-}
-
-func autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LoadBalancerIngress))(in)
- }
- out.IP = in.IP
- out.Hostname = in.Hostname
- return nil
-}
-
-func Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in *LoadBalancerIngress, out *api.LoadBalancerIngress, s conversion.Scope) error {
- return autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(in, out, s)
-}
-
-func autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LoadBalancerStatus))(in)
- }
- if in.Ingress != nil {
- out.Ingress = make([]api.LoadBalancerIngress, len(in.Ingress))
- for i := range in.Ingress {
- if err := Convert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Ingress = nil
- }
- return nil
-}
-
-func Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in *LoadBalancerStatus, out *api.LoadBalancerStatus, s conversion.Scope) error {
- return autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(in, out, s)
-}
-
-func autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in *LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LocalObjectReference))(in)
- }
- out.Name = in.Name
- return nil
-}
-
-func Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in *LocalObjectReference, out *api.LocalObjectReference, s conversion.Scope) error {
- return autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference(in, out, s)
-}
-
-func autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NFSVolumeSource))(in)
- }
- out.Server = in.Server
- out.Path = in.Path
- out.ReadOnly = in.ReadOnly
- return nil
-}
-
-func Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in *NFSVolumeSource, out *api.NFSVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in, out, s)
-}
-
-func autoConvert_v1_Namespace_To_api_Namespace(in *Namespace, out *api.Namespace, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Namespace))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_NamespaceSpec_To_api_NamespaceSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_NamespaceStatus_To_api_NamespaceStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Namespace_To_api_Namespace(in *Namespace, out *api.Namespace, s conversion.Scope) error {
- return autoConvert_v1_Namespace_To_api_Namespace(in, out, s)
-}
-
-func autoConvert_v1_NamespaceList_To_api_NamespaceList(in *NamespaceList, out *api.NamespaceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NamespaceList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.Namespace, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Namespace_To_api_Namespace(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_NamespaceList_To_api_NamespaceList(in *NamespaceList, out *api.NamespaceList, s conversion.Scope) error {
- return autoConvert_v1_NamespaceList_To_api_NamespaceList(in, out, s)
-}
-
-func autoConvert_v1_NamespaceSpec_To_api_NamespaceSpec(in *NamespaceSpec, out *api.NamespaceSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NamespaceSpec))(in)
- }
- if in.Finalizers != nil {
- out.Finalizers = make([]api.FinalizerName, len(in.Finalizers))
- for i := range in.Finalizers {
- out.Finalizers[i] = api.FinalizerName(in.Finalizers[i])
- }
- } else {
- out.Finalizers = nil
- }
- return nil
-}
-
-func Convert_v1_NamespaceSpec_To_api_NamespaceSpec(in *NamespaceSpec, out *api.NamespaceSpec, s conversion.Scope) error {
- return autoConvert_v1_NamespaceSpec_To_api_NamespaceSpec(in, out, s)
-}
-
-func autoConvert_v1_NamespaceStatus_To_api_NamespaceStatus(in *NamespaceStatus, out *api.NamespaceStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NamespaceStatus))(in)
- }
- out.Phase = api.NamespacePhase(in.Phase)
- return nil
-}
-
-func Convert_v1_NamespaceStatus_To_api_NamespaceStatus(in *NamespaceStatus, out *api.NamespaceStatus, s conversion.Scope) error {
- return autoConvert_v1_NamespaceStatus_To_api_NamespaceStatus(in, out, s)
-}
-
-func autoConvert_v1_Node_To_api_Node(in *Node, out *api.Node, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Node))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_NodeSpec_To_api_NodeSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_NodeStatus_To_api_NodeStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_Node_To_api_Node(in *Node, out *api.Node, s conversion.Scope) error {
- return autoConvert_v1_Node_To_api_Node(in, out, s)
-}
-
-func autoConvert_v1_NodeAddress_To_api_NodeAddress(in *NodeAddress, out *api.NodeAddress, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeAddress))(in)
- }
- out.Type = api.NodeAddressType(in.Type)
- out.Address = in.Address
- return nil
-}
-
-func Convert_v1_NodeAddress_To_api_NodeAddress(in *NodeAddress, out *api.NodeAddress, s conversion.Scope) error {
- return autoConvert_v1_NodeAddress_To_api_NodeAddress(in, out, s)
-}
-
-func autoConvert_v1_NodeCondition_To_api_NodeCondition(in *NodeCondition, out *api.NodeCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeCondition))(in)
- }
- out.Type = api.NodeConditionType(in.Type)
- out.Status = api.ConditionStatus(in.Status)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastHeartbeatTime, &out.LastHeartbeatTime, s); err != nil {
- return err
- }
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
- return err
- }
- out.Reason = in.Reason
- out.Message = in.Message
- return nil
-}
-
-func Convert_v1_NodeCondition_To_api_NodeCondition(in *NodeCondition, out *api.NodeCondition, s conversion.Scope) error {
- return autoConvert_v1_NodeCondition_To_api_NodeCondition(in, out, s)
-}
-
-func autoConvert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in *NodeDaemonEndpoints, out *api.NodeDaemonEndpoints, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeDaemonEndpoints))(in)
- }
- if err := Convert_v1_DaemonEndpoint_To_api_DaemonEndpoint(&in.KubeletEndpoint, &out.KubeletEndpoint, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in *NodeDaemonEndpoints, out *api.NodeDaemonEndpoints, s conversion.Scope) error {
- return autoConvert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(in, out, s)
-}
-
-func autoConvert_v1_NodeList_To_api_NodeList(in *NodeList, out *api.NodeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.Node, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Node_To_api_Node(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_NodeList_To_api_NodeList(in *NodeList, out *api.NodeList, s conversion.Scope) error {
- return autoConvert_v1_NodeList_To_api_NodeList(in, out, s)
-}
-
-func autoConvert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in *NodeProxyOptions, out *api.NodeProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeProxyOptions))(in)
- }
- out.Path = in.Path
- return nil
-}
-
-func Convert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in *NodeProxyOptions, out *api.NodeProxyOptions, s conversion.Scope) error {
- return autoConvert_v1_NodeProxyOptions_To_api_NodeProxyOptions(in, out, s)
-}
-
-func autoConvert_v1_NodeSpec_To_api_NodeSpec(in *NodeSpec, out *api.NodeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeSpec))(in)
- }
- out.PodCIDR = in.PodCIDR
- out.ExternalID = in.ExternalID
- out.ProviderID = in.ProviderID
- out.Unschedulable = in.Unschedulable
- return nil
-}
-
-func Convert_v1_NodeSpec_To_api_NodeSpec(in *NodeSpec, out *api.NodeSpec, s conversion.Scope) error {
- return autoConvert_v1_NodeSpec_To_api_NodeSpec(in, out, s)
-}
-
-func autoConvert_v1_NodeStatus_To_api_NodeStatus(in *NodeStatus, out *api.NodeStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeStatus))(in)
- }
- if err := s.Convert(&in.Capacity, &out.Capacity, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.Allocatable, &out.Allocatable, 0); err != nil {
- return err
- }
- out.Phase = api.NodePhase(in.Phase)
- if in.Conditions != nil {
- out.Conditions = make([]api.NodeCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_v1_NodeCondition_To_api_NodeCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Conditions = nil
- }
- if in.Addresses != nil {
- out.Addresses = make([]api.NodeAddress, len(in.Addresses))
- for i := range in.Addresses {
- if err := Convert_v1_NodeAddress_To_api_NodeAddress(&in.Addresses[i], &out.Addresses[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Addresses = nil
- }
- if err := Convert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints(&in.DaemonEndpoints, &out.DaemonEndpoints, s); err != nil {
- return err
- }
- if err := Convert_v1_NodeSystemInfo_To_api_NodeSystemInfo(&in.NodeInfo, &out.NodeInfo, s); err != nil {
- return err
- }
- if in.Images != nil {
- out.Images = make([]api.ContainerImage, len(in.Images))
- for i := range in.Images {
- if err := Convert_v1_ContainerImage_To_api_ContainerImage(&in.Images[i], &out.Images[i], s); err != nil {
+func autoConvert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *api.PersistentVolumeSpec, out *PersistentVolumeSpec, s conversion.Scope) error {
+ if in.Capacity != nil {
+ in, out := &in.Capacity, &out.Capacity
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
return err
- }
- }
- } else {
- out.Images = nil
- }
- return nil
-}
-
-func Convert_v1_NodeStatus_To_api_NodeStatus(in *NodeStatus, out *api.NodeStatus, s conversion.Scope) error {
- return autoConvert_v1_NodeStatus_To_api_NodeStatus(in, out, s)
-}
-
-func autoConvert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in *NodeSystemInfo, out *api.NodeSystemInfo, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*NodeSystemInfo))(in)
- }
- out.MachineID = in.MachineID
- out.SystemUUID = in.SystemUUID
- out.BootID = in.BootID
- out.KernelVersion = in.KernelVersion
- out.OSImage = in.OSImage
- out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
- out.KubeletVersion = in.KubeletVersion
- out.KubeProxyVersion = in.KubeProxyVersion
- return nil
-}
-
-func Convert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in *NodeSystemInfo, out *api.NodeSystemInfo, s conversion.Scope) error {
- return autoConvert_v1_NodeSystemInfo_To_api_NodeSystemInfo(in, out, s)
-}
-
-func autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ObjectFieldSelector))(in)
- }
- out.APIVersion = in.APIVersion
- out.FieldPath = in.FieldPath
- return nil
-}
-
-func Convert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in *ObjectFieldSelector, out *api.ObjectFieldSelector, s conversion.Scope) error {
- return autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector(in, out, s)
-}
-
-func autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in *ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ObjectMeta))(in)
- }
- out.Name = in.Name
- out.GenerateName = in.GenerateName
- out.Namespace = in.Namespace
- out.SelfLink = in.SelfLink
- out.UID = in.UID
- out.ResourceVersion = in.ResourceVersion
- out.Generation = in.Generation
- if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.CreationTimestamp, &out.CreationTimestamp, s); err != nil {
- return err
- }
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.DeletionTimestamp != nil {
- out.DeletionTimestamp = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.DeletionTimestamp, out.DeletionTimestamp, s); err != nil {
- return err
+ }
+ (*out)[ResourceName(key)] = *newVal
}
} else {
- out.DeletionTimestamp = nil
+ out.Capacity = nil
}
- if in.DeletionGracePeriodSeconds != nil {
- out.DeletionGracePeriodSeconds = new(int64)
- *out.DeletionGracePeriodSeconds = *in.DeletionGracePeriodSeconds
- } else {
- out.DeletionGracePeriodSeconds = nil
+ if err := Convert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
+ return err
}
- if in.Labels != nil {
- out.Labels = make(map[string]string)
- for key, val := range in.Labels {
- out.Labels[key] = val
+ if in.AccessModes != nil {
+ in, out := &in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(*in))
+ for i := range *in {
+ (*out)[i] = PersistentVolumeAccessMode((*in)[i])
}
} else {
- out.Labels = nil
+ out.AccessModes = nil
}
- if in.Annotations != nil {
- out.Annotations = make(map[string]string)
- for key, val := range in.Annotations {
- out.Annotations[key] = val
+ if in.ClaimRef != nil {
+ in, out := &in.ClaimRef, &out.ClaimRef
+ *out = new(ObjectReference)
+ if err := Convert_api_ObjectReference_To_v1_ObjectReference(*in, *out, s); err != nil {
+ return err
}
} else {
- out.Annotations = nil
+ out.ClaimRef = nil
}
+ out.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
return nil
}
-func Convert_v1_ObjectMeta_To_api_ObjectMeta(in *ObjectMeta, out *api.ObjectMeta, s conversion.Scope) error {
- return autoConvert_v1_ObjectMeta_To_api_ObjectMeta(in, out, s)
+func Convert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *api.PersistentVolumeSpec, out *PersistentVolumeSpec, s conversion.Scope) error {
+ return autoConvert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in, out, s)
}
-func autoConvert_v1_ObjectReference_To_api_ObjectReference(in *ObjectReference, out *api.ObjectReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ObjectReference))(in)
- }
- out.Kind = in.Kind
- out.Namespace = in.Namespace
- out.Name = in.Name
- out.UID = in.UID
- out.APIVersion = in.APIVersion
- out.ResourceVersion = in.ResourceVersion
- out.FieldPath = in.FieldPath
+func autoConvert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in *PersistentVolumeStatus, out *api.PersistentVolumeStatus, s conversion.Scope) error {
+ out.Phase = api.PersistentVolumePhase(in.Phase)
+ out.Message = in.Message
+ out.Reason = in.Reason
return nil
}
-func Convert_v1_ObjectReference_To_api_ObjectReference(in *ObjectReference, out *api.ObjectReference, s conversion.Scope) error {
- return autoConvert_v1_ObjectReference_To_api_ObjectReference(in, out, s)
+func Convert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in *PersistentVolumeStatus, out *api.PersistentVolumeStatus, s conversion.Scope) error {
+ return autoConvert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in, out, s)
}
-func autoConvert_v1_PersistentVolume_To_api_PersistentVolume(in *PersistentVolume, out *api.PersistentVolume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolume))(in)
+func autoConvert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *api.PersistentVolumeStatus, out *PersistentVolumeStatus, s conversion.Scope) error {
+ out.Phase = PersistentVolumePhase(in.Phase)
+ out.Message = in.Message
+ out.Reason = in.Reason
+ return nil
+}
+
+func Convert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *api.PersistentVolumeStatus, out *PersistentVolumeStatus, s conversion.Scope) error {
+ return autoConvert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in, out, s)
+}
+
+func autoConvert_v1_Pod_To_api_Pod(in *Pod, out *api.Pod, s conversion.Scope) error {
+ SetDefaults_Pod(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if err := Convert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
+ if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
return err
}
- if err := Convert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(&in.Status, &out.Status, s); err != nil {
+ if err := Convert_v1_PodStatus_To_api_PodStatus(&in.Status, &out.Status, s); err != nil {
return err
}
return nil
}
-func Convert_v1_PersistentVolume_To_api_PersistentVolume(in *PersistentVolume, out *api.PersistentVolume, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolume_To_api_PersistentVolume(in, out, s)
-}
-
-func autoConvert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in *PersistentVolumeClaim, out *api.PersistentVolumeClaim, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeClaim))(in)
+func autoConvert_api_Pod_To_v1_Pod(in *api.Pod, out *Pod, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if err := Convert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
+ if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
return err
}
- if err := Convert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(&in.Status, &out.Status, s); err != nil {
+ if err := Convert_api_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
return err
}
return nil
}
-func Convert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in *PersistentVolumeClaim, out *api.PersistentVolumeClaim, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(in, out, s)
-}
-
-func autoConvert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in *PersistentVolumeClaimList, out *api.PersistentVolumeClaimList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeClaimList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.PersistentVolumeClaim, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim(&in.Items[i], &out.Items[i], s); err != nil {
+func autoConvert_v1_PodAffinity_To_api_PodAffinity(in *PodAffinity, out *api.PodAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]api.PodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PodAffinityTerm_To_api_PodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
- out.Items = nil
- }
- return nil
-}
-
-func Convert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in *PersistentVolumeClaimList, out *api.PersistentVolumeClaimList, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList(in, out, s)
-}
-
-func autoConvert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in *PersistentVolumeClaimSpec, out *api.PersistentVolumeClaimSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeClaimSpec))(in)
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
}
- if in.AccessModes != nil {
- out.AccessModes = make([]api.PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = api.PersistentVolumeAccessMode(in.AccessModes[i])
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]api.WeightedPodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.AccessModes = nil
- }
- if err := Convert_v1_ResourceRequirements_To_api_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
- return err
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
}
- out.VolumeName = in.VolumeName
return nil
}
-func Convert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in *PersistentVolumeClaimSpec, out *api.PersistentVolumeClaimSpec, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec(in, out, s)
+func Convert_v1_PodAffinity_To_api_PodAffinity(in *PodAffinity, out *api.PodAffinity, s conversion.Scope) error {
+ return autoConvert_v1_PodAffinity_To_api_PodAffinity(in, out, s)
}
-func autoConvert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in *PersistentVolumeClaimStatus, out *api.PersistentVolumeClaimStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeClaimStatus))(in)
- }
- out.Phase = api.PersistentVolumeClaimPhase(in.Phase)
- if in.AccessModes != nil {
- out.AccessModes = make([]api.PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = api.PersistentVolumeAccessMode(in.AccessModes[i])
+func autoConvert_api_PodAffinity_To_v1_PodAffinity(in *api.PodAffinity, out *PodAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_PodAffinityTerm_To_v1_PodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.AccessModes = nil
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
}
- if err := s.Convert(&in.Capacity, &out.Capacity, 0); err != nil {
- return err
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
}
return nil
}
-func Convert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in *PersistentVolumeClaimStatus, out *api.PersistentVolumeClaimStatus, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus(in, out, s)
+func Convert_api_PodAffinity_To_v1_PodAffinity(in *api.PodAffinity, out *PodAffinity, s conversion.Scope) error {
+ return autoConvert_api_PodAffinity_To_v1_PodAffinity(in, out, s)
}
-func autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeClaimVolumeSource))(in)
- }
- out.ClaimName = in.ClaimName
- out.ReadOnly = in.ReadOnly
+func autoConvert_v1_PodAffinityTerm_To_api_PodAffinityTerm(in *PodAffinityTerm, out *api.PodAffinityTerm, s conversion.Scope) error {
+ out.LabelSelector = in.LabelSelector
+ out.Namespaces = in.Namespaces
+ out.TopologyKey = in.TopologyKey
return nil
}
-func Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in *PersistentVolumeClaimVolumeSource, out *api.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in, out, s)
+func Convert_v1_PodAffinityTerm_To_api_PodAffinityTerm(in *PodAffinityTerm, out *api.PodAffinityTerm, s conversion.Scope) error {
+ return autoConvert_v1_PodAffinityTerm_To_api_PodAffinityTerm(in, out, s)
}
-func autoConvert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in *PersistentVolumeList, out *api.PersistentVolumeList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.PersistentVolume, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_PersistentVolume_To_api_PersistentVolume(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
+func autoConvert_api_PodAffinityTerm_To_v1_PodAffinityTerm(in *api.PodAffinityTerm, out *PodAffinityTerm, s conversion.Scope) error {
+ out.LabelSelector = in.LabelSelector
+ out.Namespaces = in.Namespaces
+ out.TopologyKey = in.TopologyKey
return nil
}
-func Convert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in *PersistentVolumeList, out *api.PersistentVolumeList, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeList_To_api_PersistentVolumeList(in, out, s)
+func Convert_api_PodAffinityTerm_To_v1_PodAffinityTerm(in *api.PodAffinityTerm, out *PodAffinityTerm, s conversion.Scope) error {
+ return autoConvert_api_PodAffinityTerm_To_v1_PodAffinityTerm(in, out, s)
}
-func autoConvert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in *PersistentVolumeSource, out *api.PersistentVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeSource))(in)
- }
- // unable to generate simple pointer conversion for v1.GCEPersistentDiskVolumeSource -> api.GCEPersistentDiskVolumeSource
- if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(api.GCEPersistentDiskVolumeSource)
- if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
- return err
- }
- } else {
- out.GCEPersistentDisk = nil
- }
- // unable to generate simple pointer conversion for v1.AWSElasticBlockStoreVolumeSource -> api.AWSElasticBlockStoreVolumeSource
- if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(api.AWSElasticBlockStoreVolumeSource)
- if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
- return err
- }
- } else {
- out.AWSElasticBlockStore = nil
- }
- // unable to generate simple pointer conversion for v1.HostPathVolumeSource -> api.HostPathVolumeSource
- if in.HostPath != nil {
- out.HostPath = new(api.HostPathVolumeSource)
- if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
- return err
- }
- } else {
- out.HostPath = nil
- }
- // unable to generate simple pointer conversion for v1.GlusterfsVolumeSource -> api.GlusterfsVolumeSource
- if in.Glusterfs != nil {
- out.Glusterfs = new(api.GlusterfsVolumeSource)
- if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
- return err
- }
- } else {
- out.Glusterfs = nil
- }
- // unable to generate simple pointer conversion for v1.NFSVolumeSource -> api.NFSVolumeSource
- if in.NFS != nil {
- out.NFS = new(api.NFSVolumeSource)
- if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
- return err
- }
- } else {
- out.NFS = nil
- }
- // unable to generate simple pointer conversion for v1.RBDVolumeSource -> api.RBDVolumeSource
- if in.RBD != nil {
- out.RBD = new(api.RBDVolumeSource)
- if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
- return err
- }
- } else {
- out.RBD = nil
- }
- // unable to generate simple pointer conversion for v1.ISCSIVolumeSource -> api.ISCSIVolumeSource
- if in.ISCSI != nil {
- out.ISCSI = new(api.ISCSIVolumeSource)
- if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
- return err
- }
- } else {
- out.ISCSI = nil
- }
- // unable to generate simple pointer conversion for v1.CinderVolumeSource -> api.CinderVolumeSource
- if in.Cinder != nil {
- out.Cinder = new(api.CinderVolumeSource)
- if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
- return err
- }
- } else {
- out.Cinder = nil
- }
- // unable to generate simple pointer conversion for v1.CephFSVolumeSource -> api.CephFSVolumeSource
- if in.CephFS != nil {
- out.CephFS = new(api.CephFSVolumeSource)
- if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
- return err
- }
- } else {
- out.CephFS = nil
- }
- // unable to generate simple pointer conversion for v1.FCVolumeSource -> api.FCVolumeSource
- if in.FC != nil {
- out.FC = new(api.FCVolumeSource)
- if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in.FC, out.FC, s); err != nil {
- return err
- }
- } else {
- out.FC = nil
- }
- // unable to generate simple pointer conversion for v1.FlockerVolumeSource -> api.FlockerVolumeSource
- if in.Flocker != nil {
- out.Flocker = new(api.FlockerVolumeSource)
- if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
- return err
- }
- } else {
- out.Flocker = nil
- }
- // unable to generate simple pointer conversion for v1.FlexVolumeSource -> api.FlexVolumeSource
- if in.FlexVolume != nil {
- out.FlexVolume = new(api.FlexVolumeSource)
- if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
- return err
+func autoConvert_v1_PodAntiAffinity_To_api_PodAntiAffinity(in *PodAntiAffinity, out *api.PodAntiAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]api.PodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PodAffinityTerm_To_api_PodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.FlexVolume = nil
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
}
- // unable to generate simple pointer conversion for v1.AzureFileVolumeSource -> api.AzureFileVolumeSource
- if in.AzureFile != nil {
- out.AzureFile = new(api.AzureFileVolumeSource)
- if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
- return err
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]api.WeightedPodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.AzureFile = nil
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
}
return nil
}
-func Convert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in *PersistentVolumeSource, out *api.PersistentVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(in, out, s)
+func Convert_v1_PodAntiAffinity_To_api_PodAntiAffinity(in *PodAntiAffinity, out *api.PodAntiAffinity, s conversion.Scope) error {
+ return autoConvert_v1_PodAntiAffinity_To_api_PodAntiAffinity(in, out, s)
}
-func autoConvert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in *PersistentVolumeSpec, out *api.PersistentVolumeSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeSpec))(in)
- }
- if err := s.Convert(&in.Capacity, &out.Capacity, 0); err != nil {
- return err
- }
- if err := Convert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
- return err
- }
- if in.AccessModes != nil {
- out.AccessModes = make([]api.PersistentVolumeAccessMode, len(in.AccessModes))
- for i := range in.AccessModes {
- out.AccessModes[i] = api.PersistentVolumeAccessMode(in.AccessModes[i])
+func autoConvert_api_PodAntiAffinity_To_v1_PodAntiAffinity(in *api.PodAntiAffinity, out *PodAntiAffinity, s conversion.Scope) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_PodAffinityTerm_To_v1_PodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.AccessModes = nil
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
}
- // unable to generate simple pointer conversion for v1.ObjectReference -> api.ObjectReference
- if in.ClaimRef != nil {
- out.ClaimRef = new(api.ObjectReference)
- if err := Convert_v1_ObjectReference_To_api_ObjectReference(in.ClaimRef, out.ClaimRef, s); err != nil {
- return err
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(*in))
+ for i := range *in {
+ if err := Convert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.ClaimRef = nil
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
}
- out.PersistentVolumeReclaimPolicy = api.PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
return nil
}
-func Convert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in *PersistentVolumeSpec, out *api.PersistentVolumeSpec, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec(in, out, s)
+func Convert_api_PodAntiAffinity_To_v1_PodAntiAffinity(in *api.PodAntiAffinity, out *PodAntiAffinity, s conversion.Scope) error {
+ return autoConvert_api_PodAntiAffinity_To_v1_PodAntiAffinity(in, out, s)
}
-func autoConvert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in *PersistentVolumeStatus, out *api.PersistentVolumeStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PersistentVolumeStatus))(in)
+func autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions(in *PodAttachOptions, out *api.PodAttachOptions, s conversion.Scope) error {
+ SetDefaults_PodAttachOptions(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- out.Phase = api.PersistentVolumePhase(in.Phase)
- out.Message = in.Message
- out.Reason = in.Reason
+ out.Stdin = in.Stdin
+ out.Stdout = in.Stdout
+ out.Stderr = in.Stderr
+ out.TTY = in.TTY
+ out.Container = in.Container
return nil
}
-func Convert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in *PersistentVolumeStatus, out *api.PersistentVolumeStatus, s conversion.Scope) error {
- return autoConvert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus(in, out, s)
-}
-
-func autoConvert_v1_Pod_To_api_Pod(in *Pod, out *api.Pod, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Pod))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
- return err
- }
- if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
- return err
- }
- if err := Convert_v1_PodStatus_To_api_PodStatus(&in.Status, &out.Status, s); err != nil {
- return err
- }
- return nil
+func Convert_v1_PodAttachOptions_To_api_PodAttachOptions(in *PodAttachOptions, out *api.PodAttachOptions, s conversion.Scope) error {
+ return autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions(in, out, s)
}
-func autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions(in *PodAttachOptions, out *api.PodAttachOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodAttachOptions))(in)
+func autoConvert_api_PodAttachOptions_To_v1_PodAttachOptions(in *api.PodAttachOptions, out *PodAttachOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
out.Stdin = in.Stdin
out.Stdout = in.Stdout
@@ -5372,14 +4580,11 @@ func autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions(in *PodAttachOption
return nil
}
-func Convert_v1_PodAttachOptions_To_api_PodAttachOptions(in *PodAttachOptions, out *api.PodAttachOptions, s conversion.Scope) error {
- return autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions(in, out, s)
+func Convert_api_PodAttachOptions_To_v1_PodAttachOptions(in *api.PodAttachOptions, out *PodAttachOptions, s conversion.Scope) error {
+ return autoConvert_api_PodAttachOptions_To_v1_PodAttachOptions(in, out, s)
}
func autoConvert_v1_PodCondition_To_api_PodCondition(in *PodCondition, out *api.PodCondition, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodCondition))(in)
- }
out.Type = api.PodConditionType(in.Type)
out.Status = api.ConditionStatus(in.Status)
if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
@@ -5397,23 +4602,35 @@ func Convert_v1_PodCondition_To_api_PodCondition(in *PodCondition, out *api.PodC
return autoConvert_v1_PodCondition_To_api_PodCondition(in, out, s)
}
+func autoConvert_api_PodCondition_To_v1_PodCondition(in *api.PodCondition, out *PodCondition, s conversion.Scope) error {
+ out.Type = PodConditionType(in.Type)
+ out.Status = ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_api_PodCondition_To_v1_PodCondition(in *api.PodCondition, out *PodCondition, s conversion.Scope) error {
+ return autoConvert_api_PodCondition_To_v1_PodCondition(in, out, s)
+}
+
func autoConvert_v1_PodExecOptions_To_api_PodExecOptions(in *PodExecOptions, out *api.PodExecOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodExecOptions))(in)
+ SetDefaults_PodExecOptions(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
out.Stdin = in.Stdin
out.Stdout = in.Stdout
out.Stderr = in.Stderr
out.TTY = in.TTY
out.Container = in.Container
- if in.Command != nil {
- out.Command = make([]string, len(in.Command))
- for i := range in.Command {
- out.Command[i] = in.Command[i]
- }
- } else {
- out.Command = nil
- }
+ out.Command = in.Command
return nil
}
@@ -5421,17 +4638,35 @@ func Convert_v1_PodExecOptions_To_api_PodExecOptions(in *PodExecOptions, out *ap
return autoConvert_v1_PodExecOptions_To_api_PodExecOptions(in, out, s)
}
+func autoConvert_api_PodExecOptions_To_v1_PodExecOptions(in *api.PodExecOptions, out *PodExecOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Stdin = in.Stdin
+ out.Stdout = in.Stdout
+ out.Stderr = in.Stderr
+ out.TTY = in.TTY
+ out.Container = in.Container
+ out.Command = in.Command
+ return nil
+}
+
+func Convert_api_PodExecOptions_To_v1_PodExecOptions(in *api.PodExecOptions, out *PodExecOptions, s conversion.Scope) error {
+ return autoConvert_api_PodExecOptions_To_v1_PodExecOptions(in, out, s)
+}
+
func autoConvert_v1_PodList_To_api_PodList(in *PodList, out *api.PodList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.Pod, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Pod_To_api_Pod(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Pod, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Pod_To_api_Pod(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -5445,41 +4680,43 @@ func Convert_v1_PodList_To_api_PodList(in *PodList, out *api.PodList, s conversi
return autoConvert_v1_PodList_To_api_PodList(in, out, s)
}
-func autoConvert_v1_PodLogOptions_To_api_PodLogOptions(in *PodLogOptions, out *api.PodLogOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodLogOptions))(in)
+func autoConvert_api_PodList_To_v1_PodList(in *api.PodList, out *PodList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- out.Container = in.Container
- out.Follow = in.Follow
- out.Previous = in.Previous
- if in.SinceSeconds != nil {
- out.SinceSeconds = new(int64)
- *out.SinceSeconds = *in.SinceSeconds
- } else {
- out.SinceSeconds = nil
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
}
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.SinceTime != nil {
- out.SinceTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.SinceTime, out.SinceTime, s); err != nil {
- return err
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Pod, len(*in))
+ for i := range *in {
+ if err := Convert_api_Pod_To_v1_Pod(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.SinceTime = nil
- }
- out.Timestamps = in.Timestamps
- if in.TailLines != nil {
- out.TailLines = new(int64)
- *out.TailLines = *in.TailLines
- } else {
- out.TailLines = nil
+ out.Items = nil
}
- if in.LimitBytes != nil {
- out.LimitBytes = new(int64)
- *out.LimitBytes = *in.LimitBytes
- } else {
- out.LimitBytes = nil
+ return nil
+}
+
+func Convert_api_PodList_To_v1_PodList(in *api.PodList, out *PodList, s conversion.Scope) error {
+ return autoConvert_api_PodList_To_v1_PodList(in, out, s)
+}
+
+func autoConvert_v1_PodLogOptions_To_api_PodLogOptions(in *PodLogOptions, out *api.PodLogOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
+ out.Container = in.Container
+ out.Follow = in.Follow
+ out.Previous = in.Previous
+ out.SinceSeconds = in.SinceSeconds
+ out.SinceTime = in.SinceTime
+ out.Timestamps = in.Timestamps
+ out.TailLines = in.TailLines
+ out.LimitBytes = in.LimitBytes
return nil
}
@@ -5487,9 +4724,28 @@ func Convert_v1_PodLogOptions_To_api_PodLogOptions(in *PodLogOptions, out *api.P
return autoConvert_v1_PodLogOptions_To_api_PodLogOptions(in, out, s)
}
+func autoConvert_api_PodLogOptions_To_v1_PodLogOptions(in *api.PodLogOptions, out *PodLogOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Container = in.Container
+ out.Follow = in.Follow
+ out.Previous = in.Previous
+ out.SinceSeconds = in.SinceSeconds
+ out.SinceTime = in.SinceTime
+ out.Timestamps = in.Timestamps
+ out.TailLines = in.TailLines
+ out.LimitBytes = in.LimitBytes
+ return nil
+}
+
+func Convert_api_PodLogOptions_To_v1_PodLogOptions(in *api.PodLogOptions, out *PodLogOptions, s conversion.Scope) error {
+ return autoConvert_api_PodLogOptions_To_v1_PodLogOptions(in, out, s)
+}
+
func autoConvert_v1_PodProxyOptions_To_api_PodProxyOptions(in *PodProxyOptions, out *api.PodProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodProxyOptions))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
out.Path = in.Path
return nil
@@ -5499,88 +4755,108 @@ func Convert_v1_PodProxyOptions_To_api_PodProxyOptions(in *PodProxyOptions, out
return autoConvert_v1_PodProxyOptions_To_api_PodProxyOptions(in, out, s)
}
-func autoConvert_v1_PodSpec_To_api_PodSpec(in *PodSpec, out *api.PodSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodSpec))(in)
+func autoConvert_api_PodProxyOptions_To_v1_PodProxyOptions(in *api.PodProxyOptions, out *PodProxyOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func Convert_api_PodProxyOptions_To_v1_PodProxyOptions(in *api.PodProxyOptions, out *PodProxyOptions, s conversion.Scope) error {
+ return autoConvert_api_PodProxyOptions_To_v1_PodProxyOptions(in, out, s)
+}
+
+func autoConvert_v1_PodSecurityContext_To_api_PodSecurityContext(in *PodSecurityContext, out *api.PodSecurityContext, s conversion.Scope) error {
+ if in.SELinuxOptions != nil {
+ in, out := &in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(api.SELinuxOptions)
+ if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
}
+ out.RunAsUser = in.RunAsUser
+ out.RunAsNonRoot = in.RunAsNonRoot
+ out.SupplementalGroups = in.SupplementalGroups
+ out.FSGroup = in.FSGroup
+ return nil
+}
+
+func autoConvert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *PodSpec, s conversion.Scope) error {
if in.Volumes != nil {
- out.Volumes = make([]api.Volume, len(in.Volumes))
- for i := range in.Volumes {
- if err := Convert_v1_Volume_To_api_Volume(&in.Volumes[i], &out.Volumes[i], s); err != nil {
+ in, out := &in.Volumes, &out.Volumes
+ *out = make([]Volume, len(*in))
+ for i := range *in {
+ if err := Convert_api_Volume_To_v1_Volume(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
out.Volumes = nil
}
- if in.Containers != nil {
- out.Containers = make([]api.Container, len(in.Containers))
- for i := range in.Containers {
- if err := Convert_v1_Container_To_api_Container(&in.Containers[i], &out.Containers[i], s); err != nil {
+ if in.InitContainers != nil {
+ in, out := &in.InitContainers, &out.InitContainers
+ *out = make([]Container, len(*in))
+ for i := range *in {
+ if err := Convert_api_Container_To_v1_Container(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
- out.Containers = nil
- }
- out.RestartPolicy = api.RestartPolicy(in.RestartPolicy)
- if in.TerminationGracePeriodSeconds != nil {
- out.TerminationGracePeriodSeconds = new(int64)
- *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds
- } else {
- out.TerminationGracePeriodSeconds = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
+ out.InitContainers = nil
}
- out.DNSPolicy = api.DNSPolicy(in.DNSPolicy)
- if in.NodeSelector != nil {
- out.NodeSelector = make(map[string]string)
- for key, val := range in.NodeSelector {
- out.NodeSelector[key] = val
+ if in.Containers != nil {
+ in, out := &in.Containers, &out.Containers
+ *out = make([]Container, len(*in))
+ for i := range *in {
+ if err := Convert_api_Container_To_v1_Container(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.NodeSelector = nil
+ out.Containers = nil
}
+ out.RestartPolicy = RestartPolicy(in.RestartPolicy)
+ out.TerminationGracePeriodSeconds = in.TerminationGracePeriodSeconds
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ out.DNSPolicy = DNSPolicy(in.DNSPolicy)
+ out.NodeSelector = in.NodeSelector
out.ServiceAccountName = in.ServiceAccountName
- // in.DeprecatedServiceAccount has no peer in out
out.NodeName = in.NodeName
- // in.HostNetwork has no peer in out
- // in.HostPID has no peer in out
- // in.HostIPC has no peer in out
- // unable to generate simple pointer conversion for v1.PodSecurityContext -> api.PodSecurityContext
if in.SecurityContext != nil {
- if err := s.Convert(&in.SecurityContext, &out.SecurityContext, 0); err != nil {
+ in, out := &in.SecurityContext, &out.SecurityContext
+ *out = new(PodSecurityContext)
+ if err := Convert_api_PodSecurityContext_To_v1_PodSecurityContext(*in, *out, s); err != nil {
return err
}
} else {
out.SecurityContext = nil
}
if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]api.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
+ in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
+ *out = make([]LocalObjectReference, len(*in))
+ for i := range *in {
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
out.ImagePullSecrets = nil
}
+ out.Hostname = in.Hostname
+ out.Subdomain = in.Subdomain
return nil
}
func autoConvert_v1_PodStatus_To_api_PodStatus(in *PodStatus, out *api.PodStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodStatus))(in)
- }
out.Phase = api.PodPhase(in.Phase)
if in.Conditions != nil {
- out.Conditions = make([]api.PodCondition, len(in.Conditions))
- for i := range in.Conditions {
- if err := Convert_v1_PodCondition_To_api_PodCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]api.PodCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PodCondition_To_api_PodCondition(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -5591,19 +4867,23 @@ func autoConvert_v1_PodStatus_To_api_PodStatus(in *PodStatus, out *api.PodStatus
out.Reason = in.Reason
out.HostIP = in.HostIP
out.PodIP = in.PodIP
- // unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
- if in.StartTime != nil {
- out.StartTime = new(unversioned.Time)
- if err := api.Convert_unversioned_Time_To_unversioned_Time(in.StartTime, out.StartTime, s); err != nil {
- return err
+ out.StartTime = in.StartTime
+ if in.InitContainerStatuses != nil {
+ in, out := &in.InitContainerStatuses, &out.InitContainerStatuses
+ *out = make([]api.ContainerStatus, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ContainerStatus_To_api_ContainerStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.StartTime = nil
+ out.InitContainerStatuses = nil
}
if in.ContainerStatuses != nil {
- out.ContainerStatuses = make([]api.ContainerStatus, len(in.ContainerStatuses))
- for i := range in.ContainerStatuses {
- if err := Convert_v1_ContainerStatus_To_api_ContainerStatus(&in.ContainerStatuses[i], &out.ContainerStatuses[i], s); err != nil {
+ in, out := &in.ContainerStatuses, &out.ContainerStatuses
+ *out = make([]api.ContainerStatus, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ContainerStatus_To_api_ContainerStatus(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -5617,93 +4897,235 @@ func Convert_v1_PodStatus_To_api_PodStatus(in *PodStatus, out *api.PodStatus, s
return autoConvert_v1_PodStatus_To_api_PodStatus(in, out, s)
}
-func autoConvert_v1_PodStatusResult_To_api_PodStatusResult(in *PodStatusResult, out *api.PodStatusResult, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodStatusResult))(in)
- }
+func autoConvert_api_PodStatus_To_v1_PodStatus(in *api.PodStatus, out *PodStatus, s conversion.Scope) error {
+ out.Phase = PodPhase(in.Phase)
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]PodCondition, len(*in))
+ for i := range *in {
+ if err := Convert_api_PodCondition_To_v1_PodCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.Message = in.Message
+ out.Reason = in.Reason
+ out.HostIP = in.HostIP
+ out.PodIP = in.PodIP
+ out.StartTime = in.StartTime
+ if in.InitContainerStatuses != nil {
+ in, out := &in.InitContainerStatuses, &out.InitContainerStatuses
+ *out = make([]ContainerStatus, len(*in))
+ for i := range *in {
+ if err := Convert_api_ContainerStatus_To_v1_ContainerStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainerStatuses = nil
+ }
+ if in.ContainerStatuses != nil {
+ in, out := &in.ContainerStatuses, &out.ContainerStatuses
+ *out = make([]ContainerStatus, len(*in))
+ for i := range *in {
+ if err := Convert_api_ContainerStatus_To_v1_ContainerStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ContainerStatuses = nil
+ }
+ return nil
+}
+
+func Convert_api_PodStatus_To_v1_PodStatus(in *api.PodStatus, out *PodStatus, s conversion.Scope) error {
+ return autoConvert_api_PodStatus_To_v1_PodStatus(in, out, s)
+}
+
+func autoConvert_v1_PodStatusResult_To_api_PodStatusResult(in *PodStatusResult, out *api.PodStatusResult, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PodStatus_To_api_PodStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_api_PodStatusResult_To_v1_PodStatusResult(in *api.PodStatusResult, out *PodStatusResult, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_v1_PodTemplate_To_api_PodTemplate(in *PodTemplate, out *api.PodTemplate, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_PodTemplate_To_api_PodTemplate(in *PodTemplate, out *api.PodTemplate, s conversion.Scope) error {
+ return autoConvert_v1_PodTemplate_To_api_PodTemplate(in, out, s)
+}
+
+func autoConvert_api_PodTemplate_To_v1_PodTemplate(in *api.PodTemplate, out *PodTemplate, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_PodTemplate_To_v1_PodTemplate(in *api.PodTemplate, out *PodTemplate, s conversion.Scope) error {
+ return autoConvert_api_PodTemplate_To_v1_PodTemplate(in, out, s)
+}
+
+func autoConvert_v1_PodTemplateList_To_api_PodTemplateList(in *PodTemplateList, out *api.PodTemplateList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.PodTemplate, len(*in))
+ for i := range *in {
+ if err := Convert_v1_PodTemplate_To_api_PodTemplate(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_PodTemplateList_To_api_PodTemplateList(in *PodTemplateList, out *api.PodTemplateList, s conversion.Scope) error {
+ return autoConvert_v1_PodTemplateList_To_api_PodTemplateList(in, out, s)
+}
+
+func autoConvert_api_PodTemplateList_To_v1_PodTemplateList(in *api.PodTemplateList, out *PodTemplateList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PodTemplate, len(*in))
+ for i := range *in {
+ if err := Convert_api_PodTemplate_To_v1_PodTemplate(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_PodTemplateList_To_v1_PodTemplateList(in *api.PodTemplateList, out *PodTemplateList, s conversion.Scope) error {
+ return autoConvert_api_PodTemplateList_To_v1_PodTemplateList(in, out, s)
+}
+
+func autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if err := Convert_v1_PodStatus_To_api_PodStatus(&in.Status, &out.Status, s); err != nil {
+ if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
return err
}
return nil
}
-func Convert_v1_PodStatusResult_To_api_PodStatusResult(in *PodStatusResult, out *api.PodStatusResult, s conversion.Scope) error {
- return autoConvert_v1_PodStatusResult_To_api_PodStatusResult(in, out, s)
-}
-
-func autoConvert_v1_PodTemplate_To_api_PodTemplate(in *PodTemplate, out *api.PodTemplate, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodTemplate))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+func autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec(in *api.PodTemplateSpec, out *PodTemplateSpec, s conversion.Scope) error {
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ if err := Convert_api_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
return err
}
return nil
}
-func Convert_v1_PodTemplate_To_api_PodTemplate(in *PodTemplate, out *api.PodTemplate, s conversion.Scope) error {
- return autoConvert_v1_PodTemplate_To_api_PodTemplate(in, out, s)
+func autoConvert_v1_Preconditions_To_api_Preconditions(in *Preconditions, out *api.Preconditions, s conversion.Scope) error {
+ out.UID = in.UID
+ return nil
}
-func autoConvert_v1_PodTemplateList_To_api_PodTemplateList(in *PodTemplateList, out *api.PodTemplateList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodTemplateList))(in)
- }
- if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
- return err
- }
- if in.Items != nil {
- out.Items = make([]api.PodTemplate, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_PodTemplate_To_api_PodTemplate(&in.Items[i], &out.Items[i], s); err != nil {
- return err
- }
- }
- } else {
- out.Items = nil
- }
+func Convert_v1_Preconditions_To_api_Preconditions(in *Preconditions, out *api.Preconditions, s conversion.Scope) error {
+ return autoConvert_v1_Preconditions_To_api_Preconditions(in, out, s)
+}
+
+func autoConvert_api_Preconditions_To_v1_Preconditions(in *api.Preconditions, out *Preconditions, s conversion.Scope) error {
+ out.UID = in.UID
return nil
}
-func Convert_v1_PodTemplateList_To_api_PodTemplateList(in *PodTemplateList, out *api.PodTemplateList, s conversion.Scope) error {
- return autoConvert_v1_PodTemplateList_To_api_PodTemplateList(in, out, s)
+func Convert_api_Preconditions_To_v1_Preconditions(in *api.Preconditions, out *Preconditions, s conversion.Scope) error {
+ return autoConvert_api_Preconditions_To_v1_Preconditions(in, out, s)
}
-func autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*PodTemplateSpec))(in)
- }
- if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+func autoConvert_v1_PreferredSchedulingTerm_To_api_PreferredSchedulingTerm(in *PreferredSchedulingTerm, out *api.PreferredSchedulingTerm, s conversion.Scope) error {
+ out.Weight = in.Weight
+ if err := Convert_v1_NodeSelectorTerm_To_api_NodeSelectorTerm(&in.Preference, &out.Preference, s); err != nil {
return err
}
- if err := Convert_v1_PodSpec_To_api_PodSpec(&in.Spec, &out.Spec, s); err != nil {
+ return nil
+}
+
+func Convert_v1_PreferredSchedulingTerm_To_api_PreferredSchedulingTerm(in *PreferredSchedulingTerm, out *api.PreferredSchedulingTerm, s conversion.Scope) error {
+ return autoConvert_v1_PreferredSchedulingTerm_To_api_PreferredSchedulingTerm(in, out, s)
+}
+
+func autoConvert_api_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in *api.PreferredSchedulingTerm, out *PreferredSchedulingTerm, s conversion.Scope) error {
+ out.Weight = in.Weight
+ if err := Convert_api_NodeSelectorTerm_To_v1_NodeSelectorTerm(&in.Preference, &out.Preference, s); err != nil {
return err
}
return nil
}
-func Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in *PodTemplateSpec, out *api.PodTemplateSpec, s conversion.Scope) error {
- return autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in, out, s)
+func Convert_api_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in *api.PreferredSchedulingTerm, out *PreferredSchedulingTerm, s conversion.Scope) error {
+ return autoConvert_api_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in, out, s)
}
func autoConvert_v1_Probe_To_api_Probe(in *Probe, out *api.Probe, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Probe))(in)
- }
+ SetDefaults_Probe(in)
if err := Convert_v1_Handler_To_api_Handler(&in.Handler, &out.Handler, s); err != nil {
return err
}
- out.InitialDelaySeconds = int(in.InitialDelaySeconds)
- out.TimeoutSeconds = int(in.TimeoutSeconds)
- out.PeriodSeconds = int(in.PeriodSeconds)
- out.SuccessThreshold = int(in.SuccessThreshold)
- out.FailureThreshold = int(in.FailureThreshold)
+ out.InitialDelaySeconds = in.InitialDelaySeconds
+ out.TimeoutSeconds = in.TimeoutSeconds
+ out.PeriodSeconds = in.PeriodSeconds
+ out.SuccessThreshold = in.SuccessThreshold
+ out.FailureThreshold = in.FailureThreshold
return nil
}
@@ -5711,27 +5133,58 @@ func Convert_v1_Probe_To_api_Probe(in *Probe, out *api.Probe, s conversion.Scope
return autoConvert_v1_Probe_To_api_Probe(in, out, s)
}
-func autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RBDVolumeSource))(in)
+func autoConvert_api_Probe_To_v1_Probe(in *api.Probe, out *Probe, s conversion.Scope) error {
+ if err := Convert_api_Handler_To_v1_Handler(&in.Handler, &out.Handler, s); err != nil {
+ return err
}
- if in.CephMonitors != nil {
- out.CephMonitors = make([]string, len(in.CephMonitors))
- for i := range in.CephMonitors {
- out.CephMonitors[i] = in.CephMonitors[i]
+ out.InitialDelaySeconds = in.InitialDelaySeconds
+ out.TimeoutSeconds = in.TimeoutSeconds
+ out.PeriodSeconds = in.PeriodSeconds
+ out.SuccessThreshold = in.SuccessThreshold
+ out.FailureThreshold = in.FailureThreshold
+ return nil
+}
+
+func Convert_api_Probe_To_v1_Probe(in *api.Probe, out *Probe, s conversion.Scope) error {
+ return autoConvert_api_Probe_To_v1_Probe(in, out, s)
+}
+
+func autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
+ SetDefaults_RBDVolumeSource(in)
+ out.CephMonitors = in.CephMonitors
+ out.RBDImage = in.RBDImage
+ out.FSType = in.FSType
+ out.RBDPool = in.RBDPool
+ out.RadosUser = in.RadosUser
+ out.Keyring = in.Keyring
+ if in.SecretRef != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(api.LocalObjectReference)
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(*in, *out, s); err != nil {
+ return err
}
} else {
- out.CephMonitors = nil
+ out.SecretRef = nil
}
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in, out, s)
+}
+
+func autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *RBDVolumeSource, s conversion.Scope) error {
+ out.CephMonitors = in.CephMonitors
out.RBDImage = in.RBDImage
out.FSType = in.FSType
out.RBDPool = in.RBDPool
out.RadosUser = in.RadosUser
out.Keyring = in.Keyring
- // unable to generate simple pointer conversion for v1.LocalObjectReference -> api.LocalObjectReference
if in.SecretRef != nil {
- out.SecretRef = new(api.LocalObjectReference)
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(in.SecretRef, out.SecretRef, s); err != nil {
+ in, out := &in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(*in, *out, s); err != nil {
return err
}
} else {
@@ -5741,19 +5194,19 @@ func autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *RBDVolumeSource,
return nil
}
-func Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in *RBDVolumeSource, out *api.RBDVolumeSource, s conversion.Scope) error {
- return autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in, out, s)
+func Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in *api.RBDVolumeSource, out *RBDVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource(in, out, s)
}
func autoConvert_v1_RangeAllocation_To_api_RangeAllocation(in *RangeAllocation, out *api.RangeAllocation, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RangeAllocation))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
out.Range = in.Range
- if err := conversion.ByteSliceCopy(&in.Data, &out.Data, s); err != nil {
+ if err := conversion.Convert_Slice_byte_To_Slice_byte(&in.Data, &out.Data, s); err != nil {
return err
}
return nil
@@ -5763,9 +5216,28 @@ func Convert_v1_RangeAllocation_To_api_RangeAllocation(in *RangeAllocation, out
return autoConvert_v1_RangeAllocation_To_api_RangeAllocation(in, out, s)
}
+func autoConvert_api_RangeAllocation_To_v1_RangeAllocation(in *api.RangeAllocation, out *RangeAllocation, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ out.Range = in.Range
+ if err := conversion.Convert_Slice_byte_To_Slice_byte(&in.Data, &out.Data, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_RangeAllocation_To_v1_RangeAllocation(in *api.RangeAllocation, out *RangeAllocation, s conversion.Scope) error {
+ return autoConvert_api_RangeAllocation_To_v1_RangeAllocation(in, out, s)
+}
+
func autoConvert_v1_ReplicationController_To_api_ReplicationController(in *ReplicationController, out *api.ReplicationController, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationController))(in)
+ SetDefaults_ReplicationController(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -5783,17 +5255,38 @@ func Convert_v1_ReplicationController_To_api_ReplicationController(in *Replicati
return autoConvert_v1_ReplicationController_To_api_ReplicationController(in, out, s)
}
+func autoConvert_api_ReplicationController_To_v1_ReplicationController(in *api.ReplicationController, out *ReplicationController, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_ReplicationController_To_v1_ReplicationController(in *api.ReplicationController, out *ReplicationController, s conversion.Scope) error {
+ return autoConvert_api_ReplicationController_To_v1_ReplicationController(in, out, s)
+}
+
func autoConvert_v1_ReplicationControllerList_To_api_ReplicationControllerList(in *ReplicationControllerList, out *api.ReplicationControllerList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationControllerList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.ReplicationController, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_ReplicationController_To_api_ReplicationController(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.ReplicationController, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ReplicationController_To_api_ReplicationController(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -5807,37 +5300,34 @@ func Convert_v1_ReplicationControllerList_To_api_ReplicationControllerList(in *R
return autoConvert_v1_ReplicationControllerList_To_api_ReplicationControllerList(in, out, s)
}
-func autoConvert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec(in *ReplicationControllerSpec, out *api.ReplicationControllerSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationControllerSpec))(in)
+func autoConvert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in *api.ReplicationControllerList, out *ReplicationControllerList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
- // in.Replicas has no peer in out
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
}
- // unable to generate simple pointer conversion for v1.PodTemplateSpec -> api.PodTemplateSpec
- if in.Template != nil {
- out.Template = new(api.PodTemplateSpec)
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(in.Template, out.Template, s); err != nil {
- return err
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ReplicationController, len(*in))
+ for i := range *in {
+ if err := Convert_api_ReplicationController_To_v1_ReplicationController(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.Template = nil
+ out.Items = nil
}
return nil
}
+func Convert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in *api.ReplicationControllerList, out *ReplicationControllerList, s conversion.Scope) error {
+ return autoConvert_api_ReplicationControllerList_To_v1_ReplicationControllerList(in, out, s)
+}
+
func autoConvert_v1_ReplicationControllerStatus_To_api_ReplicationControllerStatus(in *ReplicationControllerStatus, out *api.ReplicationControllerStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicationControllerStatus))(in)
- }
- out.Replicas = int(in.Replicas)
- out.FullyLabeledReplicas = int(in.FullyLabeledReplicas)
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
out.ObservedGeneration = in.ObservedGeneration
return nil
}
@@ -5846,9 +5336,46 @@ func Convert_v1_ReplicationControllerStatus_To_api_ReplicationControllerStatus(i
return autoConvert_v1_ReplicationControllerStatus_To_api_ReplicationControllerStatus(in, out, s)
}
+func autoConvert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *api.ReplicationControllerStatus, out *ReplicationControllerStatus, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func Convert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *api.ReplicationControllerStatus, out *ReplicationControllerStatus, s conversion.Scope) error {
+ return autoConvert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in, out, s)
+}
+
+func autoConvert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector(in *ResourceFieldSelector, out *api.ResourceFieldSelector, s conversion.Scope) error {
+ out.ContainerName = in.ContainerName
+ out.Resource = in.Resource
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.Divisor, &out.Divisor, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector(in *ResourceFieldSelector, out *api.ResourceFieldSelector, s conversion.Scope) error {
+ return autoConvert_v1_ResourceFieldSelector_To_api_ResourceFieldSelector(in, out, s)
+}
+
+func autoConvert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector(in *api.ResourceFieldSelector, out *ResourceFieldSelector, s conversion.Scope) error {
+ out.ContainerName = in.ContainerName
+ out.Resource = in.Resource
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.Divisor, &out.Divisor, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector(in *api.ResourceFieldSelector, out *ResourceFieldSelector, s conversion.Scope) error {
+ return autoConvert_api_ResourceFieldSelector_To_v1_ResourceFieldSelector(in, out, s)
+}
+
func autoConvert_v1_ResourceQuota_To_api_ResourceQuota(in *ResourceQuota, out *api.ResourceQuota, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceQuota))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -5866,17 +5393,38 @@ func Convert_v1_ResourceQuota_To_api_ResourceQuota(in *ResourceQuota, out *api.R
return autoConvert_v1_ResourceQuota_To_api_ResourceQuota(in, out, s)
}
+func autoConvert_api_ResourceQuota_To_v1_ResourceQuota(in *api.ResourceQuota, out *ResourceQuota, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_ResourceQuota_To_v1_ResourceQuota(in *api.ResourceQuota, out *ResourceQuota, s conversion.Scope) error {
+ return autoConvert_api_ResourceQuota_To_v1_ResourceQuota(in, out, s)
+}
+
func autoConvert_v1_ResourceQuotaList_To_api_ResourceQuotaList(in *ResourceQuotaList, out *api.ResourceQuotaList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceQuotaList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.ResourceQuota, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_ResourceQuota_To_api_ResourceQuota(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.ResourceQuota, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ResourceQuota_To_api_ResourceQuota(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -5890,17 +5438,40 @@ func Convert_v1_ResourceQuotaList_To_api_ResourceQuotaList(in *ResourceQuotaList
return autoConvert_v1_ResourceQuotaList_To_api_ResourceQuotaList(in, out, s)
}
-func autoConvert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec(in *ResourceQuotaSpec, out *api.ResourceQuotaSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceQuotaSpec))(in)
+func autoConvert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in *api.ResourceQuotaList, out *ResourceQuotaList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ResourceQuota, len(*in))
+ for i := range *in {
+ if err := Convert_api_ResourceQuota_To_v1_ResourceQuota(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
}
- if err := s.Convert(&in.Hard, &out.Hard, 0); err != nil {
+ return nil
+}
+
+func Convert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in *api.ResourceQuotaList, out *ResourceQuotaList, s conversion.Scope) error {
+ return autoConvert_api_ResourceQuotaList_To_v1_ResourceQuotaList(in, out, s)
+}
+
+func autoConvert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec(in *ResourceQuotaSpec, out *api.ResourceQuotaSpec, s conversion.Scope) error {
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Hard, &out.Hard, s); err != nil {
return err
}
if in.Scopes != nil {
- out.Scopes = make([]api.ResourceQuotaScope, len(in.Scopes))
- for i := range in.Scopes {
- out.Scopes[i] = api.ResourceQuotaScope(in.Scopes[i])
+ in, out := &in.Scopes, &out.Scopes
+ *out = make([]api.ResourceQuotaScope, len(*in))
+ for i := range *in {
+ (*out)[i] = api.ResourceQuotaScope((*in)[i])
}
} else {
out.Scopes = nil
@@ -5912,14 +5483,41 @@ func Convert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec(in *ResourceQuotaSpec
return autoConvert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec(in, out, s)
}
-func autoConvert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus(in *ResourceQuotaStatus, out *api.ResourceQuotaStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceQuotaStatus))(in)
+func autoConvert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *api.ResourceQuotaSpec, out *ResourceQuotaSpec, s conversion.Scope) error {
+ if in.Hard != nil {
+ in, out := &in.Hard, &out.Hard
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
+ return err
+ }
+ (*out)[ResourceName(key)] = *newVal
+ }
+ } else {
+ out.Hard = nil
+ }
+ if in.Scopes != nil {
+ in, out := &in.Scopes, &out.Scopes
+ *out = make([]ResourceQuotaScope, len(*in))
+ for i := range *in {
+ (*out)[i] = ResourceQuotaScope((*in)[i])
+ }
+ } else {
+ out.Scopes = nil
}
- if err := s.Convert(&in.Hard, &out.Hard, 0); err != nil {
+ return nil
+}
+
+func Convert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *api.ResourceQuotaSpec, out *ResourceQuotaSpec, s conversion.Scope) error {
+ return autoConvert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in, out, s)
+}
+
+func autoConvert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus(in *ResourceQuotaStatus, out *api.ResourceQuotaStatus, s conversion.Scope) error {
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Hard, &out.Hard, s); err != nil {
return err
}
- if err := s.Convert(&in.Used, &out.Used, 0); err != nil {
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Used, &out.Used, s); err != nil {
return err
}
return nil
@@ -5929,27 +5527,89 @@ func Convert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus(in *ResourceQuota
return autoConvert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus(in, out, s)
}
+func autoConvert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *api.ResourceQuotaStatus, out *ResourceQuotaStatus, s conversion.Scope) error {
+ if in.Hard != nil {
+ in, out := &in.Hard, &out.Hard
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
+ return err
+ }
+ (*out)[ResourceName(key)] = *newVal
+ }
+ } else {
+ out.Hard = nil
+ }
+ if in.Used != nil {
+ in, out := &in.Used, &out.Used
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
+ return err
+ }
+ (*out)[ResourceName(key)] = *newVal
+ }
+ } else {
+ out.Used = nil
+ }
+ return nil
+}
+
+func Convert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *api.ResourceQuotaStatus, out *ResourceQuotaStatus, s conversion.Scope) error {
+ return autoConvert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in, out, s)
+}
+
func autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in *ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ResourceRequirements))(in)
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Limits, &out.Limits, s); err != nil {
+ return err
}
- if err := s.Convert(&in.Limits, &out.Limits, 0); err != nil {
+ if err := Convert_v1_ResourceList_To_api_ResourceList(&in.Requests, &out.Requests, s); err != nil {
return err
}
- if err := s.Convert(&in.Requests, &out.Requests, 0); err != nil {
- return err
+ return nil
+}
+
+func Convert_v1_ResourceRequirements_To_api_ResourceRequirements(in *ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
+ return autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in, out, s)
+}
+
+func autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *ResourceRequirements, s conversion.Scope) error {
+ if in.Limits != nil {
+ in, out := &in.Limits, &out.Limits
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
+ return err
+ }
+ (*out)[ResourceName(key)] = *newVal
+ }
+ } else {
+ out.Limits = nil
+ }
+ if in.Requests != nil {
+ in, out := &in.Requests, &out.Requests
+ *out = make(ResourceList, len(*in))
+ for key, val := range *in {
+ newVal := new(resource.Quantity)
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&val, newVal, s); err != nil {
+ return err
+ }
+ (*out)[ResourceName(key)] = *newVal
+ }
+ } else {
+ out.Requests = nil
}
return nil
}
-func Convert_v1_ResourceRequirements_To_api_ResourceRequirements(in *ResourceRequirements, out *api.ResourceRequirements, s conversion.Scope) error {
- return autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements(in, out, s)
+func Convert_api_ResourceRequirements_To_v1_ResourceRequirements(in *api.ResourceRequirements, out *ResourceRequirements, s conversion.Scope) error {
+ return autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements(in, out, s)
}
func autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in *SELinuxOptions, out *api.SELinuxOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SELinuxOptions))(in)
- }
out.User = in.User
out.Role = in.Role
out.Type = in.Type
@@ -5961,25 +5621,27 @@ func Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in *SELinuxOptions, out *ap
return autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions(in, out, s)
}
+func autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *SELinuxOptions, s conversion.Scope) error {
+ out.User = in.User
+ out.Role = in.Role
+ out.Type = in.Type
+ out.Level = in.Level
+ return nil
+}
+
+func Convert_api_SELinuxOptions_To_v1_SELinuxOptions(in *api.SELinuxOptions, out *SELinuxOptions, s conversion.Scope) error {
+ return autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions(in, out, s)
+}
+
func autoConvert_v1_Secret_To_api_Secret(in *Secret, out *api.Secret, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Secret))(in)
+ SetDefaults_Secret(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
- if in.Data != nil {
- out.Data = make(map[string][]uint8)
- for key, val := range in.Data {
- newVal := []uint8{}
- if err := conversion.ByteSliceCopy(&val, &newVal, s); err != nil {
- return err
- }
- out.Data[key] = newVal
- }
- } else {
- out.Data = nil
- }
+ out.Data = in.Data
out.Type = api.SecretType(in.Type)
return nil
}
@@ -5988,10 +5650,23 @@ func Convert_v1_Secret_To_api_Secret(in *Secret, out *api.Secret, s conversion.S
return autoConvert_v1_Secret_To_api_Secret(in, out, s)
}
-func autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in *SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SecretKeySelector))(in)
+func autoConvert_api_Secret_To_v1_Secret(in *api.Secret, out *Secret, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
}
+ out.Data = in.Data
+ out.Type = SecretType(in.Type)
+ return nil
+}
+
+func Convert_api_Secret_To_v1_Secret(in *api.Secret, out *Secret, s conversion.Scope) error {
+ return autoConvert_api_Secret_To_v1_Secret(in, out, s)
+}
+
+func autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in *SecretKeySelector, out *api.SecretKeySelector, s conversion.Scope) error {
if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
return err
}
@@ -6003,17 +5678,30 @@ func Convert_v1_SecretKeySelector_To_api_SecretKeySelector(in *SecretKeySelector
return autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector(in, out, s)
}
+func autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *SecretKeySelector, s conversion.Scope) error {
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
+ return err
+ }
+ out.Key = in.Key
+ return nil
+}
+
+func Convert_api_SecretKeySelector_To_v1_SecretKeySelector(in *api.SecretKeySelector, out *SecretKeySelector, s conversion.Scope) error {
+ return autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector(in, out, s)
+}
+
func autoConvert_v1_SecretList_To_api_SecretList(in *SecretList, out *api.SecretList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SecretList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.Secret, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Secret_To_api_Secret(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Secret, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Secret_To_api_Secret(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -6027,11 +5715,44 @@ func Convert_v1_SecretList_To_api_SecretList(in *SecretList, out *api.SecretList
return autoConvert_v1_SecretList_To_api_SecretList(in, out, s)
}
-func autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SecretVolumeSource))(in)
+func autoConvert_api_SecretList_To_v1_SecretList(in *api.SecretList, out *SecretList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
}
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Secret, len(*in))
+ for i := range *in {
+ if err := Convert_api_Secret_To_v1_Secret(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_SecretList_To_v1_SecretList(in *api.SecretList, out *SecretList, s conversion.Scope) error {
+ return autoConvert_api_SecretList_To_v1_SecretList(in, out, s)
+}
+
+func autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *SecretVolumeSource, out *api.SecretVolumeSource, s conversion.Scope) error {
out.SecretName = in.SecretName
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.KeyToPath, len(*in))
+ for i := range *in {
+ if err := Convert_v1_KeyToPath_To_api_KeyToPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
return nil
}
@@ -6039,62 +5760,89 @@ func Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in *SecretVolumeSou
return autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in, out, s)
}
-func autoConvert_v1_SecurityContext_To_api_SecurityContext(in *SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SecurityContext))(in)
+func autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *SecretVolumeSource, s conversion.Scope) error {
+ out.SecretName = in.SecretName
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]KeyToPath, len(*in))
+ for i := range *in {
+ if err := Convert_api_KeyToPath_To_v1_KeyToPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
}
- // unable to generate simple pointer conversion for v1.Capabilities -> api.Capabilities
+ return nil
+}
+
+func Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in *api.SecretVolumeSource, out *SecretVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource(in, out, s)
+}
+
+func autoConvert_v1_SecurityContext_To_api_SecurityContext(in *SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
if in.Capabilities != nil {
- out.Capabilities = new(api.Capabilities)
- if err := Convert_v1_Capabilities_To_api_Capabilities(in.Capabilities, out.Capabilities, s); err != nil {
+ in, out := &in.Capabilities, &out.Capabilities
+ *out = new(api.Capabilities)
+ if err := Convert_v1_Capabilities_To_api_Capabilities(*in, *out, s); err != nil {
return err
}
} else {
out.Capabilities = nil
}
- if in.Privileged != nil {
- out.Privileged = new(bool)
- *out.Privileged = *in.Privileged
- } else {
- out.Privileged = nil
- }
- // unable to generate simple pointer conversion for v1.SELinuxOptions -> api.SELinuxOptions
+ out.Privileged = in.Privileged
if in.SELinuxOptions != nil {
- out.SELinuxOptions = new(api.SELinuxOptions)
- if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(in.SELinuxOptions, out.SELinuxOptions, s); err != nil {
+ in, out := &in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(api.SELinuxOptions)
+ if err := Convert_v1_SELinuxOptions_To_api_SELinuxOptions(*in, *out, s); err != nil {
return err
}
} else {
out.SELinuxOptions = nil
}
- if in.RunAsUser != nil {
- out.RunAsUser = new(int64)
- *out.RunAsUser = *in.RunAsUser
- } else {
- out.RunAsUser = nil
- }
- if in.RunAsNonRoot != nil {
- out.RunAsNonRoot = new(bool)
- *out.RunAsNonRoot = *in.RunAsNonRoot
+ out.RunAsUser = in.RunAsUser
+ out.RunAsNonRoot = in.RunAsNonRoot
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
+ return nil
+}
+
+func Convert_v1_SecurityContext_To_api_SecurityContext(in *SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
+ return autoConvert_v1_SecurityContext_To_api_SecurityContext(in, out, s)
+}
+
+func autoConvert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *SecurityContext, s conversion.Scope) error {
+ if in.Capabilities != nil {
+ in, out := &in.Capabilities, &out.Capabilities
+ *out = new(Capabilities)
+ if err := Convert_api_Capabilities_To_v1_Capabilities(*in, *out, s); err != nil {
+ return err
+ }
} else {
- out.RunAsNonRoot = nil
+ out.Capabilities = nil
}
- if in.ReadOnlyRootFilesystem != nil {
- out.ReadOnlyRootFilesystem = new(bool)
- *out.ReadOnlyRootFilesystem = *in.ReadOnlyRootFilesystem
+ out.Privileged = in.Privileged
+ if in.SELinuxOptions != nil {
+ in, out := &in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(SELinuxOptions)
+ if err := Convert_api_SELinuxOptions_To_v1_SELinuxOptions(*in, *out, s); err != nil {
+ return err
+ }
} else {
- out.ReadOnlyRootFilesystem = nil
+ out.SELinuxOptions = nil
}
+ out.RunAsUser = in.RunAsUser
+ out.RunAsNonRoot = in.RunAsNonRoot
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
return nil
}
-func Convert_v1_SecurityContext_To_api_SecurityContext(in *SecurityContext, out *api.SecurityContext, s conversion.Scope) error {
- return autoConvert_v1_SecurityContext_To_api_SecurityContext(in, out, s)
+func Convert_api_SecurityContext_To_v1_SecurityContext(in *api.SecurityContext, out *SecurityContext, s conversion.Scope) error {
+ return autoConvert_api_SecurityContext_To_v1_SecurityContext(in, out, s)
}
func autoConvert_v1_SerializedReference_To_api_SerializedReference(in *SerializedReference, out *api.SerializedReference, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*SerializedReference))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.Reference, &out.Reference, s); err != nil {
return err
@@ -6106,9 +5854,23 @@ func Convert_v1_SerializedReference_To_api_SerializedReference(in *SerializedRef
return autoConvert_v1_SerializedReference_To_api_SerializedReference(in, out, s)
}
+func autoConvert_api_SerializedReference_To_v1_SerializedReference(in *api.SerializedReference, out *SerializedReference, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectReference_To_v1_ObjectReference(&in.Reference, &out.Reference, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_SerializedReference_To_v1_SerializedReference(in *api.SerializedReference, out *SerializedReference, s conversion.Scope) error {
+ return autoConvert_api_SerializedReference_To_v1_SerializedReference(in, out, s)
+}
+
func autoConvert_v1_Service_To_api_Service(in *Service, out *api.Service, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Service))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
@@ -6126,17 +5888,38 @@ func Convert_v1_Service_To_api_Service(in *Service, out *api.Service, s conversi
return autoConvert_v1_Service_To_api_Service(in, out, s)
}
+func autoConvert_api_Service_To_v1_Service(in *api.Service, out *Service, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ServiceSpec_To_v1_ServiceSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ServiceStatus_To_v1_ServiceStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_api_Service_To_v1_Service(in *api.Service, out *Service, s conversion.Scope) error {
+ return autoConvert_api_Service_To_v1_Service(in, out, s)
+}
+
func autoConvert_v1_ServiceAccount_To_api_ServiceAccount(in *ServiceAccount, out *api.ServiceAccount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceAccount))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
return err
}
if in.Secrets != nil {
- out.Secrets = make([]api.ObjectReference, len(in.Secrets))
- for i := range in.Secrets {
- if err := Convert_v1_ObjectReference_To_api_ObjectReference(&in.Secrets[i], &out.Secrets[i], s); err != nil {
+ in, out := &in.Secrets, &out.Secrets
+ *out = make([]api.ObjectReference, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ObjectReference_To_api_ObjectReference(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -6144,9 +5927,10 @@ func autoConvert_v1_ServiceAccount_To_api_ServiceAccount(in *ServiceAccount, out
out.Secrets = nil
}
if in.ImagePullSecrets != nil {
- out.ImagePullSecrets = make([]api.LocalObjectReference, len(in.ImagePullSecrets))
- for i := range in.ImagePullSecrets {
- if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.ImagePullSecrets[i], &out.ImagePullSecrets[i], s); err != nil {
+ in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
+ *out = make([]api.LocalObjectReference, len(*in))
+ for i := range *in {
+ if err := Convert_v1_LocalObjectReference_To_api_LocalObjectReference(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -6160,17 +5944,54 @@ func Convert_v1_ServiceAccount_To_api_ServiceAccount(in *ServiceAccount, out *ap
return autoConvert_v1_ServiceAccount_To_api_ServiceAccount(in, out, s)
}
+func autoConvert_api_ServiceAccount_To_v1_ServiceAccount(in *api.ServiceAccount, out *ServiceAccount, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_api_ObjectMeta_To_v1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
+ return err
+ }
+ if in.Secrets != nil {
+ in, out := &in.Secrets, &out.Secrets
+ *out = make([]ObjectReference, len(*in))
+ for i := range *in {
+ if err := Convert_api_ObjectReference_To_v1_ObjectReference(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Secrets = nil
+ }
+ if in.ImagePullSecrets != nil {
+ in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
+ *out = make([]LocalObjectReference, len(*in))
+ for i := range *in {
+ if err := Convert_api_LocalObjectReference_To_v1_LocalObjectReference(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ImagePullSecrets = nil
+ }
+ return nil
+}
+
+func Convert_api_ServiceAccount_To_v1_ServiceAccount(in *api.ServiceAccount, out *ServiceAccount, s conversion.Scope) error {
+ return autoConvert_api_ServiceAccount_To_v1_ServiceAccount(in, out, s)
+}
+
func autoConvert_v1_ServiceAccountList_To_api_ServiceAccountList(in *ServiceAccountList, out *api.ServiceAccountList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceAccountList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.ServiceAccount, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_ServiceAccount_To_api_ServiceAccount(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.ServiceAccount, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ServiceAccount_To_api_ServiceAccount(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -6184,17 +6005,43 @@ func Convert_v1_ServiceAccountList_To_api_ServiceAccountList(in *ServiceAccountL
return autoConvert_v1_ServiceAccountList_To_api_ServiceAccountList(in, out, s)
}
+func autoConvert_api_ServiceAccountList_To_v1_ServiceAccountList(in *api.ServiceAccountList, out *ServiceAccountList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ServiceAccount, len(*in))
+ for i := range *in {
+ if err := Convert_api_ServiceAccount_To_v1_ServiceAccount(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_api_ServiceAccountList_To_v1_ServiceAccountList(in *api.ServiceAccountList, out *ServiceAccountList, s conversion.Scope) error {
+ return autoConvert_api_ServiceAccountList_To_v1_ServiceAccountList(in, out, s)
+}
+
func autoConvert_v1_ServiceList_To_api_ServiceList(in *ServiceList, out *api.ServiceList, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceList))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
return err
}
if in.Items != nil {
- out.Items = make([]api.Service, len(in.Items))
- for i := range in.Items {
- if err := Convert_v1_Service_To_api_Service(&in.Items[i], &out.Items[i], s); err != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]api.Service, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Service_To_api_Service(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
@@ -6208,17 +6055,39 @@ func Convert_v1_ServiceList_To_api_ServiceList(in *ServiceList, out *api.Service
return autoConvert_v1_ServiceList_To_api_ServiceList(in, out, s)
}
-func autoConvert_v1_ServicePort_To_api_ServicePort(in *ServicePort, out *api.ServicePort, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServicePort))(in)
+func autoConvert_api_ServiceList_To_v1_ServiceList(in *api.ServiceList, out *ServiceList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Service, len(*in))
+ for i := range *in {
+ if err := Convert_api_Service_To_v1_Service(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
}
+ return nil
+}
+
+func Convert_api_ServiceList_To_v1_ServiceList(in *api.ServiceList, out *ServiceList, s conversion.Scope) error {
+ return autoConvert_api_ServiceList_To_v1_ServiceList(in, out, s)
+}
+
+func autoConvert_v1_ServicePort_To_api_ServicePort(in *ServicePort, out *api.ServicePort, s conversion.Scope) error {
out.Name = in.Name
out.Protocol = api.Protocol(in.Protocol)
- out.Port = int(in.Port)
+ out.Port = in.Port
if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.TargetPort, &out.TargetPort, s); err != nil {
return err
}
- out.NodePort = int(in.NodePort)
+ out.NodePort = in.NodePort
return nil
}
@@ -6226,60 +6095,91 @@ func Convert_v1_ServicePort_To_api_ServicePort(in *ServicePort, out *api.Service
return autoConvert_v1_ServicePort_To_api_ServicePort(in, out, s)
}
+func autoConvert_api_ServicePort_To_v1_ServicePort(in *api.ServicePort, out *ServicePort, s conversion.Scope) error {
+ out.Name = in.Name
+ out.Protocol = Protocol(in.Protocol)
+ out.Port = in.Port
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.TargetPort, &out.TargetPort, s); err != nil {
+ return err
+ }
+ out.NodePort = in.NodePort
+ return nil
+}
+
+func Convert_api_ServicePort_To_v1_ServicePort(in *api.ServicePort, out *ServicePort, s conversion.Scope) error {
+ return autoConvert_api_ServicePort_To_v1_ServicePort(in, out, s)
+}
+
func autoConvert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions(in *ServiceProxyOptions, out *api.ServiceProxyOptions, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceProxyOptions))(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func Convert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions(in *ServiceProxyOptions, out *api.ServiceProxyOptions, s conversion.Scope) error {
+ return autoConvert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions(in, out, s)
+}
+
+func autoConvert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *api.ServiceProxyOptions, out *ServiceProxyOptions, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
}
out.Path = in.Path
return nil
}
-func Convert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions(in *ServiceProxyOptions, out *api.ServiceProxyOptions, s conversion.Scope) error {
- return autoConvert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions(in, out, s)
+func Convert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *api.ServiceProxyOptions, out *ServiceProxyOptions, s conversion.Scope) error {
+ return autoConvert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions(in, out, s)
}
func autoConvert_v1_ServiceSpec_To_api_ServiceSpec(in *ServiceSpec, out *api.ServiceSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceSpec))(in)
- }
+ SetDefaults_ServiceSpec(in)
if in.Ports != nil {
- out.Ports = make([]api.ServicePort, len(in.Ports))
- for i := range in.Ports {
- if err := Convert_v1_ServicePort_To_api_ServicePort(&in.Ports[i], &out.Ports[i], s); err != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]api.ServicePort, len(*in))
+ for i := range *in {
+ if err := Convert_v1_ServicePort_To_api_ServicePort(&(*in)[i], &(*out)[i], s); err != nil {
return err
}
}
} else {
out.Ports = nil
}
- if in.Selector != nil {
- out.Selector = make(map[string]string)
- for key, val := range in.Selector {
- out.Selector[key] = val
- }
- } else {
- out.Selector = nil
- }
+ out.Selector = in.Selector
out.ClusterIP = in.ClusterIP
out.Type = api.ServiceType(in.Type)
- if in.ExternalIPs != nil {
- out.ExternalIPs = make([]string, len(in.ExternalIPs))
- for i := range in.ExternalIPs {
- out.ExternalIPs[i] = in.ExternalIPs[i]
+ out.ExternalIPs = in.ExternalIPs
+ out.SessionAffinity = api.ServiceAffinity(in.SessionAffinity)
+ out.LoadBalancerIP = in.LoadBalancerIP
+ out.LoadBalancerSourceRanges = in.LoadBalancerSourceRanges
+ return nil
+}
+
+func autoConvert_api_ServiceSpec_To_v1_ServiceSpec(in *api.ServiceSpec, out *ServiceSpec, s conversion.Scope) error {
+ out.Type = ServiceType(in.Type)
+ if in.Ports != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]ServicePort, len(*in))
+ for i := range *in {
+ if err := Convert_api_ServicePort_To_v1_ServicePort(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
}
} else {
- out.ExternalIPs = nil
+ out.Ports = nil
}
- // in.DeprecatedPublicIPs has no peer in out
- out.SessionAffinity = api.ServiceAffinity(in.SessionAffinity)
+ out.Selector = in.Selector
+ out.ClusterIP = in.ClusterIP
+ out.ExternalIPs = in.ExternalIPs
out.LoadBalancerIP = in.LoadBalancerIP
+ out.SessionAffinity = ServiceAffinity(in.SessionAffinity)
+ out.LoadBalancerSourceRanges = in.LoadBalancerSourceRanges
return nil
}
func autoConvert_v1_ServiceStatus_To_api_ServiceStatus(in *ServiceStatus, out *api.ServiceStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ServiceStatus))(in)
- }
if err := Convert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
return err
}
@@ -6290,10 +6190,18 @@ func Convert_v1_ServiceStatus_To_api_ServiceStatus(in *ServiceStatus, out *api.S
return autoConvert_v1_ServiceStatus_To_api_ServiceStatus(in, out, s)
}
-func autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in *TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*TCPSocketAction))(in)
+func autoConvert_api_ServiceStatus_To_v1_ServiceStatus(in *api.ServiceStatus, out *ServiceStatus, s conversion.Scope) error {
+ if err := Convert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_api_ServiceStatus_To_v1_ServiceStatus(in *api.ServiceStatus, out *ServiceStatus, s conversion.Scope) error {
+ return autoConvert_api_ServiceStatus_To_v1_ServiceStatus(in, out, s)
+}
+
+func autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in *TCPSocketAction, out *api.TCPSocketAction, s conversion.Scope) error {
if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
return err
}
@@ -6304,10 +6212,65 @@ func Convert_v1_TCPSocketAction_To_api_TCPSocketAction(in *TCPSocketAction, out
return autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction(in, out, s)
}
-func autoConvert_v1_Volume_To_api_Volume(in *Volume, out *api.Volume, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*Volume))(in)
+func autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *TCPSocketAction, s conversion.Scope) error {
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.Port, &out.Port, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_api_TCPSocketAction_To_v1_TCPSocketAction(in *api.TCPSocketAction, out *TCPSocketAction, s conversion.Scope) error {
+ return autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction(in, out, s)
+}
+
+func autoConvert_v1_Taint_To_api_Taint(in *Taint, out *api.Taint, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Value = in.Value
+ out.Effect = api.TaintEffect(in.Effect)
+ return nil
+}
+
+func Convert_v1_Taint_To_api_Taint(in *Taint, out *api.Taint, s conversion.Scope) error {
+ return autoConvert_v1_Taint_To_api_Taint(in, out, s)
+}
+
+func autoConvert_api_Taint_To_v1_Taint(in *api.Taint, out *Taint, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Value = in.Value
+ out.Effect = TaintEffect(in.Effect)
+ return nil
+}
+
+func Convert_api_Taint_To_v1_Taint(in *api.Taint, out *Taint, s conversion.Scope) error {
+ return autoConvert_api_Taint_To_v1_Taint(in, out, s)
+}
+
+func autoConvert_v1_Toleration_To_api_Toleration(in *Toleration, out *api.Toleration, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = api.TolerationOperator(in.Operator)
+ out.Value = in.Value
+ out.Effect = api.TaintEffect(in.Effect)
+ return nil
+}
+
+func Convert_v1_Toleration_To_api_Toleration(in *Toleration, out *api.Toleration, s conversion.Scope) error {
+ return autoConvert_v1_Toleration_To_api_Toleration(in, out, s)
+}
+
+func autoConvert_api_Toleration_To_v1_Toleration(in *api.Toleration, out *Toleration, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = TolerationOperator(in.Operator)
+ out.Value = in.Value
+ out.Effect = TaintEffect(in.Effect)
+ return nil
+}
+
+func Convert_api_Toleration_To_v1_Toleration(in *api.Toleration, out *Toleration, s conversion.Scope) error {
+ return autoConvert_api_Toleration_To_v1_Toleration(in, out, s)
+}
+
+func autoConvert_v1_Volume_To_api_Volume(in *Volume, out *api.Volume, s conversion.Scope) error {
+ SetDefaults_Volume(in)
out.Name = in.Name
if err := Convert_v1_VolumeSource_To_api_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
return err
@@ -6319,13 +6282,23 @@ func Convert_v1_Volume_To_api_Volume(in *Volume, out *api.Volume, s conversion.S
return autoConvert_v1_Volume_To_api_Volume(in, out, s)
}
-func autoConvert_v1_VolumeMount_To_api_VolumeMount(in *VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*VolumeMount))(in)
+func autoConvert_api_Volume_To_v1_Volume(in *api.Volume, out *Volume, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := Convert_api_VolumeSource_To_v1_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_api_Volume_To_v1_Volume(in *api.Volume, out *Volume, s conversion.Scope) error {
+ return autoConvert_api_Volume_To_v1_Volume(in, out, s)
+}
+
+func autoConvert_v1_VolumeMount_To_api_VolumeMount(in *VolumeMount, out *api.VolumeMount, s conversion.Scope) error {
out.Name = in.Name
out.ReadOnly = in.ReadOnly
out.MountPath = in.MountPath
+ out.SubPath = in.SubPath
return nil
}
@@ -6333,181 +6306,199 @@ func Convert_v1_VolumeMount_To_api_VolumeMount(in *VolumeMount, out *api.VolumeM
return autoConvert_v1_VolumeMount_To_api_VolumeMount(in, out, s)
}
+func autoConvert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *VolumeMount, s conversion.Scope) error {
+ out.Name = in.Name
+ out.ReadOnly = in.ReadOnly
+ out.MountPath = in.MountPath
+ out.SubPath = in.SubPath
+ return nil
+}
+
+func Convert_api_VolumeMount_To_v1_VolumeMount(in *api.VolumeMount, out *VolumeMount, s conversion.Scope) error {
+ return autoConvert_api_VolumeMount_To_v1_VolumeMount(in, out, s)
+}
+
func autoConvert_v1_VolumeSource_To_api_VolumeSource(in *VolumeSource, out *api.VolumeSource, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*VolumeSource))(in)
- }
- // unable to generate simple pointer conversion for v1.HostPathVolumeSource -> api.HostPathVolumeSource
if in.HostPath != nil {
- out.HostPath = new(api.HostPathVolumeSource)
- if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(in.HostPath, out.HostPath, s); err != nil {
+ in, out := &in.HostPath, &out.HostPath
+ *out = new(api.HostPathVolumeSource)
+ if err := Convert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.HostPath = nil
}
- // unable to generate simple pointer conversion for v1.EmptyDirVolumeSource -> api.EmptyDirVolumeSource
if in.EmptyDir != nil {
- out.EmptyDir = new(api.EmptyDirVolumeSource)
- if err := Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(in.EmptyDir, out.EmptyDir, s); err != nil {
+ in, out := &in.EmptyDir, &out.EmptyDir
+ *out = new(api.EmptyDirVolumeSource)
+ if err := Convert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.EmptyDir = nil
}
- // unable to generate simple pointer conversion for v1.GCEPersistentDiskVolumeSource -> api.GCEPersistentDiskVolumeSource
if in.GCEPersistentDisk != nil {
- out.GCEPersistentDisk = new(api.GCEPersistentDiskVolumeSource)
- if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(in.GCEPersistentDisk, out.GCEPersistentDisk, s); err != nil {
+ in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(api.GCEPersistentDiskVolumeSource)
+ if err := Convert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.GCEPersistentDisk = nil
}
- // unable to generate simple pointer conversion for v1.AWSElasticBlockStoreVolumeSource -> api.AWSElasticBlockStoreVolumeSource
if in.AWSElasticBlockStore != nil {
- out.AWSElasticBlockStore = new(api.AWSElasticBlockStoreVolumeSource)
- if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(in.AWSElasticBlockStore, out.AWSElasticBlockStore, s); err != nil {
+ in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(api.AWSElasticBlockStoreVolumeSource)
+ if err := Convert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.AWSElasticBlockStore = nil
}
- // unable to generate simple pointer conversion for v1.GitRepoVolumeSource -> api.GitRepoVolumeSource
if in.GitRepo != nil {
- out.GitRepo = new(api.GitRepoVolumeSource)
- if err := Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(in.GitRepo, out.GitRepo, s); err != nil {
+ in, out := &in.GitRepo, &out.GitRepo
+ *out = new(api.GitRepoVolumeSource)
+ if err := Convert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.GitRepo = nil
}
- // unable to generate simple pointer conversion for v1.SecretVolumeSource -> api.SecretVolumeSource
if in.Secret != nil {
- out.Secret = new(api.SecretVolumeSource)
- if err := Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(in.Secret, out.Secret, s); err != nil {
+ in, out := &in.Secret, &out.Secret
+ *out = new(api.SecretVolumeSource)
+ if err := Convert_v1_SecretVolumeSource_To_api_SecretVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Secret = nil
}
- // unable to generate simple pointer conversion for v1.NFSVolumeSource -> api.NFSVolumeSource
if in.NFS != nil {
- out.NFS = new(api.NFSVolumeSource)
- if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(in.NFS, out.NFS, s); err != nil {
+ in, out := &in.NFS, &out.NFS
+ *out = new(api.NFSVolumeSource)
+ if err := Convert_v1_NFSVolumeSource_To_api_NFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.NFS = nil
}
- // unable to generate simple pointer conversion for v1.ISCSIVolumeSource -> api.ISCSIVolumeSource
if in.ISCSI != nil {
- out.ISCSI = new(api.ISCSIVolumeSource)
- if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(in.ISCSI, out.ISCSI, s); err != nil {
+ in, out := &in.ISCSI, &out.ISCSI
+ *out = new(api.ISCSIVolumeSource)
+ if err := Convert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.ISCSI = nil
}
- // unable to generate simple pointer conversion for v1.GlusterfsVolumeSource -> api.GlusterfsVolumeSource
if in.Glusterfs != nil {
- out.Glusterfs = new(api.GlusterfsVolumeSource)
- if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(in.Glusterfs, out.Glusterfs, s); err != nil {
+ in, out := &in.Glusterfs, &out.Glusterfs
+ *out = new(api.GlusterfsVolumeSource)
+ if err := Convert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Glusterfs = nil
}
- // unable to generate simple pointer conversion for v1.PersistentVolumeClaimVolumeSource -> api.PersistentVolumeClaimVolumeSource
if in.PersistentVolumeClaim != nil {
- out.PersistentVolumeClaim = new(api.PersistentVolumeClaimVolumeSource)
- if err := Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(in.PersistentVolumeClaim, out.PersistentVolumeClaim, s); err != nil {
+ in, out := &in.PersistentVolumeClaim, &out.PersistentVolumeClaim
+ *out = new(api.PersistentVolumeClaimVolumeSource)
+ if err := Convert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.PersistentVolumeClaim = nil
}
- // unable to generate simple pointer conversion for v1.RBDVolumeSource -> api.RBDVolumeSource
if in.RBD != nil {
- out.RBD = new(api.RBDVolumeSource)
- if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(in.RBD, out.RBD, s); err != nil {
+ in, out := &in.RBD, &out.RBD
+ *out = new(api.RBDVolumeSource)
+ if err := Convert_v1_RBDVolumeSource_To_api_RBDVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.RBD = nil
}
- // unable to generate simple pointer conversion for v1.FlexVolumeSource -> api.FlexVolumeSource
if in.FlexVolume != nil {
- out.FlexVolume = new(api.FlexVolumeSource)
- if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(in.FlexVolume, out.FlexVolume, s); err != nil {
+ in, out := &in.FlexVolume, &out.FlexVolume
+ *out = new(api.FlexVolumeSource)
+ if err := Convert_v1_FlexVolumeSource_To_api_FlexVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.FlexVolume = nil
}
- // unable to generate simple pointer conversion for v1.CinderVolumeSource -> api.CinderVolumeSource
if in.Cinder != nil {
- out.Cinder = new(api.CinderVolumeSource)
- if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(in.Cinder, out.Cinder, s); err != nil {
+ in, out := &in.Cinder, &out.Cinder
+ *out = new(api.CinderVolumeSource)
+ if err := Convert_v1_CinderVolumeSource_To_api_CinderVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Cinder = nil
}
- // unable to generate simple pointer conversion for v1.CephFSVolumeSource -> api.CephFSVolumeSource
if in.CephFS != nil {
- out.CephFS = new(api.CephFSVolumeSource)
- if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(in.CephFS, out.CephFS, s); err != nil {
+ in, out := &in.CephFS, &out.CephFS
+ *out = new(api.CephFSVolumeSource)
+ if err := Convert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.CephFS = nil
}
- // unable to generate simple pointer conversion for v1.FlockerVolumeSource -> api.FlockerVolumeSource
if in.Flocker != nil {
- out.Flocker = new(api.FlockerVolumeSource)
- if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(in.Flocker, out.Flocker, s); err != nil {
+ in, out := &in.Flocker, &out.Flocker
+ *out = new(api.FlockerVolumeSource)
+ if err := Convert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.Flocker = nil
}
- // unable to generate simple pointer conversion for v1.DownwardAPIVolumeSource -> api.DownwardAPIVolumeSource
if in.DownwardAPI != nil {
- out.DownwardAPI = new(api.DownwardAPIVolumeSource)
- if err := Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(in.DownwardAPI, out.DownwardAPI, s); err != nil {
+ in, out := &in.DownwardAPI, &out.DownwardAPI
+ *out = new(api.DownwardAPIVolumeSource)
+ if err := Convert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.DownwardAPI = nil
}
- // unable to generate simple pointer conversion for v1.FCVolumeSource -> api.FCVolumeSource
if in.FC != nil {
- out.FC = new(api.FCVolumeSource)
- if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(in.FC, out.FC, s); err != nil {
+ in, out := &in.FC, &out.FC
+ *out = new(api.FCVolumeSource)
+ if err := Convert_v1_FCVolumeSource_To_api_FCVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.FC = nil
}
- // unable to generate simple pointer conversion for v1.AzureFileVolumeSource -> api.AzureFileVolumeSource
if in.AzureFile != nil {
- out.AzureFile = new(api.AzureFileVolumeSource)
- if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(in.AzureFile, out.AzureFile, s); err != nil {
+ in, out := &in.AzureFile, &out.AzureFile
+ *out = new(api.AzureFileVolumeSource)
+ if err := Convert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.AzureFile = nil
}
- // unable to generate simple pointer conversion for v1.ConfigMapVolumeSource -> api.ConfigMapVolumeSource
if in.ConfigMap != nil {
- out.ConfigMap = new(api.ConfigMapVolumeSource)
- if err := Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(in.ConfigMap, out.ConfigMap, s); err != nil {
+ in, out := &in.ConfigMap, &out.ConfigMap
+ *out = new(api.ConfigMapVolumeSource)
+ if err := Convert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource(*in, *out, s); err != nil {
return err
}
} else {
out.ConfigMap = nil
}
+ if in.VsphereVolume != nil {
+ in, out := &in.VsphereVolume, &out.VsphereVolume
+ *out = new(api.VsphereVirtualDiskVolumeSource)
+ if err := Convert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
return nil
}
@@ -6515,273 +6506,234 @@ func Convert_v1_VolumeSource_To_api_VolumeSource(in *VolumeSource, out *api.Volu
return autoConvert_v1_VolumeSource_To_api_VolumeSource(in, out, s)
}
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource,
- autoConvert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource,
- autoConvert_api_Binding_To_v1_Binding,
- autoConvert_api_Capabilities_To_v1_Capabilities,
- autoConvert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource,
- autoConvert_api_CinderVolumeSource_To_v1_CinderVolumeSource,
- autoConvert_api_ComponentCondition_To_v1_ComponentCondition,
- autoConvert_api_ComponentStatusList_To_v1_ComponentStatusList,
- autoConvert_api_ComponentStatus_To_v1_ComponentStatus,
- autoConvert_api_ConfigMapKeySelector_To_v1_ConfigMapKeySelector,
- autoConvert_api_ConfigMapList_To_v1_ConfigMapList,
- autoConvert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource,
- autoConvert_api_ConfigMap_To_v1_ConfigMap,
- autoConvert_api_ContainerImage_To_v1_ContainerImage,
- autoConvert_api_ContainerPort_To_v1_ContainerPort,
- autoConvert_api_ContainerStateRunning_To_v1_ContainerStateRunning,
- autoConvert_api_ContainerStateTerminated_To_v1_ContainerStateTerminated,
- autoConvert_api_ContainerStateWaiting_To_v1_ContainerStateWaiting,
- autoConvert_api_ContainerState_To_v1_ContainerState,
- autoConvert_api_ContainerStatus_To_v1_ContainerStatus,
- autoConvert_api_Container_To_v1_Container,
- autoConvert_api_DaemonEndpoint_To_v1_DaemonEndpoint,
- autoConvert_api_DeleteOptions_To_v1_DeleteOptions,
- autoConvert_api_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile,
- autoConvert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource,
- autoConvert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource,
- autoConvert_api_EndpointAddress_To_v1_EndpointAddress,
- autoConvert_api_EndpointPort_To_v1_EndpointPort,
- autoConvert_api_EndpointSubset_To_v1_EndpointSubset,
- autoConvert_api_EndpointsList_To_v1_EndpointsList,
- autoConvert_api_Endpoints_To_v1_Endpoints,
- autoConvert_api_EnvVarSource_To_v1_EnvVarSource,
- autoConvert_api_EnvVar_To_v1_EnvVar,
- autoConvert_api_EventList_To_v1_EventList,
- autoConvert_api_EventSource_To_v1_EventSource,
- autoConvert_api_Event_To_v1_Event,
- autoConvert_api_ExecAction_To_v1_ExecAction,
- autoConvert_api_FCVolumeSource_To_v1_FCVolumeSource,
- autoConvert_api_FlexVolumeSource_To_v1_FlexVolumeSource,
- autoConvert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource,
- autoConvert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource,
- autoConvert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource,
- autoConvert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource,
- autoConvert_api_HTTPGetAction_To_v1_HTTPGetAction,
- autoConvert_api_HTTPHeader_To_v1_HTTPHeader,
- autoConvert_api_Handler_To_v1_Handler,
- autoConvert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource,
- autoConvert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource,
- autoConvert_api_KeyToPath_To_v1_KeyToPath,
- autoConvert_api_Lifecycle_To_v1_Lifecycle,
- autoConvert_api_LimitRangeItem_To_v1_LimitRangeItem,
- autoConvert_api_LimitRangeList_To_v1_LimitRangeList,
- autoConvert_api_LimitRangeSpec_To_v1_LimitRangeSpec,
- autoConvert_api_LimitRange_To_v1_LimitRange,
- autoConvert_api_ListOptions_To_v1_ListOptions,
- autoConvert_api_List_To_v1_List,
- autoConvert_api_LoadBalancerIngress_To_v1_LoadBalancerIngress,
- autoConvert_api_LoadBalancerStatus_To_v1_LoadBalancerStatus,
- autoConvert_api_LocalObjectReference_To_v1_LocalObjectReference,
- autoConvert_api_NFSVolumeSource_To_v1_NFSVolumeSource,
- autoConvert_api_NamespaceList_To_v1_NamespaceList,
- autoConvert_api_NamespaceSpec_To_v1_NamespaceSpec,
- autoConvert_api_NamespaceStatus_To_v1_NamespaceStatus,
- autoConvert_api_Namespace_To_v1_Namespace,
- autoConvert_api_NodeAddress_To_v1_NodeAddress,
- autoConvert_api_NodeCondition_To_v1_NodeCondition,
- autoConvert_api_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints,
- autoConvert_api_NodeList_To_v1_NodeList,
- autoConvert_api_NodeProxyOptions_To_v1_NodeProxyOptions,
- autoConvert_api_NodeSpec_To_v1_NodeSpec,
- autoConvert_api_NodeStatus_To_v1_NodeStatus,
- autoConvert_api_NodeSystemInfo_To_v1_NodeSystemInfo,
- autoConvert_api_Node_To_v1_Node,
- autoConvert_api_ObjectFieldSelector_To_v1_ObjectFieldSelector,
- autoConvert_api_ObjectMeta_To_v1_ObjectMeta,
- autoConvert_api_ObjectReference_To_v1_ObjectReference,
- autoConvert_api_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList,
- autoConvert_api_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec,
- autoConvert_api_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus,
- autoConvert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource,
- autoConvert_api_PersistentVolumeClaim_To_v1_PersistentVolumeClaim,
- autoConvert_api_PersistentVolumeList_To_v1_PersistentVolumeList,
- autoConvert_api_PersistentVolumeSource_To_v1_PersistentVolumeSource,
- autoConvert_api_PersistentVolumeSpec_To_v1_PersistentVolumeSpec,
- autoConvert_api_PersistentVolumeStatus_To_v1_PersistentVolumeStatus,
- autoConvert_api_PersistentVolume_To_v1_PersistentVolume,
- autoConvert_api_PodAttachOptions_To_v1_PodAttachOptions,
- autoConvert_api_PodCondition_To_v1_PodCondition,
- autoConvert_api_PodExecOptions_To_v1_PodExecOptions,
- autoConvert_api_PodList_To_v1_PodList,
- autoConvert_api_PodLogOptions_To_v1_PodLogOptions,
- autoConvert_api_PodProxyOptions_To_v1_PodProxyOptions,
- autoConvert_api_PodSpec_To_v1_PodSpec,
- autoConvert_api_PodStatusResult_To_v1_PodStatusResult,
- autoConvert_api_PodStatus_To_v1_PodStatus,
- autoConvert_api_PodTemplateList_To_v1_PodTemplateList,
- autoConvert_api_PodTemplateSpec_To_v1_PodTemplateSpec,
- autoConvert_api_PodTemplate_To_v1_PodTemplate,
- autoConvert_api_Pod_To_v1_Pod,
- autoConvert_api_Probe_To_v1_Probe,
- autoConvert_api_RBDVolumeSource_To_v1_RBDVolumeSource,
- autoConvert_api_RangeAllocation_To_v1_RangeAllocation,
- autoConvert_api_ReplicationControllerList_To_v1_ReplicationControllerList,
- autoConvert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec,
- autoConvert_api_ReplicationControllerStatus_To_v1_ReplicationControllerStatus,
- autoConvert_api_ReplicationController_To_v1_ReplicationController,
- autoConvert_api_ResourceQuotaList_To_v1_ResourceQuotaList,
- autoConvert_api_ResourceQuotaSpec_To_v1_ResourceQuotaSpec,
- autoConvert_api_ResourceQuotaStatus_To_v1_ResourceQuotaStatus,
- autoConvert_api_ResourceQuota_To_v1_ResourceQuota,
- autoConvert_api_ResourceRequirements_To_v1_ResourceRequirements,
- autoConvert_api_SELinuxOptions_To_v1_SELinuxOptions,
- autoConvert_api_SecretKeySelector_To_v1_SecretKeySelector,
- autoConvert_api_SecretList_To_v1_SecretList,
- autoConvert_api_SecretVolumeSource_To_v1_SecretVolumeSource,
- autoConvert_api_Secret_To_v1_Secret,
- autoConvert_api_SecurityContext_To_v1_SecurityContext,
- autoConvert_api_SerializedReference_To_v1_SerializedReference,
- autoConvert_api_ServiceAccountList_To_v1_ServiceAccountList,
- autoConvert_api_ServiceAccount_To_v1_ServiceAccount,
- autoConvert_api_ServiceList_To_v1_ServiceList,
- autoConvert_api_ServicePort_To_v1_ServicePort,
- autoConvert_api_ServiceProxyOptions_To_v1_ServiceProxyOptions,
- autoConvert_api_ServiceSpec_To_v1_ServiceSpec,
- autoConvert_api_ServiceStatus_To_v1_ServiceStatus,
- autoConvert_api_Service_To_v1_Service,
- autoConvert_api_TCPSocketAction_To_v1_TCPSocketAction,
- autoConvert_api_VolumeMount_To_v1_VolumeMount,
- autoConvert_api_VolumeSource_To_v1_VolumeSource,
- autoConvert_api_Volume_To_v1_Volume,
- autoConvert_unversioned_ExportOptions_To_v1_ExportOptions,
- autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_api_AWSElasticBlockStoreVolumeSource,
- autoConvert_v1_AzureFileVolumeSource_To_api_AzureFileVolumeSource,
- autoConvert_v1_Binding_To_api_Binding,
- autoConvert_v1_Capabilities_To_api_Capabilities,
- autoConvert_v1_CephFSVolumeSource_To_api_CephFSVolumeSource,
- autoConvert_v1_CinderVolumeSource_To_api_CinderVolumeSource,
- autoConvert_v1_ComponentCondition_To_api_ComponentCondition,
- autoConvert_v1_ComponentStatusList_To_api_ComponentStatusList,
- autoConvert_v1_ComponentStatus_To_api_ComponentStatus,
- autoConvert_v1_ConfigMapKeySelector_To_api_ConfigMapKeySelector,
- autoConvert_v1_ConfigMapList_To_api_ConfigMapList,
- autoConvert_v1_ConfigMapVolumeSource_To_api_ConfigMapVolumeSource,
- autoConvert_v1_ConfigMap_To_api_ConfigMap,
- autoConvert_v1_ContainerImage_To_api_ContainerImage,
- autoConvert_v1_ContainerPort_To_api_ContainerPort,
- autoConvert_v1_ContainerStateRunning_To_api_ContainerStateRunning,
- autoConvert_v1_ContainerStateTerminated_To_api_ContainerStateTerminated,
- autoConvert_v1_ContainerStateWaiting_To_api_ContainerStateWaiting,
- autoConvert_v1_ContainerState_To_api_ContainerState,
- autoConvert_v1_ContainerStatus_To_api_ContainerStatus,
- autoConvert_v1_Container_To_api_Container,
- autoConvert_v1_DaemonEndpoint_To_api_DaemonEndpoint,
- autoConvert_v1_DeleteOptions_To_api_DeleteOptions,
- autoConvert_v1_DownwardAPIVolumeFile_To_api_DownwardAPIVolumeFile,
- autoConvert_v1_DownwardAPIVolumeSource_To_api_DownwardAPIVolumeSource,
- autoConvert_v1_EmptyDirVolumeSource_To_api_EmptyDirVolumeSource,
- autoConvert_v1_EndpointAddress_To_api_EndpointAddress,
- autoConvert_v1_EndpointPort_To_api_EndpointPort,
- autoConvert_v1_EndpointSubset_To_api_EndpointSubset,
- autoConvert_v1_EndpointsList_To_api_EndpointsList,
- autoConvert_v1_Endpoints_To_api_Endpoints,
- autoConvert_v1_EnvVarSource_To_api_EnvVarSource,
- autoConvert_v1_EnvVar_To_api_EnvVar,
- autoConvert_v1_EventList_To_api_EventList,
- autoConvert_v1_EventSource_To_api_EventSource,
- autoConvert_v1_Event_To_api_Event,
- autoConvert_v1_ExecAction_To_api_ExecAction,
- autoConvert_v1_ExportOptions_To_unversioned_ExportOptions,
- autoConvert_v1_FCVolumeSource_To_api_FCVolumeSource,
- autoConvert_v1_FlexVolumeSource_To_api_FlexVolumeSource,
- autoConvert_v1_FlockerVolumeSource_To_api_FlockerVolumeSource,
- autoConvert_v1_GCEPersistentDiskVolumeSource_To_api_GCEPersistentDiskVolumeSource,
- autoConvert_v1_GitRepoVolumeSource_To_api_GitRepoVolumeSource,
- autoConvert_v1_GlusterfsVolumeSource_To_api_GlusterfsVolumeSource,
- autoConvert_v1_HTTPGetAction_To_api_HTTPGetAction,
- autoConvert_v1_HTTPHeader_To_api_HTTPHeader,
- autoConvert_v1_Handler_To_api_Handler,
- autoConvert_v1_HostPathVolumeSource_To_api_HostPathVolumeSource,
- autoConvert_v1_ISCSIVolumeSource_To_api_ISCSIVolumeSource,
- autoConvert_v1_KeyToPath_To_api_KeyToPath,
- autoConvert_v1_Lifecycle_To_api_Lifecycle,
- autoConvert_v1_LimitRangeItem_To_api_LimitRangeItem,
- autoConvert_v1_LimitRangeList_To_api_LimitRangeList,
- autoConvert_v1_LimitRangeSpec_To_api_LimitRangeSpec,
- autoConvert_v1_LimitRange_To_api_LimitRange,
- autoConvert_v1_ListOptions_To_api_ListOptions,
- autoConvert_v1_List_To_api_List,
- autoConvert_v1_LoadBalancerIngress_To_api_LoadBalancerIngress,
- autoConvert_v1_LoadBalancerStatus_To_api_LoadBalancerStatus,
- autoConvert_v1_LocalObjectReference_To_api_LocalObjectReference,
- autoConvert_v1_NFSVolumeSource_To_api_NFSVolumeSource,
- autoConvert_v1_NamespaceList_To_api_NamespaceList,
- autoConvert_v1_NamespaceSpec_To_api_NamespaceSpec,
- autoConvert_v1_NamespaceStatus_To_api_NamespaceStatus,
- autoConvert_v1_Namespace_To_api_Namespace,
- autoConvert_v1_NodeAddress_To_api_NodeAddress,
- autoConvert_v1_NodeCondition_To_api_NodeCondition,
- autoConvert_v1_NodeDaemonEndpoints_To_api_NodeDaemonEndpoints,
- autoConvert_v1_NodeList_To_api_NodeList,
- autoConvert_v1_NodeProxyOptions_To_api_NodeProxyOptions,
- autoConvert_v1_NodeSpec_To_api_NodeSpec,
- autoConvert_v1_NodeStatus_To_api_NodeStatus,
- autoConvert_v1_NodeSystemInfo_To_api_NodeSystemInfo,
- autoConvert_v1_Node_To_api_Node,
- autoConvert_v1_ObjectFieldSelector_To_api_ObjectFieldSelector,
- autoConvert_v1_ObjectMeta_To_api_ObjectMeta,
- autoConvert_v1_ObjectReference_To_api_ObjectReference,
- autoConvert_v1_PersistentVolumeClaimList_To_api_PersistentVolumeClaimList,
- autoConvert_v1_PersistentVolumeClaimSpec_To_api_PersistentVolumeClaimSpec,
- autoConvert_v1_PersistentVolumeClaimStatus_To_api_PersistentVolumeClaimStatus,
- autoConvert_v1_PersistentVolumeClaimVolumeSource_To_api_PersistentVolumeClaimVolumeSource,
- autoConvert_v1_PersistentVolumeClaim_To_api_PersistentVolumeClaim,
- autoConvert_v1_PersistentVolumeList_To_api_PersistentVolumeList,
- autoConvert_v1_PersistentVolumeSource_To_api_PersistentVolumeSource,
- autoConvert_v1_PersistentVolumeSpec_To_api_PersistentVolumeSpec,
- autoConvert_v1_PersistentVolumeStatus_To_api_PersistentVolumeStatus,
- autoConvert_v1_PersistentVolume_To_api_PersistentVolume,
- autoConvert_v1_PodAttachOptions_To_api_PodAttachOptions,
- autoConvert_v1_PodCondition_To_api_PodCondition,
- autoConvert_v1_PodExecOptions_To_api_PodExecOptions,
- autoConvert_v1_PodList_To_api_PodList,
- autoConvert_v1_PodLogOptions_To_api_PodLogOptions,
- autoConvert_v1_PodProxyOptions_To_api_PodProxyOptions,
- autoConvert_v1_PodSpec_To_api_PodSpec,
- autoConvert_v1_PodStatusResult_To_api_PodStatusResult,
- autoConvert_v1_PodStatus_To_api_PodStatus,
- autoConvert_v1_PodTemplateList_To_api_PodTemplateList,
- autoConvert_v1_PodTemplateSpec_To_api_PodTemplateSpec,
- autoConvert_v1_PodTemplate_To_api_PodTemplate,
- autoConvert_v1_Pod_To_api_Pod,
- autoConvert_v1_Probe_To_api_Probe,
- autoConvert_v1_RBDVolumeSource_To_api_RBDVolumeSource,
- autoConvert_v1_RangeAllocation_To_api_RangeAllocation,
- autoConvert_v1_ReplicationControllerList_To_api_ReplicationControllerList,
- autoConvert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec,
- autoConvert_v1_ReplicationControllerStatus_To_api_ReplicationControllerStatus,
- autoConvert_v1_ReplicationController_To_api_ReplicationController,
- autoConvert_v1_ResourceQuotaList_To_api_ResourceQuotaList,
- autoConvert_v1_ResourceQuotaSpec_To_api_ResourceQuotaSpec,
- autoConvert_v1_ResourceQuotaStatus_To_api_ResourceQuotaStatus,
- autoConvert_v1_ResourceQuota_To_api_ResourceQuota,
- autoConvert_v1_ResourceRequirements_To_api_ResourceRequirements,
- autoConvert_v1_SELinuxOptions_To_api_SELinuxOptions,
- autoConvert_v1_SecretKeySelector_To_api_SecretKeySelector,
- autoConvert_v1_SecretList_To_api_SecretList,
- autoConvert_v1_SecretVolumeSource_To_api_SecretVolumeSource,
- autoConvert_v1_Secret_To_api_Secret,
- autoConvert_v1_SecurityContext_To_api_SecurityContext,
- autoConvert_v1_SerializedReference_To_api_SerializedReference,
- autoConvert_v1_ServiceAccountList_To_api_ServiceAccountList,
- autoConvert_v1_ServiceAccount_To_api_ServiceAccount,
- autoConvert_v1_ServiceList_To_api_ServiceList,
- autoConvert_v1_ServicePort_To_api_ServicePort,
- autoConvert_v1_ServiceProxyOptions_To_api_ServiceProxyOptions,
- autoConvert_v1_ServiceSpec_To_api_ServiceSpec,
- autoConvert_v1_ServiceStatus_To_api_ServiceStatus,
- autoConvert_v1_Service_To_api_Service,
- autoConvert_v1_TCPSocketAction_To_api_TCPSocketAction,
- autoConvert_v1_VolumeMount_To_api_VolumeMount,
- autoConvert_v1_VolumeSource_To_api_VolumeSource,
- autoConvert_v1_Volume_To_api_Volume,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
+func autoConvert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *VolumeSource, s conversion.Scope) error {
+ if in.HostPath != nil {
+ in, out := &in.HostPath, &out.HostPath
+ *out = new(HostPathVolumeSource)
+ if err := Convert_api_HostPathVolumeSource_To_v1_HostPathVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.HostPath = nil
+ }
+ if in.EmptyDir != nil {
+ in, out := &in.EmptyDir, &out.EmptyDir
+ *out = new(EmptyDirVolumeSource)
+ if err := Convert_api_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.EmptyDir = nil
+ }
+ if in.GCEPersistentDisk != nil {
+ in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(GCEPersistentDiskVolumeSource)
+ if err := Convert_api_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.GCEPersistentDisk = nil
+ }
+ if in.AWSElasticBlockStore != nil {
+ in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(AWSElasticBlockStoreVolumeSource)
+ if err := Convert_api_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.AWSElasticBlockStore = nil
+ }
+ if in.GitRepo != nil {
+ in, out := &in.GitRepo, &out.GitRepo
+ *out = new(GitRepoVolumeSource)
+ if err := Convert_api_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.GitRepo = nil
+ }
+ if in.Secret != nil {
+ in, out := &in.Secret, &out.Secret
+ *out = new(SecretVolumeSource)
+ if err := Convert_api_SecretVolumeSource_To_v1_SecretVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Secret = nil
+ }
+ if in.NFS != nil {
+ in, out := &in.NFS, &out.NFS
+ *out = new(NFSVolumeSource)
+ if err := Convert_api_NFSVolumeSource_To_v1_NFSVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NFS = nil
+ }
+ if in.ISCSI != nil {
+ in, out := &in.ISCSI, &out.ISCSI
+ *out = new(ISCSIVolumeSource)
+ if err := Convert_api_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ISCSI = nil
+ }
+ if in.Glusterfs != nil {
+ in, out := &in.Glusterfs, &out.Glusterfs
+ *out = new(GlusterfsVolumeSource)
+ if err := Convert_api_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Glusterfs = nil
+ }
+ if in.PersistentVolumeClaim != nil {
+ in, out := &in.PersistentVolumeClaim, &out.PersistentVolumeClaim
+ *out = new(PersistentVolumeClaimVolumeSource)
+ if err := Convert_api_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PersistentVolumeClaim = nil
+ }
+ if in.RBD != nil {
+ in, out := &in.RBD, &out.RBD
+ *out = new(RBDVolumeSource)
+ if err := Convert_api_RBDVolumeSource_To_v1_RBDVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RBD = nil
+ }
+ if in.FlexVolume != nil {
+ in, out := &in.FlexVolume, &out.FlexVolume
+ *out = new(FlexVolumeSource)
+ if err := Convert_api_FlexVolumeSource_To_v1_FlexVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FlexVolume = nil
+ }
+ if in.Cinder != nil {
+ in, out := &in.Cinder, &out.Cinder
+ *out = new(CinderVolumeSource)
+ if err := Convert_api_CinderVolumeSource_To_v1_CinderVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Cinder = nil
+ }
+ if in.CephFS != nil {
+ in, out := &in.CephFS, &out.CephFS
+ *out = new(CephFSVolumeSource)
+ if err := Convert_api_CephFSVolumeSource_To_v1_CephFSVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.CephFS = nil
+ }
+ if in.Flocker != nil {
+ in, out := &in.Flocker, &out.Flocker
+ *out = new(FlockerVolumeSource)
+ if err := Convert_api_FlockerVolumeSource_To_v1_FlockerVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Flocker = nil
+ }
+ if in.DownwardAPI != nil {
+ in, out := &in.DownwardAPI, &out.DownwardAPI
+ *out = new(DownwardAPIVolumeSource)
+ if err := Convert_api_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.DownwardAPI = nil
+ }
+ if in.FC != nil {
+ in, out := &in.FC, &out.FC
+ *out = new(FCVolumeSource)
+ if err := Convert_api_FCVolumeSource_To_v1_FCVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.FC = nil
+ }
+ if in.AzureFile != nil {
+ in, out := &in.AzureFile, &out.AzureFile
+ *out = new(AzureFileVolumeSource)
+ if err := Convert_api_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.AzureFile = nil
+ }
+ if in.ConfigMap != nil {
+ in, out := &in.ConfigMap, &out.ConfigMap
+ *out = new(ConfigMapVolumeSource)
+ if err := Convert_api_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ConfigMap = nil
+ }
+ if in.VsphereVolume != nil {
+ in, out := &in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := Convert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
+ return nil
+}
+
+func Convert_api_VolumeSource_To_v1_VolumeSource(in *api.VolumeSource, out *VolumeSource, s conversion.Scope) error {
+ return autoConvert_api_VolumeSource_To_v1_VolumeSource(in, out, s)
+}
+
+func autoConvert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource(in *VsphereVirtualDiskVolumeSource, out *api.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
+ out.VolumePath = in.VolumePath
+ out.FSType = in.FSType
+ return nil
+}
+
+func Convert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource(in *VsphereVirtualDiskVolumeSource, out *api.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
+ return autoConvert_v1_VsphereVirtualDiskVolumeSource_To_api_VsphereVirtualDiskVolumeSource(in, out, s)
+}
+
+func autoConvert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in *api.VsphereVirtualDiskVolumeSource, out *VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
+ out.VolumePath = in.VolumePath
+ out.FSType = in.FSType
+ return nil
+}
+
+func Convert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in *api.VsphereVirtualDiskVolumeSource, out *VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
+ return autoConvert_api_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in, out, s)
+}
+
+func autoConvert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm(in *WeightedPodAffinityTerm, out *api.WeightedPodAffinityTerm, s conversion.Scope) error {
+ out.Weight = int(in.Weight)
+ if err := Convert_v1_PodAffinityTerm_To_api_PodAffinityTerm(&in.PodAffinityTerm, &out.PodAffinityTerm, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm(in *WeightedPodAffinityTerm, out *api.WeightedPodAffinityTerm, s conversion.Scope) error {
+ return autoConvert_v1_WeightedPodAffinityTerm_To_api_WeightedPodAffinityTerm(in, out, s)
+}
+
+func autoConvert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in *api.WeightedPodAffinityTerm, out *WeightedPodAffinityTerm, s conversion.Scope) error {
+ out.Weight = int32(in.Weight)
+ if err := Convert_api_PodAffinityTerm_To_v1_PodAffinityTerm(&in.PodAffinityTerm, &out.PodAffinityTerm, s); err != nil {
+ return err
}
+ return nil
+}
+
+func Convert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in *api.WeightedPodAffinityTerm, out *WeightedPodAffinityTerm, s conversion.Scope) error {
+ return autoConvert_api_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in, out, s)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..e7d59684a7075355943502dd19a0841a8e4a8d9f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/deep_copy_generated.go
@@ -0,0 +1,3261 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ resource "k8s.io/kubernetes/pkg/api/resource"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ runtime "k8s.io/kubernetes/pkg/runtime"
+ types "k8s.io/kubernetes/pkg/types"
+ intstr "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1_AWSElasticBlockStoreVolumeSource,
+ DeepCopy_v1_Affinity,
+ DeepCopy_v1_AttachedVolume,
+ DeepCopy_v1_AzureFileVolumeSource,
+ DeepCopy_v1_Binding,
+ DeepCopy_v1_Capabilities,
+ DeepCopy_v1_CephFSVolumeSource,
+ DeepCopy_v1_CinderVolumeSource,
+ DeepCopy_v1_ComponentCondition,
+ DeepCopy_v1_ComponentStatus,
+ DeepCopy_v1_ComponentStatusList,
+ DeepCopy_v1_ConfigMap,
+ DeepCopy_v1_ConfigMapKeySelector,
+ DeepCopy_v1_ConfigMapList,
+ DeepCopy_v1_ConfigMapVolumeSource,
+ DeepCopy_v1_Container,
+ DeepCopy_v1_ContainerImage,
+ DeepCopy_v1_ContainerPort,
+ DeepCopy_v1_ContainerState,
+ DeepCopy_v1_ContainerStateRunning,
+ DeepCopy_v1_ContainerStateTerminated,
+ DeepCopy_v1_ContainerStateWaiting,
+ DeepCopy_v1_ContainerStatus,
+ DeepCopy_v1_DaemonEndpoint,
+ DeepCopy_v1_DeleteOptions,
+ DeepCopy_v1_DownwardAPIVolumeFile,
+ DeepCopy_v1_DownwardAPIVolumeSource,
+ DeepCopy_v1_EmptyDirVolumeSource,
+ DeepCopy_v1_EndpointAddress,
+ DeepCopy_v1_EndpointPort,
+ DeepCopy_v1_EndpointSubset,
+ DeepCopy_v1_Endpoints,
+ DeepCopy_v1_EndpointsList,
+ DeepCopy_v1_EnvVar,
+ DeepCopy_v1_EnvVarSource,
+ DeepCopy_v1_Event,
+ DeepCopy_v1_EventList,
+ DeepCopy_v1_EventSource,
+ DeepCopy_v1_ExecAction,
+ DeepCopy_v1_ExportOptions,
+ DeepCopy_v1_FCVolumeSource,
+ DeepCopy_v1_FlexVolumeSource,
+ DeepCopy_v1_FlockerVolumeSource,
+ DeepCopy_v1_GCEPersistentDiskVolumeSource,
+ DeepCopy_v1_GitRepoVolumeSource,
+ DeepCopy_v1_GlusterfsVolumeSource,
+ DeepCopy_v1_HTTPGetAction,
+ DeepCopy_v1_HTTPHeader,
+ DeepCopy_v1_Handler,
+ DeepCopy_v1_HostPathVolumeSource,
+ DeepCopy_v1_ISCSIVolumeSource,
+ DeepCopy_v1_KeyToPath,
+ DeepCopy_v1_Lifecycle,
+ DeepCopy_v1_LimitRange,
+ DeepCopy_v1_LimitRangeItem,
+ DeepCopy_v1_LimitRangeList,
+ DeepCopy_v1_LimitRangeSpec,
+ DeepCopy_v1_List,
+ DeepCopy_v1_ListOptions,
+ DeepCopy_v1_LoadBalancerIngress,
+ DeepCopy_v1_LoadBalancerStatus,
+ DeepCopy_v1_LocalObjectReference,
+ DeepCopy_v1_NFSVolumeSource,
+ DeepCopy_v1_Namespace,
+ DeepCopy_v1_NamespaceList,
+ DeepCopy_v1_NamespaceSpec,
+ DeepCopy_v1_NamespaceStatus,
+ DeepCopy_v1_Node,
+ DeepCopy_v1_NodeAddress,
+ DeepCopy_v1_NodeAffinity,
+ DeepCopy_v1_NodeCondition,
+ DeepCopy_v1_NodeDaemonEndpoints,
+ DeepCopy_v1_NodeList,
+ DeepCopy_v1_NodeProxyOptions,
+ DeepCopy_v1_NodeSelector,
+ DeepCopy_v1_NodeSelectorRequirement,
+ DeepCopy_v1_NodeSelectorTerm,
+ DeepCopy_v1_NodeSpec,
+ DeepCopy_v1_NodeStatus,
+ DeepCopy_v1_NodeSystemInfo,
+ DeepCopy_v1_ObjectFieldSelector,
+ DeepCopy_v1_ObjectMeta,
+ DeepCopy_v1_ObjectReference,
+ DeepCopy_v1_OwnerReference,
+ DeepCopy_v1_PersistentVolume,
+ DeepCopy_v1_PersistentVolumeClaim,
+ DeepCopy_v1_PersistentVolumeClaimList,
+ DeepCopy_v1_PersistentVolumeClaimSpec,
+ DeepCopy_v1_PersistentVolumeClaimStatus,
+ DeepCopy_v1_PersistentVolumeClaimVolumeSource,
+ DeepCopy_v1_PersistentVolumeList,
+ DeepCopy_v1_PersistentVolumeSource,
+ DeepCopy_v1_PersistentVolumeSpec,
+ DeepCopy_v1_PersistentVolumeStatus,
+ DeepCopy_v1_Pod,
+ DeepCopy_v1_PodAffinity,
+ DeepCopy_v1_PodAffinityTerm,
+ DeepCopy_v1_PodAntiAffinity,
+ DeepCopy_v1_PodAttachOptions,
+ DeepCopy_v1_PodCondition,
+ DeepCopy_v1_PodExecOptions,
+ DeepCopy_v1_PodList,
+ DeepCopy_v1_PodLogOptions,
+ DeepCopy_v1_PodProxyOptions,
+ DeepCopy_v1_PodSecurityContext,
+ DeepCopy_v1_PodSpec,
+ DeepCopy_v1_PodStatus,
+ DeepCopy_v1_PodStatusResult,
+ DeepCopy_v1_PodTemplate,
+ DeepCopy_v1_PodTemplateList,
+ DeepCopy_v1_PodTemplateSpec,
+ DeepCopy_v1_Preconditions,
+ DeepCopy_v1_PreferredSchedulingTerm,
+ DeepCopy_v1_Probe,
+ DeepCopy_v1_RBDVolumeSource,
+ DeepCopy_v1_RangeAllocation,
+ DeepCopy_v1_ReplicationController,
+ DeepCopy_v1_ReplicationControllerList,
+ DeepCopy_v1_ReplicationControllerSpec,
+ DeepCopy_v1_ReplicationControllerStatus,
+ DeepCopy_v1_ResourceFieldSelector,
+ DeepCopy_v1_ResourceQuota,
+ DeepCopy_v1_ResourceQuotaList,
+ DeepCopy_v1_ResourceQuotaSpec,
+ DeepCopy_v1_ResourceQuotaStatus,
+ DeepCopy_v1_ResourceRequirements,
+ DeepCopy_v1_SELinuxOptions,
+ DeepCopy_v1_Secret,
+ DeepCopy_v1_SecretKeySelector,
+ DeepCopy_v1_SecretList,
+ DeepCopy_v1_SecretVolumeSource,
+ DeepCopy_v1_SecurityContext,
+ DeepCopy_v1_SerializedReference,
+ DeepCopy_v1_Service,
+ DeepCopy_v1_ServiceAccount,
+ DeepCopy_v1_ServiceAccountList,
+ DeepCopy_v1_ServiceList,
+ DeepCopy_v1_ServicePort,
+ DeepCopy_v1_ServiceProxyOptions,
+ DeepCopy_v1_ServiceSpec,
+ DeepCopy_v1_ServiceStatus,
+ DeepCopy_v1_TCPSocketAction,
+ DeepCopy_v1_Taint,
+ DeepCopy_v1_Toleration,
+ DeepCopy_v1_Volume,
+ DeepCopy_v1_VolumeMount,
+ DeepCopy_v1_VolumeSource,
+ DeepCopy_v1_VsphereVirtualDiskVolumeSource,
+ DeepCopy_v1_WeightedPodAffinityTerm,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1_AWSElasticBlockStoreVolumeSource(in AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error {
+ out.VolumeID = in.VolumeID
+ out.FSType = in.FSType
+ out.Partition = in.Partition
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_Affinity(in Affinity, out *Affinity, c *conversion.Cloner) error {
+ if in.NodeAffinity != nil {
+ in, out := in.NodeAffinity, &out.NodeAffinity
+ *out = new(NodeAffinity)
+ if err := DeepCopy_v1_NodeAffinity(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NodeAffinity = nil
+ }
+ if in.PodAffinity != nil {
+ in, out := in.PodAffinity, &out.PodAffinity
+ *out = new(PodAffinity)
+ if err := DeepCopy_v1_PodAffinity(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodAffinity = nil
+ }
+ if in.PodAntiAffinity != nil {
+ in, out := in.PodAntiAffinity, &out.PodAntiAffinity
+ *out = new(PodAntiAffinity)
+ if err := DeepCopy_v1_PodAntiAffinity(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodAntiAffinity = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_AttachedVolume(in AttachedVolume, out *AttachedVolume, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.DevicePath = in.DevicePath
+ return nil
+}
+
+func DeepCopy_v1_AzureFileVolumeSource(in AzureFileVolumeSource, out *AzureFileVolumeSource, c *conversion.Cloner) error {
+ out.SecretName = in.SecretName
+ out.ShareName = in.ShareName
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_Binding(in Binding, out *Binding, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectReference(in.Target, &out.Target, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_Capabilities(in Capabilities, out *Capabilities, c *conversion.Cloner) error {
+ if in.Add != nil {
+ in, out := in.Add, &out.Add
+ *out = make([]Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Add = nil
+ }
+ if in.Drop != nil {
+ in, out := in.Drop, &out.Drop
+ *out = make([]Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Drop = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_CephFSVolumeSource(in CephFSVolumeSource, out *CephFSVolumeSource, c *conversion.Cloner) error {
+ if in.Monitors != nil {
+ in, out := in.Monitors, &out.Monitors
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Monitors = nil
+ }
+ out.Path = in.Path
+ out.User = in.User
+ out.SecretFile = in.SecretFile
+ if in.SecretRef != nil {
+ in, out := in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := DeepCopy_v1_LocalObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_CinderVolumeSource(in CinderVolumeSource, out *CinderVolumeSource, c *conversion.Cloner) error {
+ out.VolumeID = in.VolumeID
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_ComponentCondition(in ComponentCondition, out *ComponentCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ out.Message = in.Message
+ out.Error = in.Error
+ return nil
+}
+
+func DeepCopy_v1_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]ComponentCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ComponentCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ComponentStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ComponentStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ConfigMap(in ConfigMap, out *ConfigMap, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Data != nil {
+ in, out := in.Data, &out.Data
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Data = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ConfigMapKeySelector(in ConfigMapKeySelector, out *ConfigMapKeySelector, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
+ return err
+ }
+ out.Key = in.Key
+ return nil
+}
+
+func DeepCopy_v1_ConfigMapList(in ConfigMapList, out *ConfigMapList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ConfigMap, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ConfigMap(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ConfigMapVolumeSource(in ConfigMapVolumeSource, out *ConfigMapVolumeSource, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]KeyToPath, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_KeyToPath(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_Container(in Container, out *Container, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Image = in.Image
+ if in.Command != nil {
+ in, out := in.Command, &out.Command
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Command = nil
+ }
+ if in.Args != nil {
+ in, out := in.Args, &out.Args
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Args = nil
+ }
+ out.WorkingDir = in.WorkingDir
+ if in.Ports != nil {
+ in, out := in.Ports, &out.Ports
+ *out = make([]ContainerPort, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ContainerPort(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.Env != nil {
+ in, out := in.Env, &out.Env
+ *out = make([]EnvVar, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_EnvVar(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Env = nil
+ }
+ if err := DeepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
+ return err
+ }
+ if in.VolumeMounts != nil {
+ in, out := in.VolumeMounts, &out.VolumeMounts
+ *out = make([]VolumeMount, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_VolumeMount(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeMounts = nil
+ }
+ if in.LivenessProbe != nil {
+ in, out := in.LivenessProbe, &out.LivenessProbe
+ *out = new(Probe)
+ if err := DeepCopy_v1_Probe(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LivenessProbe = nil
+ }
+ if in.ReadinessProbe != nil {
+ in, out := in.ReadinessProbe, &out.ReadinessProbe
+ *out = new(Probe)
+ if err := DeepCopy_v1_Probe(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ReadinessProbe = nil
+ }
+ if in.Lifecycle != nil {
+ in, out := in.Lifecycle, &out.Lifecycle
+ *out = new(Lifecycle)
+ if err := DeepCopy_v1_Lifecycle(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Lifecycle = nil
+ }
+ out.TerminationMessagePath = in.TerminationMessagePath
+ out.ImagePullPolicy = in.ImagePullPolicy
+ if in.SecurityContext != nil {
+ in, out := in.SecurityContext, &out.SecurityContext
+ *out = new(SecurityContext)
+ if err := DeepCopy_v1_SecurityContext(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecurityContext = nil
+ }
+ out.Stdin = in.Stdin
+ out.StdinOnce = in.StdinOnce
+ out.TTY = in.TTY
+ return nil
+}
+
+func DeepCopy_v1_ContainerImage(in ContainerImage, out *ContainerImage, c *conversion.Cloner) error {
+ if in.Names != nil {
+ in, out := in.Names, &out.Names
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Names = nil
+ }
+ out.SizeBytes = in.SizeBytes
+ return nil
+}
+
+func DeepCopy_v1_ContainerPort(in ContainerPort, out *ContainerPort, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.HostPort = in.HostPort
+ out.ContainerPort = in.ContainerPort
+ out.Protocol = in.Protocol
+ out.HostIP = in.HostIP
+ return nil
+}
+
+func DeepCopy_v1_ContainerState(in ContainerState, out *ContainerState, c *conversion.Cloner) error {
+ if in.Waiting != nil {
+ in, out := in.Waiting, &out.Waiting
+ *out = new(ContainerStateWaiting)
+ if err := DeepCopy_v1_ContainerStateWaiting(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Waiting = nil
+ }
+ if in.Running != nil {
+ in, out := in.Running, &out.Running
+ *out = new(ContainerStateRunning)
+ if err := DeepCopy_v1_ContainerStateRunning(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Running = nil
+ }
+ if in.Terminated != nil {
+ in, out := in.Terminated, &out.Terminated
+ *out = new(ContainerStateTerminated)
+ if err := DeepCopy_v1_ContainerStateTerminated(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Terminated = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ContainerStateTerminated(in ContainerStateTerminated, out *ContainerStateTerminated, c *conversion.Cloner) error {
+ out.ExitCode = in.ExitCode
+ out.Signal = in.Signal
+ out.Reason = in.Reason
+ out.Message = in.Message
+ if err := unversioned.DeepCopy_unversioned_Time(in.StartedAt, &out.StartedAt, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.FinishedAt, &out.FinishedAt, c); err != nil {
+ return err
+ }
+ out.ContainerID = in.ContainerID
+ return nil
+}
+
+func DeepCopy_v1_ContainerStateWaiting(in ContainerStateWaiting, out *ContainerStateWaiting, c *conversion.Cloner) error {
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := DeepCopy_v1_ContainerState(in.State, &out.State, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ContainerState(in.LastTerminationState, &out.LastTerminationState, c); err != nil {
+ return err
+ }
+ out.Ready = in.Ready
+ out.RestartCount = in.RestartCount
+ out.Image = in.Image
+ out.ImageID = in.ImageID
+ out.ContainerID = in.ContainerID
+ return nil
+}
+
+func DeepCopy_v1_DaemonEndpoint(in DaemonEndpoint, out *DaemonEndpoint, c *conversion.Cloner) error {
+ out.Port = in.Port
+ return nil
+}
+
+func DeepCopy_v1_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if in.GracePeriodSeconds != nil {
+ in, out := in.GracePeriodSeconds, &out.GracePeriodSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.GracePeriodSeconds = nil
+ }
+ if in.Preconditions != nil {
+ in, out := in.Preconditions, &out.Preconditions
+ *out = new(Preconditions)
+ if err := DeepCopy_v1_Preconditions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Preconditions = nil
+ }
+ if in.OrphanDependents != nil {
+ in, out := in.OrphanDependents, &out.OrphanDependents
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.OrphanDependents = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_DownwardAPIVolumeFile(in DownwardAPIVolumeFile, out *DownwardAPIVolumeFile, c *conversion.Cloner) error {
+ out.Path = in.Path
+ if in.FieldRef != nil {
+ in, out := in.FieldRef, &out.FieldRef
+ *out = new(ObjectFieldSelector)
+ if err := DeepCopy_v1_ObjectFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
+ }
+ if in.ResourceFieldRef != nil {
+ in, out := in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := DeepCopy_v1_ResourceFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_DownwardAPIVolumeSource(in DownwardAPIVolumeSource, out *DownwardAPIVolumeSource, c *conversion.Cloner) error {
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]DownwardAPIVolumeFile, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_DownwardAPIVolumeFile(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVolumeSource, c *conversion.Cloner) error {
+ out.Medium = in.Medium
+ return nil
+}
+
+func DeepCopy_v1_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error {
+ out.IP = in.IP
+ out.Hostname = in.Hostname
+ if in.TargetRef != nil {
+ in, out := in.TargetRef, &out.TargetRef
+ *out = new(ObjectReference)
+ if err := DeepCopy_v1_ObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.TargetRef = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EndpointPort(in EndpointPort, out *EndpointPort, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Port = in.Port
+ out.Protocol = in.Protocol
+ return nil
+}
+
+func DeepCopy_v1_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conversion.Cloner) error {
+ if in.Addresses != nil {
+ in, out := in.Addresses, &out.Addresses
+ *out = make([]EndpointAddress, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_EndpointAddress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Addresses = nil
+ }
+ if in.NotReadyAddresses != nil {
+ in, out := in.NotReadyAddresses, &out.NotReadyAddresses
+ *out = make([]EndpointAddress, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_EndpointAddress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.NotReadyAddresses = nil
+ }
+ if in.Ports != nil {
+ in, out := in.Ports, &out.Ports
+ *out = make([]EndpointPort, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_EndpointPort(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Subsets != nil {
+ in, out := in.Subsets, &out.Subsets
+ *out = make([]EndpointSubset, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_EndpointSubset(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subsets = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Endpoints, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Endpoints(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EnvVar(in EnvVar, out *EnvVar, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Value = in.Value
+ if in.ValueFrom != nil {
+ in, out := in.ValueFrom, &out.ValueFrom
+ *out = new(EnvVarSource)
+ if err := DeepCopy_v1_EnvVarSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ValueFrom = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion.Cloner) error {
+ if in.FieldRef != nil {
+ in, out := in.FieldRef, &out.FieldRef
+ *out = new(ObjectFieldSelector)
+ if err := DeepCopy_v1_ObjectFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FieldRef = nil
+ }
+ if in.ResourceFieldRef != nil {
+ in, out := in.ResourceFieldRef, &out.ResourceFieldRef
+ *out = new(ResourceFieldSelector)
+ if err := DeepCopy_v1_ResourceFieldSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceFieldRef = nil
+ }
+ if in.ConfigMapKeyRef != nil {
+ in, out := in.ConfigMapKeyRef, &out.ConfigMapKeyRef
+ *out = new(ConfigMapKeySelector)
+ if err := DeepCopy_v1_ConfigMapKeySelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ConfigMapKeyRef = nil
+ }
+ if in.SecretKeyRef != nil {
+ in, out := in.SecretKeyRef, &out.SecretKeyRef
+ *out = new(SecretKeySelector)
+ if err := DeepCopy_v1_SecretKeySelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretKeyRef = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_Event(in Event, out *Event, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectReference(in.InvolvedObject, &out.InvolvedObject, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ if err := DeepCopy_v1_EventSource(in.Source, &out.Source, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil {
+ return err
+ }
+ out.Count = in.Count
+ out.Type = in.Type
+ return nil
+}
+
+func DeepCopy_v1_EventList(in EventList, out *EventList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Event, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Event(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_EventSource(in EventSource, out *EventSource, c *conversion.Cloner) error {
+ out.Component = in.Component
+ out.Host = in.Host
+ return nil
+}
+
+func DeepCopy_v1_ExecAction(in ExecAction, out *ExecAction, c *conversion.Cloner) error {
+ if in.Command != nil {
+ in, out := in.Command, &out.Command
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Command = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ExportOptions(in ExportOptions, out *ExportOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Export = in.Export
+ out.Exact = in.Exact
+ return nil
+}
+
+func DeepCopy_v1_FCVolumeSource(in FCVolumeSource, out *FCVolumeSource, c *conversion.Cloner) error {
+ if in.TargetWWNs != nil {
+ in, out := in.TargetWWNs, &out.TargetWWNs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.TargetWWNs = nil
+ }
+ if in.Lun != nil {
+ in, out := in.Lun, &out.Lun
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Lun = nil
+ }
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_FlexVolumeSource(in FlexVolumeSource, out *FlexVolumeSource, c *conversion.Cloner) error {
+ out.Driver = in.Driver
+ out.FSType = in.FSType
+ if in.SecretRef != nil {
+ in, out := in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := DeepCopy_v1_LocalObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ out.ReadOnly = in.ReadOnly
+ if in.Options != nil {
+ in, out := in.Options, &out.Options
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Options = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_FlockerVolumeSource(in FlockerVolumeSource, out *FlockerVolumeSource, c *conversion.Cloner) error {
+ out.DatasetName = in.DatasetName
+ return nil
+}
+
+func DeepCopy_v1_GCEPersistentDiskVolumeSource(in GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, c *conversion.Cloner) error {
+ out.PDName = in.PDName
+ out.FSType = in.FSType
+ out.Partition = in.Partition
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_GitRepoVolumeSource(in GitRepoVolumeSource, out *GitRepoVolumeSource, c *conversion.Cloner) error {
+ out.Repository = in.Repository
+ out.Revision = in.Revision
+ out.Directory = in.Directory
+ return nil
+}
+
+func DeepCopy_v1_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *GlusterfsVolumeSource, c *conversion.Cloner) error {
+ out.EndpointsName = in.EndpointsName
+ out.Path = in.Path
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error {
+ out.Path = in.Path
+ if err := intstr.DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
+ return err
+ }
+ out.Host = in.Host
+ out.Scheme = in.Scheme
+ if in.HTTPHeaders != nil {
+ in, out := in.HTTPHeaders, &out.HTTPHeaders
+ *out = make([]HTTPHeader, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_HTTPHeader(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HTTPHeaders = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_HTTPHeader(in HTTPHeader, out *HTTPHeader, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Value = in.Value
+ return nil
+}
+
+func DeepCopy_v1_Handler(in Handler, out *Handler, c *conversion.Cloner) error {
+ if in.Exec != nil {
+ in, out := in.Exec, &out.Exec
+ *out = new(ExecAction)
+ if err := DeepCopy_v1_ExecAction(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Exec = nil
+ }
+ if in.HTTPGet != nil {
+ in, out := in.HTTPGet, &out.HTTPGet
+ *out = new(HTTPGetAction)
+ if err := DeepCopy_v1_HTTPGetAction(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.HTTPGet = nil
+ }
+ if in.TCPSocket != nil {
+ in, out := in.TCPSocket, &out.TCPSocket
+ *out = new(TCPSocketAction)
+ if err := DeepCopy_v1_TCPSocketAction(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.TCPSocket = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_HostPathVolumeSource(in HostPathVolumeSource, out *HostPathVolumeSource, c *conversion.Cloner) error {
+ out.Path = in.Path
+ return nil
+}
+
+func DeepCopy_v1_ISCSIVolumeSource(in ISCSIVolumeSource, out *ISCSIVolumeSource, c *conversion.Cloner) error {
+ out.TargetPortal = in.TargetPortal
+ out.IQN = in.IQN
+ out.Lun = in.Lun
+ out.ISCSIInterface = in.ISCSIInterface
+ out.FSType = in.FSType
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_KeyToPath(in KeyToPath, out *KeyToPath, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Path = in.Path
+ return nil
+}
+
+func DeepCopy_v1_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner) error {
+ if in.PostStart != nil {
+ in, out := in.PostStart, &out.PostStart
+ *out = new(Handler)
+ if err := DeepCopy_v1_Handler(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PostStart = nil
+ }
+ if in.PreStop != nil {
+ in, out := in.PreStop, &out.PreStop
+ *out = new(Handler)
+ if err := DeepCopy_v1_Handler(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PreStop = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_LimitRangeSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conversion.Cloner) error {
+ out.Type = in.Type
+ if in.Max != nil {
+ in, out := in.Max, &out.Max
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Max = nil
+ }
+ if in.Min != nil {
+ in, out := in.Min, &out.Min
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Min = nil
+ }
+ if in.Default != nil {
+ in, out := in.Default, &out.Default
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Default = nil
+ }
+ if in.DefaultRequest != nil {
+ in, out := in.DefaultRequest, &out.DefaultRequest
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.DefaultRequest = nil
+ }
+ if in.MaxLimitRequestRatio != nil {
+ in, out := in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.MaxLimitRequestRatio = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]LimitRange, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LimitRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conversion.Cloner) error {
+ if in.Limits != nil {
+ in, out := in.Limits, &out.Limits
+ *out = make([]LimitRangeItem, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LimitRangeItem(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Limits = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_List(in List, out *List, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]runtime.RawExtension, len(in))
+ for i := range in {
+ if err := runtime.DeepCopy_runtime_RawExtension(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.LabelSelector = in.LabelSelector
+ out.FieldSelector = in.FieldSelector
+ out.Watch = in.Watch
+ out.ResourceVersion = in.ResourceVersion
+ if in.TimeoutSeconds != nil {
+ in, out := in.TimeoutSeconds, &out.TimeoutSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.TimeoutSeconds = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LoadBalancerIngress(in LoadBalancerIngress, out *LoadBalancerIngress, c *conversion.Cloner) error {
+ out.IP = in.IP
+ out.Hostname = in.Hostname
+ return nil
+}
+
+func DeepCopy_v1_LoadBalancerStatus(in LoadBalancerStatus, out *LoadBalancerStatus, c *conversion.Cloner) error {
+ if in.Ingress != nil {
+ in, out := in.Ingress, &out.Ingress
+ *out = make([]LoadBalancerIngress, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LoadBalancerIngress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LocalObjectReference(in LocalObjectReference, out *LocalObjectReference, c *conversion.Cloner) error {
+ out.Name = in.Name
+ return nil
+}
+
+func DeepCopy_v1_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *conversion.Cloner) error {
+ out.Server = in.Server
+ out.Path = in.Path
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_NamespaceSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_NamespaceStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Namespace, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Namespace(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NamespaceSpec(in NamespaceSpec, out *NamespaceSpec, c *conversion.Cloner) error {
+ if in.Finalizers != nil {
+ in, out := in.Finalizers, &out.Finalizers
+ *out = make([]FinalizerName, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Finalizers = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *conversion.Cloner) error {
+ out.Phase = in.Phase
+ return nil
+}
+
+func DeepCopy_v1_Node(in Node, out *Node, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_NodeSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_NodeStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeAddress(in NodeAddress, out *NodeAddress, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Address = in.Address
+ return nil
+}
+
+func DeepCopy_v1_NodeAffinity(in NodeAffinity, out *NodeAffinity, c *conversion.Cloner) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = new(NodeSelector)
+ if err := DeepCopy_v1_NodeSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PreferredSchedulingTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PreferredSchedulingTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1_NodeDaemonEndpoints(in NodeDaemonEndpoints, out *NodeDaemonEndpoints, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_DaemonEndpoint(in.KubeletEndpoint, &out.KubeletEndpoint, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Node, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Node(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeProxyOptions(in NodeProxyOptions, out *NodeProxyOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func DeepCopy_v1_NodeSelector(in NodeSelector, out *NodeSelector, c *conversion.Cloner) error {
+ if in.NodeSelectorTerms != nil {
+ in, out := in.NodeSelectorTerms, &out.NodeSelectorTerms
+ *out = make([]NodeSelectorTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_NodeSelectorTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.NodeSelectorTerms = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeSelectorRequirement(in NodeSelectorRequirement, out *NodeSelectorRequirement, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ if in.Values != nil {
+ in, out := in.Values, &out.Values
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Values = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeSelectorTerm(in NodeSelectorTerm, out *NodeSelectorTerm, c *conversion.Cloner) error {
+ if in.MatchExpressions != nil {
+ in, out := in.MatchExpressions, &out.MatchExpressions
+ *out = make([]NodeSelectorRequirement, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_NodeSelectorRequirement(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeSpec(in NodeSpec, out *NodeSpec, c *conversion.Cloner) error {
+ out.PodCIDR = in.PodCIDR
+ out.ExternalID = in.ExternalID
+ out.ProviderID = in.ProviderID
+ out.Unschedulable = in.Unschedulable
+ return nil
+}
+
+func DeepCopy_v1_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Cloner) error {
+ if in.Capacity != nil {
+ in, out := in.Capacity, &out.Capacity
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Capacity = nil
+ }
+ if in.Allocatable != nil {
+ in, out := in.Allocatable, &out.Allocatable
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Allocatable = nil
+ }
+ out.Phase = in.Phase
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]NodeCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_NodeCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.Addresses != nil {
+ in, out := in.Addresses, &out.Addresses
+ *out = make([]NodeAddress, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_NodeAddress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Addresses = nil
+ }
+ if err := DeepCopy_v1_NodeDaemonEndpoints(in.DaemonEndpoints, &out.DaemonEndpoints, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_NodeSystemInfo(in.NodeInfo, &out.NodeInfo, c); err != nil {
+ return err
+ }
+ if in.Images != nil {
+ in, out := in.Images, &out.Images
+ *out = make([]ContainerImage, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ContainerImage(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Images = nil
+ }
+ if in.VolumesInUse != nil {
+ in, out := in.VolumesInUse, &out.VolumesInUse
+ *out = make([]UniqueVolumeName, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.VolumesInUse = nil
+ }
+ if in.VolumesAttached != nil {
+ in, out := in.VolumesAttached, &out.VolumesAttached
+ *out = make([]AttachedVolume, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_AttachedVolume(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumesAttached = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conversion.Cloner) error {
+ out.MachineID = in.MachineID
+ out.SystemUUID = in.SystemUUID
+ out.BootID = in.BootID
+ out.KernelVersion = in.KernelVersion
+ out.OSImage = in.OSImage
+ out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
+ out.KubeletVersion = in.KubeletVersion
+ out.KubeProxyVersion = in.KubeProxyVersion
+ out.OperatingSystem = in.OperatingSystem
+ out.Architecture = in.Architecture
+ return nil
+}
+
+func DeepCopy_v1_ObjectFieldSelector(in ObjectFieldSelector, out *ObjectFieldSelector, c *conversion.Cloner) error {
+ out.APIVersion = in.APIVersion
+ out.FieldPath = in.FieldPath
+ return nil
+}
+
+func DeepCopy_v1_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.GenerateName = in.GenerateName
+ out.Namespace = in.Namespace
+ out.SelfLink = in.SelfLink
+ out.UID = in.UID
+ out.ResourceVersion = in.ResourceVersion
+ out.Generation = in.Generation
+ if err := unversioned.DeepCopy_unversioned_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil {
+ return err
+ }
+ if in.DeletionTimestamp != nil {
+ in, out := in.DeletionTimestamp, &out.DeletionTimestamp
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.DeletionTimestamp = nil
+ }
+ if in.DeletionGracePeriodSeconds != nil {
+ in, out := in.DeletionGracePeriodSeconds, &out.DeletionGracePeriodSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.DeletionGracePeriodSeconds = nil
+ }
+ if in.Labels != nil {
+ in, out := in.Labels, &out.Labels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Labels = nil
+ }
+ if in.Annotations != nil {
+ in, out := in.Annotations, &out.Annotations
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Annotations = nil
+ }
+ if in.OwnerReferences != nil {
+ in, out := in.OwnerReferences, &out.OwnerReferences
+ *out = make([]OwnerReference, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_OwnerReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.OwnerReferences = nil
+ }
+ if in.Finalizers != nil {
+ in, out := in.Finalizers, &out.Finalizers
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Finalizers = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ObjectReference(in ObjectReference, out *ObjectReference, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.Namespace = in.Namespace
+ out.Name = in.Name
+ out.UID = in.UID
+ out.APIVersion = in.APIVersion
+ out.ResourceVersion = in.ResourceVersion
+ out.FieldPath = in.FieldPath
+ return nil
+}
+
+func DeepCopy_v1_OwnerReference(in OwnerReference, out *OwnerReference, c *conversion.Cloner) error {
+ out.APIVersion = in.APIVersion
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.UID = in.UID
+ if in.Controller != nil {
+ in, out := in.Controller, &out.Controller
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.Controller = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PersistentVolumeSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PersistentVolumeStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PersistentVolumeClaimSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PersistentVolumeClaimStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PersistentVolumeClaim, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PersistentVolumeClaim(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, c *conversion.Cloner) error {
+ if in.AccessModes != nil {
+ in, out := in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.AccessModes = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := DeepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil {
+ return err
+ }
+ out.VolumeName = in.VolumeName
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, c *conversion.Cloner) error {
+ out.Phase = in.Phase
+ if in.AccessModes != nil {
+ in, out := in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.AccessModes = nil
+ }
+ if in.Capacity != nil {
+ in, out := in.Capacity, &out.Capacity
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Capacity = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error {
+ out.ClaimName = in.ClaimName
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PersistentVolume, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PersistentVolume(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeSource(in PersistentVolumeSource, out *PersistentVolumeSource, c *conversion.Cloner) error {
+ if in.GCEPersistentDisk != nil {
+ in, out := in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(GCEPersistentDiskVolumeSource)
+ if err := DeepCopy_v1_GCEPersistentDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.GCEPersistentDisk = nil
+ }
+ if in.AWSElasticBlockStore != nil {
+ in, out := in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(AWSElasticBlockStoreVolumeSource)
+ if err := DeepCopy_v1_AWSElasticBlockStoreVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.AWSElasticBlockStore = nil
+ }
+ if in.HostPath != nil {
+ in, out := in.HostPath, &out.HostPath
+ *out = new(HostPathVolumeSource)
+ if err := DeepCopy_v1_HostPathVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.HostPath = nil
+ }
+ if in.Glusterfs != nil {
+ in, out := in.Glusterfs, &out.Glusterfs
+ *out = new(GlusterfsVolumeSource)
+ if err := DeepCopy_v1_GlusterfsVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Glusterfs = nil
+ }
+ if in.NFS != nil {
+ in, out := in.NFS, &out.NFS
+ *out = new(NFSVolumeSource)
+ if err := DeepCopy_v1_NFSVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NFS = nil
+ }
+ if in.RBD != nil {
+ in, out := in.RBD, &out.RBD
+ *out = new(RBDVolumeSource)
+ if err := DeepCopy_v1_RBDVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RBD = nil
+ }
+ if in.ISCSI != nil {
+ in, out := in.ISCSI, &out.ISCSI
+ *out = new(ISCSIVolumeSource)
+ if err := DeepCopy_v1_ISCSIVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ISCSI = nil
+ }
+ if in.Cinder != nil {
+ in, out := in.Cinder, &out.Cinder
+ *out = new(CinderVolumeSource)
+ if err := DeepCopy_v1_CinderVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Cinder = nil
+ }
+ if in.CephFS != nil {
+ in, out := in.CephFS, &out.CephFS
+ *out = new(CephFSVolumeSource)
+ if err := DeepCopy_v1_CephFSVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CephFS = nil
+ }
+ if in.FC != nil {
+ in, out := in.FC, &out.FC
+ *out = new(FCVolumeSource)
+ if err := DeepCopy_v1_FCVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FC = nil
+ }
+ if in.Flocker != nil {
+ in, out := in.Flocker, &out.Flocker
+ *out = new(FlockerVolumeSource)
+ if err := DeepCopy_v1_FlockerVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Flocker = nil
+ }
+ if in.FlexVolume != nil {
+ in, out := in.FlexVolume, &out.FlexVolume
+ *out = new(FlexVolumeSource)
+ if err := DeepCopy_v1_FlexVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FlexVolume = nil
+ }
+ if in.AzureFile != nil {
+ in, out := in.AzureFile, &out.AzureFile
+ *out = new(AzureFileVolumeSource)
+ if err := DeepCopy_v1_AzureFileVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.AzureFile = nil
+ }
+ if in.VsphereVolume != nil {
+ in, out := in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := DeepCopy_v1_VsphereVirtualDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentVolumeSpec, c *conversion.Cloner) error {
+ if in.Capacity != nil {
+ in, out := in.Capacity, &out.Capacity
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Capacity = nil
+ }
+ if err := DeepCopy_v1_PersistentVolumeSource(in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil {
+ return err
+ }
+ if in.AccessModes != nil {
+ in, out := in.AccessModes, &out.AccessModes
+ *out = make([]PersistentVolumeAccessMode, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.AccessModes = nil
+ }
+ if in.ClaimRef != nil {
+ in, out := in.ClaimRef, &out.ClaimRef
+ *out = new(ObjectReference)
+ if err := DeepCopy_v1_ObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ClaimRef = nil
+ }
+ out.PersistentVolumeReclaimPolicy = in.PersistentVolumeReclaimPolicy
+ return nil
+}
+
+func DeepCopy_v1_PersistentVolumeStatus(in PersistentVolumeStatus, out *PersistentVolumeStatus, c *conversion.Cloner) error {
+ out.Phase = in.Phase
+ out.Message = in.Message
+ out.Reason = in.Reason
+ return nil
+}
+
+func DeepCopy_v1_Pod(in Pod, out *Pod, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodAffinity(in PodAffinity, out *PodAffinity, c *conversion.Cloner) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_WeightedPodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodAffinityTerm(in PodAffinityTerm, out *PodAffinityTerm, c *conversion.Cloner) error {
+ if in.LabelSelector != nil {
+ in, out := in.LabelSelector, &out.LabelSelector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LabelSelector = nil
+ }
+ if in.Namespaces != nil {
+ in, out := in.Namespaces, &out.Namespaces
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Namespaces = nil
+ }
+ out.TopologyKey = in.TopologyKey
+ return nil
+}
+
+func DeepCopy_v1_PodAntiAffinity(in PodAntiAffinity, out *PodAntiAffinity, c *conversion.Cloner) error {
+ if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
+ *out = make([]PodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ in, out := in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
+ *out = make([]WeightedPodAffinityTerm, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_WeightedPodAffinityTerm(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodAttachOptions(in PodAttachOptions, out *PodAttachOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Stdin = in.Stdin
+ out.Stdout = in.Stdout
+ out.Stderr = in.Stderr
+ out.TTY = in.TTY
+ out.Container = in.Container
+ return nil
+}
+
+func DeepCopy_v1_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Stdin = in.Stdin
+ out.Stdout = in.Stdout
+ out.Stderr = in.Stderr
+ out.TTY = in.TTY
+ out.Container = in.Container
+ if in.Command != nil {
+ in, out := in.Command, &out.Command
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Command = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodList(in PodList, out *PodList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Pod, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Pod(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Container = in.Container
+ out.Follow = in.Follow
+ out.Previous = in.Previous
+ if in.SinceSeconds != nil {
+ in, out := in.SinceSeconds, &out.SinceSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.SinceSeconds = nil
+ }
+ if in.SinceTime != nil {
+ in, out := in.SinceTime, &out.SinceTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SinceTime = nil
+ }
+ out.Timestamps = in.Timestamps
+ if in.TailLines != nil {
+ in, out := in.TailLines, &out.TailLines
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.TailLines = nil
+ }
+ if in.LimitBytes != nil {
+ in, out := in.LimitBytes, &out.LimitBytes
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.LimitBytes = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func DeepCopy_v1_PodSecurityContext(in PodSecurityContext, out *PodSecurityContext, c *conversion.Cloner) error {
+ if in.SELinuxOptions != nil {
+ in, out := in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(SELinuxOptions)
+ if err := DeepCopy_v1_SELinuxOptions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ if in.RunAsUser != nil {
+ in, out := in.RunAsUser, &out.RunAsUser
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.RunAsUser = nil
+ }
+ if in.RunAsNonRoot != nil {
+ in, out := in.RunAsNonRoot, &out.RunAsNonRoot
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.RunAsNonRoot = nil
+ }
+ if in.SupplementalGroups != nil {
+ in, out := in.SupplementalGroups, &out.SupplementalGroups
+ *out = make([]int64, len(in))
+ copy(*out, in)
+ } else {
+ out.SupplementalGroups = nil
+ }
+ if in.FSGroup != nil {
+ in, out := in.FSGroup, &out.FSGroup
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.FSGroup = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error {
+ if in.Volumes != nil {
+ in, out := in.Volumes, &out.Volumes
+ *out = make([]Volume, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Volume(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Volumes = nil
+ }
+ if in.InitContainers != nil {
+ in, out := in.InitContainers, &out.InitContainers
+ *out = make([]Container, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Container(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainers = nil
+ }
+ if in.Containers != nil {
+ in, out := in.Containers, &out.Containers
+ *out = make([]Container, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Container(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Containers = nil
+ }
+ out.RestartPolicy = in.RestartPolicy
+ if in.TerminationGracePeriodSeconds != nil {
+ in, out := in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.TerminationGracePeriodSeconds = nil
+ }
+ if in.ActiveDeadlineSeconds != nil {
+ in, out := in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ActiveDeadlineSeconds = nil
+ }
+ out.DNSPolicy = in.DNSPolicy
+ if in.NodeSelector != nil {
+ in, out := in.NodeSelector, &out.NodeSelector
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.NodeSelector = nil
+ }
+ out.ServiceAccountName = in.ServiceAccountName
+ out.DeprecatedServiceAccount = in.DeprecatedServiceAccount
+ out.NodeName = in.NodeName
+ out.HostNetwork = in.HostNetwork
+ out.HostPID = in.HostPID
+ out.HostIPC = in.HostIPC
+ if in.SecurityContext != nil {
+ in, out := in.SecurityContext, &out.SecurityContext
+ *out = new(PodSecurityContext)
+ if err := DeepCopy_v1_PodSecurityContext(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecurityContext = nil
+ }
+ if in.ImagePullSecrets != nil {
+ in, out := in.ImagePullSecrets, &out.ImagePullSecrets
+ *out = make([]LocalObjectReference, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LocalObjectReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ImagePullSecrets = nil
+ }
+ out.Hostname = in.Hostname
+ out.Subdomain = in.Subdomain
+ return nil
+}
+
+func DeepCopy_v1_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner) error {
+ out.Phase = in.Phase
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]PodCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PodCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.Message = in.Message
+ out.Reason = in.Reason
+ out.HostIP = in.HostIP
+ out.PodIP = in.PodIP
+ if in.StartTime != nil {
+ in, out := in.StartTime, &out.StartTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.StartTime = nil
+ }
+ if in.InitContainerStatuses != nil {
+ in, out := in.InitContainerStatuses, &out.InitContainerStatuses
+ *out = make([]ContainerStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ContainerStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.InitContainerStatuses = nil
+ }
+ if in.ContainerStatuses != nil {
+ in, out := in.ContainerStatuses, &out.ContainerStatuses
+ *out = make([]ContainerStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ContainerStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ContainerStatuses = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PodTemplate, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_PodTemplate(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_Preconditions(in Preconditions, out *Preconditions, c *conversion.Cloner) error {
+ if in.UID != nil {
+ in, out := in.UID, &out.UID
+ *out = new(types.UID)
+ **out = *in
+ } else {
+ out.UID = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_PreferredSchedulingTerm(in PreferredSchedulingTerm, out *PreferredSchedulingTerm, c *conversion.Cloner) error {
+ out.Weight = in.Weight
+ if err := DeepCopy_v1_NodeSelectorTerm(in.Preference, &out.Preference, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_Probe(in Probe, out *Probe, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_Handler(in.Handler, &out.Handler, c); err != nil {
+ return err
+ }
+ out.InitialDelaySeconds = in.InitialDelaySeconds
+ out.TimeoutSeconds = in.TimeoutSeconds
+ out.PeriodSeconds = in.PeriodSeconds
+ out.SuccessThreshold = in.SuccessThreshold
+ out.FailureThreshold = in.FailureThreshold
+ return nil
+}
+
+func DeepCopy_v1_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *conversion.Cloner) error {
+ if in.CephMonitors != nil {
+ in, out := in.CephMonitors, &out.CephMonitors
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.CephMonitors = nil
+ }
+ out.RBDImage = in.RBDImage
+ out.FSType = in.FSType
+ out.RBDPool = in.RBDPool
+ out.RadosUser = in.RadosUser
+ out.Keyring = in.Keyring
+ if in.SecretRef != nil {
+ in, out := in.SecretRef, &out.SecretRef
+ *out = new(LocalObjectReference)
+ if err := DeepCopy_v1_LocalObjectReference(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SecretRef = nil
+ }
+ out.ReadOnly = in.ReadOnly
+ return nil
+}
+
+func DeepCopy_v1_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ out.Range = in.Range
+ if in.Data != nil {
+ in, out := in.Data, &out.Data
+ *out = make([]byte, len(in))
+ copy(*out, in)
+ } else {
+ out.Data = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ReplicationControllerSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ReplicationControllerStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ReplicationController, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ReplicationController(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ReplicationControllerSpec(in ReplicationControllerSpec, out *ReplicationControllerSpec, c *conversion.Cloner) error {
+ if in.Replicas != nil {
+ in, out := in.Replicas, &out.Replicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Replicas = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.Template != nil {
+ in, out := in.Template, &out.Template
+ *out = new(PodTemplateSpec)
+ if err := DeepCopy_v1_PodTemplateSpec(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Template = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ReplicationControllerStatus(in ReplicationControllerStatus, out *ReplicationControllerStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func DeepCopy_v1_ResourceFieldSelector(in ResourceFieldSelector, out *ResourceFieldSelector, c *conversion.Cloner) error {
+ out.ContainerName = in.ContainerName
+ out.Resource = in.Resource
+ if err := resource.DeepCopy_resource_Quantity(in.Divisor, &out.Divisor, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ResourceQuotaSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ResourceQuotaStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ResourceQuota, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ResourceQuota(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec, c *conversion.Cloner) error {
+ if in.Hard != nil {
+ in, out := in.Hard, &out.Hard
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Hard = nil
+ }
+ if in.Scopes != nil {
+ in, out := in.Scopes, &out.Scopes
+ *out = make([]ResourceQuotaScope, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Scopes = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuotaStatus, c *conversion.Cloner) error {
+ if in.Hard != nil {
+ in, out := in.Hard, &out.Hard
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Hard = nil
+ }
+ if in.Used != nil {
+ in, out := in.Used, &out.Used
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Used = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ResourceRequirements(in ResourceRequirements, out *ResourceRequirements, c *conversion.Cloner) error {
+ if in.Limits != nil {
+ in, out := in.Limits, &out.Limits
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Limits = nil
+ }
+ if in.Requests != nil {
+ in, out := in.Requests, &out.Requests
+ *out = make(ResourceList)
+ for key, val := range in {
+ newVal := new(resource.Quantity)
+ if err := resource.DeepCopy_resource_Quantity(val, newVal, c); err != nil {
+ return err
+ }
+ (*out)[key] = *newVal
+ }
+ } else {
+ out.Requests = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conversion.Cloner) error {
+ out.User = in.User
+ out.Role = in.Role
+ out.Type = in.Type
+ out.Level = in.Level
+ return nil
+}
+
+func DeepCopy_v1_Secret(in Secret, out *Secret, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Data != nil {
+ in, out := in.Data, &out.Data
+ *out = make(map[string][]byte)
+ for key, val := range in {
+ if newVal, err := c.DeepCopy(val); err != nil {
+ return err
+ } else {
+ (*out)[key] = newVal.([]byte)
+ }
+ }
+ } else {
+ out.Data = nil
+ }
+ out.Type = in.Type
+ return nil
+}
+
+func DeepCopy_v1_SecretKeySelector(in SecretKeySelector, out *SecretKeySelector, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_LocalObjectReference(in.LocalObjectReference, &out.LocalObjectReference, c); err != nil {
+ return err
+ }
+ out.Key = in.Key
+ return nil
+}
+
+func DeepCopy_v1_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Secret, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Secret(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error {
+ out.SecretName = in.SecretName
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]KeyToPath, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_KeyToPath(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_SecurityContext(in SecurityContext, out *SecurityContext, c *conversion.Cloner) error {
+ if in.Capabilities != nil {
+ in, out := in.Capabilities, &out.Capabilities
+ *out = new(Capabilities)
+ if err := DeepCopy_v1_Capabilities(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Capabilities = nil
+ }
+ if in.Privileged != nil {
+ in, out := in.Privileged, &out.Privileged
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.Privileged = nil
+ }
+ if in.SELinuxOptions != nil {
+ in, out := in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(SELinuxOptions)
+ if err := DeepCopy_v1_SELinuxOptions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ if in.RunAsUser != nil {
+ in, out := in.RunAsUser, &out.RunAsUser
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.RunAsUser = nil
+ }
+ if in.RunAsNonRoot != nil {
+ in, out := in.RunAsNonRoot, &out.RunAsNonRoot
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.RunAsNonRoot = nil
+ }
+ if in.ReadOnlyRootFilesystem != nil {
+ in, out := in.ReadOnlyRootFilesystem, &out.ReadOnlyRootFilesystem
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.ReadOnlyRootFilesystem = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectReference(in.Reference, &out.Reference, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_Service(in Service, out *Service, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ServiceSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ServiceStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Secrets != nil {
+ in, out := in.Secrets, &out.Secrets
+ *out = make([]ObjectReference, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ObjectReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Secrets = nil
+ }
+ if in.ImagePullSecrets != nil {
+ in, out := in.ImagePullSecrets, &out.ImagePullSecrets
+ *out = make([]LocalObjectReference, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LocalObjectReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.ImagePullSecrets = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ServiceAccount, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ServiceAccount(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Service, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Service(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.Protocol = in.Protocol
+ out.Port = in.Port
+ if err := intstr.DeepCopy_intstr_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil {
+ return err
+ }
+ out.NodePort = in.NodePort
+ return nil
+}
+
+func DeepCopy_v1_ServiceProxyOptions(in ServiceProxyOptions, out *ServiceProxyOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Path = in.Path
+ return nil
+}
+
+func DeepCopy_v1_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cloner) error {
+ if in.Ports != nil {
+ in, out := in.Ports, &out.Ports
+ *out = make([]ServicePort, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_ServicePort(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.ClusterIP = in.ClusterIP
+ out.Type = in.Type
+ if in.ExternalIPs != nil {
+ in, out := in.ExternalIPs, &out.ExternalIPs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.ExternalIPs = nil
+ }
+ if in.DeprecatedPublicIPs != nil {
+ in, out := in.DeprecatedPublicIPs, &out.DeprecatedPublicIPs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.DeprecatedPublicIPs = nil
+ }
+ out.SessionAffinity = in.SessionAffinity
+ out.LoadBalancerIP = in.LoadBalancerIP
+ if in.LoadBalancerSourceRanges != nil {
+ in, out := in.LoadBalancerSourceRanges, &out.LoadBalancerSourceRanges
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.LoadBalancerSourceRanges = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.Port, &out.Port, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_Taint(in Taint, out *Taint, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Value = in.Value
+ out.Effect = in.Effect
+ return nil
+}
+
+func DeepCopy_v1_Toleration(in Toleration, out *Toleration, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ out.Value = in.Value
+ out.Effect = in.Effect
+ return nil
+}
+
+func DeepCopy_v1_Volume(in Volume, out *Volume, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := DeepCopy_v1_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cloner) error {
+ out.Name = in.Name
+ out.ReadOnly = in.ReadOnly
+ out.MountPath = in.MountPath
+ out.SubPath = in.SubPath
+ return nil
+}
+
+func DeepCopy_v1_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion.Cloner) error {
+ if in.HostPath != nil {
+ in, out := in.HostPath, &out.HostPath
+ *out = new(HostPathVolumeSource)
+ if err := DeepCopy_v1_HostPathVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.HostPath = nil
+ }
+ if in.EmptyDir != nil {
+ in, out := in.EmptyDir, &out.EmptyDir
+ *out = new(EmptyDirVolumeSource)
+ if err := DeepCopy_v1_EmptyDirVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.EmptyDir = nil
+ }
+ if in.GCEPersistentDisk != nil {
+ in, out := in.GCEPersistentDisk, &out.GCEPersistentDisk
+ *out = new(GCEPersistentDiskVolumeSource)
+ if err := DeepCopy_v1_GCEPersistentDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.GCEPersistentDisk = nil
+ }
+ if in.AWSElasticBlockStore != nil {
+ in, out := in.AWSElasticBlockStore, &out.AWSElasticBlockStore
+ *out = new(AWSElasticBlockStoreVolumeSource)
+ if err := DeepCopy_v1_AWSElasticBlockStoreVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.AWSElasticBlockStore = nil
+ }
+ if in.GitRepo != nil {
+ in, out := in.GitRepo, &out.GitRepo
+ *out = new(GitRepoVolumeSource)
+ if err := DeepCopy_v1_GitRepoVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.GitRepo = nil
+ }
+ if in.Secret != nil {
+ in, out := in.Secret, &out.Secret
+ *out = new(SecretVolumeSource)
+ if err := DeepCopy_v1_SecretVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Secret = nil
+ }
+ if in.NFS != nil {
+ in, out := in.NFS, &out.NFS
+ *out = new(NFSVolumeSource)
+ if err := DeepCopy_v1_NFSVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NFS = nil
+ }
+ if in.ISCSI != nil {
+ in, out := in.ISCSI, &out.ISCSI
+ *out = new(ISCSIVolumeSource)
+ if err := DeepCopy_v1_ISCSIVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ISCSI = nil
+ }
+ if in.Glusterfs != nil {
+ in, out := in.Glusterfs, &out.Glusterfs
+ *out = new(GlusterfsVolumeSource)
+ if err := DeepCopy_v1_GlusterfsVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Glusterfs = nil
+ }
+ if in.PersistentVolumeClaim != nil {
+ in, out := in.PersistentVolumeClaim, &out.PersistentVolumeClaim
+ *out = new(PersistentVolumeClaimVolumeSource)
+ if err := DeepCopy_v1_PersistentVolumeClaimVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PersistentVolumeClaim = nil
+ }
+ if in.RBD != nil {
+ in, out := in.RBD, &out.RBD
+ *out = new(RBDVolumeSource)
+ if err := DeepCopy_v1_RBDVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RBD = nil
+ }
+ if in.FlexVolume != nil {
+ in, out := in.FlexVolume, &out.FlexVolume
+ *out = new(FlexVolumeSource)
+ if err := DeepCopy_v1_FlexVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FlexVolume = nil
+ }
+ if in.Cinder != nil {
+ in, out := in.Cinder, &out.Cinder
+ *out = new(CinderVolumeSource)
+ if err := DeepCopy_v1_CinderVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Cinder = nil
+ }
+ if in.CephFS != nil {
+ in, out := in.CephFS, &out.CephFS
+ *out = new(CephFSVolumeSource)
+ if err := DeepCopy_v1_CephFSVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CephFS = nil
+ }
+ if in.Flocker != nil {
+ in, out := in.Flocker, &out.Flocker
+ *out = new(FlockerVolumeSource)
+ if err := DeepCopy_v1_FlockerVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Flocker = nil
+ }
+ if in.DownwardAPI != nil {
+ in, out := in.DownwardAPI, &out.DownwardAPI
+ *out = new(DownwardAPIVolumeSource)
+ if err := DeepCopy_v1_DownwardAPIVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.DownwardAPI = nil
+ }
+ if in.FC != nil {
+ in, out := in.FC, &out.FC
+ *out = new(FCVolumeSource)
+ if err := DeepCopy_v1_FCVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.FC = nil
+ }
+ if in.AzureFile != nil {
+ in, out := in.AzureFile, &out.AzureFile
+ *out = new(AzureFileVolumeSource)
+ if err := DeepCopy_v1_AzureFileVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.AzureFile = nil
+ }
+ if in.ConfigMap != nil {
+ in, out := in.ConfigMap, &out.ConfigMap
+ *out = new(ConfigMapVolumeSource)
+ if err := DeepCopy_v1_ConfigMapVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ConfigMap = nil
+ }
+ if in.VsphereVolume != nil {
+ in, out := in.VsphereVolume, &out.VsphereVolume
+ *out = new(VsphereVirtualDiskVolumeSource)
+ if err := DeepCopy_v1_VsphereVirtualDiskVolumeSource(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.VsphereVolume = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_VsphereVirtualDiskVolumeSource(in VsphereVirtualDiskVolumeSource, out *VsphereVirtualDiskVolumeSource, c *conversion.Cloner) error {
+ out.VolumePath = in.VolumePath
+ out.FSType = in.FSType
+ return nil
+}
+
+func DeepCopy_v1_WeightedPodAffinityTerm(in WeightedPodAffinityTerm, out *WeightedPodAffinityTerm, c *conversion.Cloner) error {
+ out.Weight = in.Weight
+ if err := DeepCopy_v1_PodAffinityTerm(in.PodAffinityTerm, &out.PodAffinityTerm, c); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/defaults.go b/vendor/k8s.io/kubernetes/pkg/api/v1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..c6f11b4ee16688bb4a15ed88b4d8bddba3bcea15
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/defaults.go
@@ -0,0 +1,301 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/util/intstr"
+ "k8s.io/kubernetes/pkg/util/parsers"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_PodExecOptions,
+ SetDefaults_PodAttachOptions,
+ SetDefaults_ReplicationController,
+ SetDefaults_Volume,
+ SetDefaults_ContainerPort,
+ SetDefaults_Container,
+ SetDefaults_ServiceSpec,
+ SetDefaults_Pod,
+ SetDefaults_PodSpec,
+ SetDefaults_Probe,
+ SetDefaults_Secret,
+ SetDefaults_PersistentVolume,
+ SetDefaults_PersistentVolumeClaim,
+ SetDefaults_ISCSIVolumeSource,
+ SetDefaults_Endpoints,
+ SetDefaults_HTTPGetAction,
+ SetDefaults_NamespaceStatus,
+ SetDefaults_Node,
+ SetDefaults_NodeStatus,
+ SetDefaults_ObjectFieldSelector,
+ SetDefaults_LimitRangeItem,
+ SetDefaults_ConfigMap,
+ SetDefaults_RBDVolumeSource,
+ )
+}
+
+func SetDefaults_PodExecOptions(obj *PodExecOptions) {
+ obj.Stdout = true
+ obj.Stderr = true
+}
+func SetDefaults_PodAttachOptions(obj *PodAttachOptions) {
+ obj.Stdout = true
+ obj.Stderr = true
+}
+func SetDefaults_ReplicationController(obj *ReplicationController) {
+ var labels map[string]string
+ if obj.Spec.Template != nil {
+ labels = obj.Spec.Template.Labels
+ }
+ // TODO: support templates defined elsewhere when we support them in the API
+ if labels != nil {
+ if len(obj.Spec.Selector) == 0 {
+ obj.Spec.Selector = labels
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+ if obj.Spec.Replicas == nil {
+ obj.Spec.Replicas = new(int32)
+ *obj.Spec.Replicas = 1
+ }
+}
+func SetDefaults_Volume(obj *Volume) {
+ if util.AllPtrFieldsNil(&obj.VolumeSource) {
+ obj.VolumeSource = VolumeSource{
+ EmptyDir: &EmptyDirVolumeSource{},
+ }
+ }
+}
+func SetDefaults_ContainerPort(obj *ContainerPort) {
+ if obj.Protocol == "" {
+ obj.Protocol = ProtocolTCP
+ }
+}
+func SetDefaults_Container(obj *Container) {
+ if obj.ImagePullPolicy == "" {
+ // Ignore error and assume it has been validated elsewhere
+ _, tag, _, _ := parsers.ParseImageName(obj.Image)
+
+ // Check image tag
+
+ if tag == "latest" {
+ obj.ImagePullPolicy = PullAlways
+ } else {
+ obj.ImagePullPolicy = PullIfNotPresent
+ }
+ }
+ if obj.TerminationMessagePath == "" {
+ obj.TerminationMessagePath = TerminationMessagePathDefault
+ }
+}
+func SetDefaults_ServiceSpec(obj *ServiceSpec) {
+ if obj.SessionAffinity == "" {
+ obj.SessionAffinity = ServiceAffinityNone
+ }
+ if obj.Type == "" {
+ obj.Type = ServiceTypeClusterIP
+ }
+ for i := range obj.Ports {
+ sp := &obj.Ports[i]
+ if sp.Protocol == "" {
+ sp.Protocol = ProtocolTCP
+ }
+ if sp.TargetPort == intstr.FromInt(0) || sp.TargetPort == intstr.FromString("") {
+ sp.TargetPort = intstr.FromInt(int(sp.Port))
+ }
+ }
+}
+func SetDefaults_Pod(obj *Pod) {
+ // If limits are specified, but requests are not, default requests to limits
+ // This is done here rather than a more specific defaulting pass on ResourceRequirements
+ // because we only want this defaulting semantic to take place on a Pod and not a PodTemplate
+ for i := range obj.Spec.Containers {
+ // set requests to limits if requests are not specified, but limits are
+ if obj.Spec.Containers[i].Resources.Limits != nil {
+ if obj.Spec.Containers[i].Resources.Requests == nil {
+ obj.Spec.Containers[i].Resources.Requests = make(ResourceList)
+ }
+ for key, value := range obj.Spec.Containers[i].Resources.Limits {
+ if _, exists := obj.Spec.Containers[i].Resources.Requests[key]; !exists {
+ obj.Spec.Containers[i].Resources.Requests[key] = *(value.Copy())
+ }
+ }
+ }
+ }
+}
+func SetDefaults_PodSpec(obj *PodSpec) {
+ if obj.DNSPolicy == "" {
+ obj.DNSPolicy = DNSClusterFirst
+ }
+ if obj.RestartPolicy == "" {
+ obj.RestartPolicy = RestartPolicyAlways
+ }
+ if obj.HostNetwork {
+ defaultHostNetworkPorts(&obj.Containers)
+ }
+ if obj.SecurityContext == nil {
+ obj.SecurityContext = &PodSecurityContext{}
+ }
+ if obj.TerminationGracePeriodSeconds == nil {
+ period := int64(DefaultTerminationGracePeriodSeconds)
+ obj.TerminationGracePeriodSeconds = &period
+ }
+}
+func SetDefaults_Probe(obj *Probe) {
+ if obj.TimeoutSeconds == 0 {
+ obj.TimeoutSeconds = 1
+ }
+ if obj.PeriodSeconds == 0 {
+ obj.PeriodSeconds = 10
+ }
+ if obj.SuccessThreshold == 0 {
+ obj.SuccessThreshold = 1
+ }
+ if obj.FailureThreshold == 0 {
+ obj.FailureThreshold = 3
+ }
+}
+func SetDefaults_Secret(obj *Secret) {
+ if obj.Type == "" {
+ obj.Type = SecretTypeOpaque
+ }
+}
+func SetDefaults_PersistentVolume(obj *PersistentVolume) {
+ if obj.Status.Phase == "" {
+ obj.Status.Phase = VolumePending
+ }
+ if obj.Spec.PersistentVolumeReclaimPolicy == "" {
+ obj.Spec.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimRetain
+ }
+}
+func SetDefaults_PersistentVolumeClaim(obj *PersistentVolumeClaim) {
+ if obj.Status.Phase == "" {
+ obj.Status.Phase = ClaimPending
+ }
+}
+func SetDefaults_ISCSIVolumeSource(obj *ISCSIVolumeSource) {
+ if obj.ISCSIInterface == "" {
+ obj.ISCSIInterface = "default"
+ }
+}
+func SetDefaults_Endpoints(obj *Endpoints) {
+ for i := range obj.Subsets {
+ ss := &obj.Subsets[i]
+ for i := range ss.Ports {
+ ep := &ss.Ports[i]
+ if ep.Protocol == "" {
+ ep.Protocol = ProtocolTCP
+ }
+ }
+ }
+}
+func SetDefaults_HTTPGetAction(obj *HTTPGetAction) {
+ if obj.Path == "" {
+ obj.Path = "/"
+ }
+ if obj.Scheme == "" {
+ obj.Scheme = URISchemeHTTP
+ }
+}
+func SetDefaults_NamespaceStatus(obj *NamespaceStatus) {
+ if obj.Phase == "" {
+ obj.Phase = NamespaceActive
+ }
+}
+func SetDefaults_Node(obj *Node) {
+ if obj.Spec.ExternalID == "" {
+ obj.Spec.ExternalID = obj.Name
+ }
+}
+func SetDefaults_NodeStatus(obj *NodeStatus) {
+ if obj.Allocatable == nil && obj.Capacity != nil {
+ obj.Allocatable = make(ResourceList, len(obj.Capacity))
+ for key, value := range obj.Capacity {
+ obj.Allocatable[key] = *(value.Copy())
+ }
+ obj.Allocatable = obj.Capacity
+ }
+}
+func SetDefaults_ObjectFieldSelector(obj *ObjectFieldSelector) {
+ if obj.APIVersion == "" {
+ obj.APIVersion = "v1"
+ }
+}
+func SetDefaults_LimitRangeItem(obj *LimitRangeItem) {
+ // for container limits, we apply default values
+ if obj.Type == LimitTypeContainer {
+
+ if obj.Default == nil {
+ obj.Default = make(ResourceList)
+ }
+ if obj.DefaultRequest == nil {
+ obj.DefaultRequest = make(ResourceList)
+ }
+
+ // If a default limit is unspecified, but the max is specified, default the limit to the max
+ for key, value := range obj.Max {
+ if _, exists := obj.Default[key]; !exists {
+ obj.Default[key] = *(value.Copy())
+ }
+ }
+ // If a default limit is specified, but the default request is not, default request to limit
+ for key, value := range obj.Default {
+ if _, exists := obj.DefaultRequest[key]; !exists {
+ obj.DefaultRequest[key] = *(value.Copy())
+ }
+ }
+ // If a default request is not specified, but the min is provided, default request to the min
+ for key, value := range obj.Min {
+ if _, exists := obj.DefaultRequest[key]; !exists {
+ obj.DefaultRequest[key] = *(value.Copy())
+ }
+ }
+ }
+}
+func SetDefaults_ConfigMap(obj *ConfigMap) {
+ if obj.Data == nil {
+ obj.Data = make(map[string]string)
+ }
+}
+
+// With host networking default all container ports to host ports.
+func defaultHostNetworkPorts(containers *[]Container) {
+ for i := range *containers {
+ for j := range (*containers)[i].Ports {
+ if (*containers)[i].Ports[j].HostPort == 0 {
+ (*containers)[i].Ports[j].HostPort = (*containers)[i].Ports[j].ContainerPort
+ }
+ }
+ }
+}
+
+func SetDefaults_RBDVolumeSource(obj *RBDVolumeSource) {
+ if obj.RBDPool == "" {
+ obj.RBDPool = "rbd"
+ }
+ if obj.RadosUser == "" {
+ obj.RadosUser = "admin"
+ }
+ if obj.Keyring == "" {
+ obj.Keyring = "/etc/ceph/keyring"
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/doc.go b/vendor/k8s.io/kubernetes/pkg/api/v1/doc.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/doc.go
index 84569e9f2282a7a324129205074cad8a48d44509..bf85d77a169553b66efae318782de6723617dcfb 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/doc.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/doc.go
@@ -15,4 +15,5 @@ limitations under the License.
*/
// Package v1 is the v1 version of the API.
+// +genconversion=true
package v1
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/api/v1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..78477e4bfa01865b49df74e73bd8f07cf315ef31
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/generated.pb.go
@@ -0,0 +1,34661 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/api/v1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/api/v1/generated.proto
+
+ It has these top-level messages:
+ AWSElasticBlockStoreVolumeSource
+ Affinity
+ AttachedVolume
+ AzureFileVolumeSource
+ Binding
+ Capabilities
+ CephFSVolumeSource
+ CinderVolumeSource
+ ComponentCondition
+ ComponentStatus
+ ComponentStatusList
+ ConfigMap
+ ConfigMapKeySelector
+ ConfigMapList
+ ConfigMapVolumeSource
+ Container
+ ContainerImage
+ ContainerPort
+ ContainerState
+ ContainerStateRunning
+ ContainerStateTerminated
+ ContainerStateWaiting
+ ContainerStatus
+ DaemonEndpoint
+ DeleteOptions
+ DownwardAPIVolumeFile
+ DownwardAPIVolumeSource
+ EmptyDirVolumeSource
+ EndpointAddress
+ EndpointPort
+ EndpointSubset
+ Endpoints
+ EndpointsList
+ EnvVar
+ EnvVarSource
+ Event
+ EventList
+ EventSource
+ ExecAction
+ ExportOptions
+ FCVolumeSource
+ FlexVolumeSource
+ FlockerVolumeSource
+ GCEPersistentDiskVolumeSource
+ GitRepoVolumeSource
+ GlusterfsVolumeSource
+ HTTPGetAction
+ HTTPHeader
+ Handler
+ HostPathVolumeSource
+ ISCSIVolumeSource
+ KeyToPath
+ Lifecycle
+ LimitRange
+ LimitRangeItem
+ LimitRangeList
+ LimitRangeSpec
+ List
+ ListOptions
+ LoadBalancerIngress
+ LoadBalancerStatus
+ LocalObjectReference
+ NFSVolumeSource
+ Namespace
+ NamespaceList
+ NamespaceSpec
+ NamespaceStatus
+ Node
+ NodeAddress
+ NodeAffinity
+ NodeCondition
+ NodeDaemonEndpoints
+ NodeList
+ NodeProxyOptions
+ NodeSelector
+ NodeSelectorRequirement
+ NodeSelectorTerm
+ NodeSpec
+ NodeStatus
+ NodeSystemInfo
+ ObjectFieldSelector
+ ObjectMeta
+ ObjectReference
+ OwnerReference
+ PersistentVolume
+ PersistentVolumeClaim
+ PersistentVolumeClaimList
+ PersistentVolumeClaimSpec
+ PersistentVolumeClaimStatus
+ PersistentVolumeClaimVolumeSource
+ PersistentVolumeList
+ PersistentVolumeSource
+ PersistentVolumeSpec
+ PersistentVolumeStatus
+ Pod
+ PodAffinity
+ PodAffinityTerm
+ PodAntiAffinity
+ PodAttachOptions
+ PodCondition
+ PodExecOptions
+ PodList
+ PodLogOptions
+ PodProxyOptions
+ PodSecurityContext
+ PodSpec
+ PodStatus
+ PodStatusResult
+ PodTemplate
+ PodTemplateList
+ PodTemplateSpec
+ Preconditions
+ PreferredSchedulingTerm
+ Probe
+ RBDVolumeSource
+ RangeAllocation
+ ReplicationController
+ ReplicationControllerList
+ ReplicationControllerSpec
+ ReplicationControllerStatus
+ ResourceFieldSelector
+ ResourceQuota
+ ResourceQuotaList
+ ResourceQuotaSpec
+ ResourceQuotaStatus
+ ResourceRequirements
+ SELinuxOptions
+ Secret
+ SecretKeySelector
+ SecretList
+ SecretVolumeSource
+ SecurityContext
+ SerializedReference
+ Service
+ ServiceAccount
+ ServiceAccountList
+ ServiceList
+ ServicePort
+ ServiceProxyOptions
+ ServiceSpec
+ ServiceStatus
+ TCPSocketAction
+ Taint
+ Toleration
+ Volume
+ VolumeMount
+ VolumeSource
+ VsphereVirtualDiskVolumeSource
+ WeightedPodAffinityTerm
+*/
+package v1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_resource "k8s.io/kubernetes/pkg/api/resource"
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+import k8s_io_kubernetes_pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+
+import k8s_io_kubernetes_pkg_types "k8s.io/kubernetes/pkg/types"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *AWSElasticBlockStoreVolumeSource) Reset() { *m = AWSElasticBlockStoreVolumeSource{} }
+func (m *AWSElasticBlockStoreVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*AWSElasticBlockStoreVolumeSource) ProtoMessage() {}
+
+func (m *Affinity) Reset() { *m = Affinity{} }
+func (m *Affinity) String() string { return proto.CompactTextString(m) }
+func (*Affinity) ProtoMessage() {}
+
+func (m *AttachedVolume) Reset() { *m = AttachedVolume{} }
+func (m *AttachedVolume) String() string { return proto.CompactTextString(m) }
+func (*AttachedVolume) ProtoMessage() {}
+
+func (m *AzureFileVolumeSource) Reset() { *m = AzureFileVolumeSource{} }
+func (m *AzureFileVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*AzureFileVolumeSource) ProtoMessage() {}
+
+func (m *Binding) Reset() { *m = Binding{} }
+func (m *Binding) String() string { return proto.CompactTextString(m) }
+func (*Binding) ProtoMessage() {}
+
+func (m *Capabilities) Reset() { *m = Capabilities{} }
+func (m *Capabilities) String() string { return proto.CompactTextString(m) }
+func (*Capabilities) ProtoMessage() {}
+
+func (m *CephFSVolumeSource) Reset() { *m = CephFSVolumeSource{} }
+func (m *CephFSVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*CephFSVolumeSource) ProtoMessage() {}
+
+func (m *CinderVolumeSource) Reset() { *m = CinderVolumeSource{} }
+func (m *CinderVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*CinderVolumeSource) ProtoMessage() {}
+
+func (m *ComponentCondition) Reset() { *m = ComponentCondition{} }
+func (m *ComponentCondition) String() string { return proto.CompactTextString(m) }
+func (*ComponentCondition) ProtoMessage() {}
+
+func (m *ComponentStatus) Reset() { *m = ComponentStatus{} }
+func (m *ComponentStatus) String() string { return proto.CompactTextString(m) }
+func (*ComponentStatus) ProtoMessage() {}
+
+func (m *ComponentStatusList) Reset() { *m = ComponentStatusList{} }
+func (m *ComponentStatusList) String() string { return proto.CompactTextString(m) }
+func (*ComponentStatusList) ProtoMessage() {}
+
+func (m *ConfigMap) Reset() { *m = ConfigMap{} }
+func (m *ConfigMap) String() string { return proto.CompactTextString(m) }
+func (*ConfigMap) ProtoMessage() {}
+
+func (m *ConfigMapKeySelector) Reset() { *m = ConfigMapKeySelector{} }
+func (m *ConfigMapKeySelector) String() string { return proto.CompactTextString(m) }
+func (*ConfigMapKeySelector) ProtoMessage() {}
+
+func (m *ConfigMapList) Reset() { *m = ConfigMapList{} }
+func (m *ConfigMapList) String() string { return proto.CompactTextString(m) }
+func (*ConfigMapList) ProtoMessage() {}
+
+func (m *ConfigMapVolumeSource) Reset() { *m = ConfigMapVolumeSource{} }
+func (m *ConfigMapVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*ConfigMapVolumeSource) ProtoMessage() {}
+
+func (m *Container) Reset() { *m = Container{} }
+func (m *Container) String() string { return proto.CompactTextString(m) }
+func (*Container) ProtoMessage() {}
+
+func (m *ContainerImage) Reset() { *m = ContainerImage{} }
+func (m *ContainerImage) String() string { return proto.CompactTextString(m) }
+func (*ContainerImage) ProtoMessage() {}
+
+func (m *ContainerPort) Reset() { *m = ContainerPort{} }
+func (m *ContainerPort) String() string { return proto.CompactTextString(m) }
+func (*ContainerPort) ProtoMessage() {}
+
+func (m *ContainerState) Reset() { *m = ContainerState{} }
+func (m *ContainerState) String() string { return proto.CompactTextString(m) }
+func (*ContainerState) ProtoMessage() {}
+
+func (m *ContainerStateRunning) Reset() { *m = ContainerStateRunning{} }
+func (m *ContainerStateRunning) String() string { return proto.CompactTextString(m) }
+func (*ContainerStateRunning) ProtoMessage() {}
+
+func (m *ContainerStateTerminated) Reset() { *m = ContainerStateTerminated{} }
+func (m *ContainerStateTerminated) String() string { return proto.CompactTextString(m) }
+func (*ContainerStateTerminated) ProtoMessage() {}
+
+func (m *ContainerStateWaiting) Reset() { *m = ContainerStateWaiting{} }
+func (m *ContainerStateWaiting) String() string { return proto.CompactTextString(m) }
+func (*ContainerStateWaiting) ProtoMessage() {}
+
+func (m *ContainerStatus) Reset() { *m = ContainerStatus{} }
+func (m *ContainerStatus) String() string { return proto.CompactTextString(m) }
+func (*ContainerStatus) ProtoMessage() {}
+
+func (m *DaemonEndpoint) Reset() { *m = DaemonEndpoint{} }
+func (m *DaemonEndpoint) String() string { return proto.CompactTextString(m) }
+func (*DaemonEndpoint) ProtoMessage() {}
+
+func (m *DeleteOptions) Reset() { *m = DeleteOptions{} }
+func (m *DeleteOptions) String() string { return proto.CompactTextString(m) }
+func (*DeleteOptions) ProtoMessage() {}
+
+func (m *DownwardAPIVolumeFile) Reset() { *m = DownwardAPIVolumeFile{} }
+func (m *DownwardAPIVolumeFile) String() string { return proto.CompactTextString(m) }
+func (*DownwardAPIVolumeFile) ProtoMessage() {}
+
+func (m *DownwardAPIVolumeSource) Reset() { *m = DownwardAPIVolumeSource{} }
+func (m *DownwardAPIVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*DownwardAPIVolumeSource) ProtoMessage() {}
+
+func (m *EmptyDirVolumeSource) Reset() { *m = EmptyDirVolumeSource{} }
+func (m *EmptyDirVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*EmptyDirVolumeSource) ProtoMessage() {}
+
+func (m *EndpointAddress) Reset() { *m = EndpointAddress{} }
+func (m *EndpointAddress) String() string { return proto.CompactTextString(m) }
+func (*EndpointAddress) ProtoMessage() {}
+
+func (m *EndpointPort) Reset() { *m = EndpointPort{} }
+func (m *EndpointPort) String() string { return proto.CompactTextString(m) }
+func (*EndpointPort) ProtoMessage() {}
+
+func (m *EndpointSubset) Reset() { *m = EndpointSubset{} }
+func (m *EndpointSubset) String() string { return proto.CompactTextString(m) }
+func (*EndpointSubset) ProtoMessage() {}
+
+func (m *Endpoints) Reset() { *m = Endpoints{} }
+func (m *Endpoints) String() string { return proto.CompactTextString(m) }
+func (*Endpoints) ProtoMessage() {}
+
+func (m *EndpointsList) Reset() { *m = EndpointsList{} }
+func (m *EndpointsList) String() string { return proto.CompactTextString(m) }
+func (*EndpointsList) ProtoMessage() {}
+
+func (m *EnvVar) Reset() { *m = EnvVar{} }
+func (m *EnvVar) String() string { return proto.CompactTextString(m) }
+func (*EnvVar) ProtoMessage() {}
+
+func (m *EnvVarSource) Reset() { *m = EnvVarSource{} }
+func (m *EnvVarSource) String() string { return proto.CompactTextString(m) }
+func (*EnvVarSource) ProtoMessage() {}
+
+func (m *Event) Reset() { *m = Event{} }
+func (m *Event) String() string { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage() {}
+
+func (m *EventList) Reset() { *m = EventList{} }
+func (m *EventList) String() string { return proto.CompactTextString(m) }
+func (*EventList) ProtoMessage() {}
+
+func (m *EventSource) Reset() { *m = EventSource{} }
+func (m *EventSource) String() string { return proto.CompactTextString(m) }
+func (*EventSource) ProtoMessage() {}
+
+func (m *ExecAction) Reset() { *m = ExecAction{} }
+func (m *ExecAction) String() string { return proto.CompactTextString(m) }
+func (*ExecAction) ProtoMessage() {}
+
+func (m *ExportOptions) Reset() { *m = ExportOptions{} }
+func (m *ExportOptions) String() string { return proto.CompactTextString(m) }
+func (*ExportOptions) ProtoMessage() {}
+
+func (m *FCVolumeSource) Reset() { *m = FCVolumeSource{} }
+func (m *FCVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*FCVolumeSource) ProtoMessage() {}
+
+func (m *FlexVolumeSource) Reset() { *m = FlexVolumeSource{} }
+func (m *FlexVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*FlexVolumeSource) ProtoMessage() {}
+
+func (m *FlockerVolumeSource) Reset() { *m = FlockerVolumeSource{} }
+func (m *FlockerVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*FlockerVolumeSource) ProtoMessage() {}
+
+func (m *GCEPersistentDiskVolumeSource) Reset() { *m = GCEPersistentDiskVolumeSource{} }
+func (m *GCEPersistentDiskVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*GCEPersistentDiskVolumeSource) ProtoMessage() {}
+
+func (m *GitRepoVolumeSource) Reset() { *m = GitRepoVolumeSource{} }
+func (m *GitRepoVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*GitRepoVolumeSource) ProtoMessage() {}
+
+func (m *GlusterfsVolumeSource) Reset() { *m = GlusterfsVolumeSource{} }
+func (m *GlusterfsVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*GlusterfsVolumeSource) ProtoMessage() {}
+
+func (m *HTTPGetAction) Reset() { *m = HTTPGetAction{} }
+func (m *HTTPGetAction) String() string { return proto.CompactTextString(m) }
+func (*HTTPGetAction) ProtoMessage() {}
+
+func (m *HTTPHeader) Reset() { *m = HTTPHeader{} }
+func (m *HTTPHeader) String() string { return proto.CompactTextString(m) }
+func (*HTTPHeader) ProtoMessage() {}
+
+func (m *Handler) Reset() { *m = Handler{} }
+func (m *Handler) String() string { return proto.CompactTextString(m) }
+func (*Handler) ProtoMessage() {}
+
+func (m *HostPathVolumeSource) Reset() { *m = HostPathVolumeSource{} }
+func (m *HostPathVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*HostPathVolumeSource) ProtoMessage() {}
+
+func (m *ISCSIVolumeSource) Reset() { *m = ISCSIVolumeSource{} }
+func (m *ISCSIVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*ISCSIVolumeSource) ProtoMessage() {}
+
+func (m *KeyToPath) Reset() { *m = KeyToPath{} }
+func (m *KeyToPath) String() string { return proto.CompactTextString(m) }
+func (*KeyToPath) ProtoMessage() {}
+
+func (m *Lifecycle) Reset() { *m = Lifecycle{} }
+func (m *Lifecycle) String() string { return proto.CompactTextString(m) }
+func (*Lifecycle) ProtoMessage() {}
+
+func (m *LimitRange) Reset() { *m = LimitRange{} }
+func (m *LimitRange) String() string { return proto.CompactTextString(m) }
+func (*LimitRange) ProtoMessage() {}
+
+func (m *LimitRangeItem) Reset() { *m = LimitRangeItem{} }
+func (m *LimitRangeItem) String() string { return proto.CompactTextString(m) }
+func (*LimitRangeItem) ProtoMessage() {}
+
+func (m *LimitRangeList) Reset() { *m = LimitRangeList{} }
+func (m *LimitRangeList) String() string { return proto.CompactTextString(m) }
+func (*LimitRangeList) ProtoMessage() {}
+
+func (m *LimitRangeSpec) Reset() { *m = LimitRangeSpec{} }
+func (m *LimitRangeSpec) String() string { return proto.CompactTextString(m) }
+func (*LimitRangeSpec) ProtoMessage() {}
+
+func (m *List) Reset() { *m = List{} }
+func (m *List) String() string { return proto.CompactTextString(m) }
+func (*List) ProtoMessage() {}
+
+func (m *ListOptions) Reset() { *m = ListOptions{} }
+func (m *ListOptions) String() string { return proto.CompactTextString(m) }
+func (*ListOptions) ProtoMessage() {}
+
+func (m *LoadBalancerIngress) Reset() { *m = LoadBalancerIngress{} }
+func (m *LoadBalancerIngress) String() string { return proto.CompactTextString(m) }
+func (*LoadBalancerIngress) ProtoMessage() {}
+
+func (m *LoadBalancerStatus) Reset() { *m = LoadBalancerStatus{} }
+func (m *LoadBalancerStatus) String() string { return proto.CompactTextString(m) }
+func (*LoadBalancerStatus) ProtoMessage() {}
+
+func (m *LocalObjectReference) Reset() { *m = LocalObjectReference{} }
+func (m *LocalObjectReference) String() string { return proto.CompactTextString(m) }
+func (*LocalObjectReference) ProtoMessage() {}
+
+func (m *NFSVolumeSource) Reset() { *m = NFSVolumeSource{} }
+func (m *NFSVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*NFSVolumeSource) ProtoMessage() {}
+
+func (m *Namespace) Reset() { *m = Namespace{} }
+func (m *Namespace) String() string { return proto.CompactTextString(m) }
+func (*Namespace) ProtoMessage() {}
+
+func (m *NamespaceList) Reset() { *m = NamespaceList{} }
+func (m *NamespaceList) String() string { return proto.CompactTextString(m) }
+func (*NamespaceList) ProtoMessage() {}
+
+func (m *NamespaceSpec) Reset() { *m = NamespaceSpec{} }
+func (m *NamespaceSpec) String() string { return proto.CompactTextString(m) }
+func (*NamespaceSpec) ProtoMessage() {}
+
+func (m *NamespaceStatus) Reset() { *m = NamespaceStatus{} }
+func (m *NamespaceStatus) String() string { return proto.CompactTextString(m) }
+func (*NamespaceStatus) ProtoMessage() {}
+
+func (m *Node) Reset() { *m = Node{} }
+func (m *Node) String() string { return proto.CompactTextString(m) }
+func (*Node) ProtoMessage() {}
+
+func (m *NodeAddress) Reset() { *m = NodeAddress{} }
+func (m *NodeAddress) String() string { return proto.CompactTextString(m) }
+func (*NodeAddress) ProtoMessage() {}
+
+func (m *NodeAffinity) Reset() { *m = NodeAffinity{} }
+func (m *NodeAffinity) String() string { return proto.CompactTextString(m) }
+func (*NodeAffinity) ProtoMessage() {}
+
+func (m *NodeCondition) Reset() { *m = NodeCondition{} }
+func (m *NodeCondition) String() string { return proto.CompactTextString(m) }
+func (*NodeCondition) ProtoMessage() {}
+
+func (m *NodeDaemonEndpoints) Reset() { *m = NodeDaemonEndpoints{} }
+func (m *NodeDaemonEndpoints) String() string { return proto.CompactTextString(m) }
+func (*NodeDaemonEndpoints) ProtoMessage() {}
+
+func (m *NodeList) Reset() { *m = NodeList{} }
+func (m *NodeList) String() string { return proto.CompactTextString(m) }
+func (*NodeList) ProtoMessage() {}
+
+func (m *NodeProxyOptions) Reset() { *m = NodeProxyOptions{} }
+func (m *NodeProxyOptions) String() string { return proto.CompactTextString(m) }
+func (*NodeProxyOptions) ProtoMessage() {}
+
+func (m *NodeSelector) Reset() { *m = NodeSelector{} }
+func (m *NodeSelector) String() string { return proto.CompactTextString(m) }
+func (*NodeSelector) ProtoMessage() {}
+
+func (m *NodeSelectorRequirement) Reset() { *m = NodeSelectorRequirement{} }
+func (m *NodeSelectorRequirement) String() string { return proto.CompactTextString(m) }
+func (*NodeSelectorRequirement) ProtoMessage() {}
+
+func (m *NodeSelectorTerm) Reset() { *m = NodeSelectorTerm{} }
+func (m *NodeSelectorTerm) String() string { return proto.CompactTextString(m) }
+func (*NodeSelectorTerm) ProtoMessage() {}
+
+func (m *NodeSpec) Reset() { *m = NodeSpec{} }
+func (m *NodeSpec) String() string { return proto.CompactTextString(m) }
+func (*NodeSpec) ProtoMessage() {}
+
+func (m *NodeStatus) Reset() { *m = NodeStatus{} }
+func (m *NodeStatus) String() string { return proto.CompactTextString(m) }
+func (*NodeStatus) ProtoMessage() {}
+
+func (m *NodeSystemInfo) Reset() { *m = NodeSystemInfo{} }
+func (m *NodeSystemInfo) String() string { return proto.CompactTextString(m) }
+func (*NodeSystemInfo) ProtoMessage() {}
+
+func (m *ObjectFieldSelector) Reset() { *m = ObjectFieldSelector{} }
+func (m *ObjectFieldSelector) String() string { return proto.CompactTextString(m) }
+func (*ObjectFieldSelector) ProtoMessage() {}
+
+func (m *ObjectMeta) Reset() { *m = ObjectMeta{} }
+func (m *ObjectMeta) String() string { return proto.CompactTextString(m) }
+func (*ObjectMeta) ProtoMessage() {}
+
+func (m *ObjectReference) Reset() { *m = ObjectReference{} }
+func (m *ObjectReference) String() string { return proto.CompactTextString(m) }
+func (*ObjectReference) ProtoMessage() {}
+
+func (m *OwnerReference) Reset() { *m = OwnerReference{} }
+func (m *OwnerReference) String() string { return proto.CompactTextString(m) }
+func (*OwnerReference) ProtoMessage() {}
+
+func (m *PersistentVolume) Reset() { *m = PersistentVolume{} }
+func (m *PersistentVolume) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolume) ProtoMessage() {}
+
+func (m *PersistentVolumeClaim) Reset() { *m = PersistentVolumeClaim{} }
+func (m *PersistentVolumeClaim) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeClaim) ProtoMessage() {}
+
+func (m *PersistentVolumeClaimList) Reset() { *m = PersistentVolumeClaimList{} }
+func (m *PersistentVolumeClaimList) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeClaimList) ProtoMessage() {}
+
+func (m *PersistentVolumeClaimSpec) Reset() { *m = PersistentVolumeClaimSpec{} }
+func (m *PersistentVolumeClaimSpec) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeClaimSpec) ProtoMessage() {}
+
+func (m *PersistentVolumeClaimStatus) Reset() { *m = PersistentVolumeClaimStatus{} }
+func (m *PersistentVolumeClaimStatus) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeClaimStatus) ProtoMessage() {}
+
+func (m *PersistentVolumeClaimVolumeSource) Reset() { *m = PersistentVolumeClaimVolumeSource{} }
+func (m *PersistentVolumeClaimVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeClaimVolumeSource) ProtoMessage() {}
+
+func (m *PersistentVolumeList) Reset() { *m = PersistentVolumeList{} }
+func (m *PersistentVolumeList) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeList) ProtoMessage() {}
+
+func (m *PersistentVolumeSource) Reset() { *m = PersistentVolumeSource{} }
+func (m *PersistentVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeSource) ProtoMessage() {}
+
+func (m *PersistentVolumeSpec) Reset() { *m = PersistentVolumeSpec{} }
+func (m *PersistentVolumeSpec) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeSpec) ProtoMessage() {}
+
+func (m *PersistentVolumeStatus) Reset() { *m = PersistentVolumeStatus{} }
+func (m *PersistentVolumeStatus) String() string { return proto.CompactTextString(m) }
+func (*PersistentVolumeStatus) ProtoMessage() {}
+
+func (m *Pod) Reset() { *m = Pod{} }
+func (m *Pod) String() string { return proto.CompactTextString(m) }
+func (*Pod) ProtoMessage() {}
+
+func (m *PodAffinity) Reset() { *m = PodAffinity{} }
+func (m *PodAffinity) String() string { return proto.CompactTextString(m) }
+func (*PodAffinity) ProtoMessage() {}
+
+func (m *PodAffinityTerm) Reset() { *m = PodAffinityTerm{} }
+func (m *PodAffinityTerm) String() string { return proto.CompactTextString(m) }
+func (*PodAffinityTerm) ProtoMessage() {}
+
+func (m *PodAntiAffinity) Reset() { *m = PodAntiAffinity{} }
+func (m *PodAntiAffinity) String() string { return proto.CompactTextString(m) }
+func (*PodAntiAffinity) ProtoMessage() {}
+
+func (m *PodAttachOptions) Reset() { *m = PodAttachOptions{} }
+func (m *PodAttachOptions) String() string { return proto.CompactTextString(m) }
+func (*PodAttachOptions) ProtoMessage() {}
+
+func (m *PodCondition) Reset() { *m = PodCondition{} }
+func (m *PodCondition) String() string { return proto.CompactTextString(m) }
+func (*PodCondition) ProtoMessage() {}
+
+func (m *PodExecOptions) Reset() { *m = PodExecOptions{} }
+func (m *PodExecOptions) String() string { return proto.CompactTextString(m) }
+func (*PodExecOptions) ProtoMessage() {}
+
+func (m *PodList) Reset() { *m = PodList{} }
+func (m *PodList) String() string { return proto.CompactTextString(m) }
+func (*PodList) ProtoMessage() {}
+
+func (m *PodLogOptions) Reset() { *m = PodLogOptions{} }
+func (m *PodLogOptions) String() string { return proto.CompactTextString(m) }
+func (*PodLogOptions) ProtoMessage() {}
+
+func (m *PodProxyOptions) Reset() { *m = PodProxyOptions{} }
+func (m *PodProxyOptions) String() string { return proto.CompactTextString(m) }
+func (*PodProxyOptions) ProtoMessage() {}
+
+func (m *PodSecurityContext) Reset() { *m = PodSecurityContext{} }
+func (m *PodSecurityContext) String() string { return proto.CompactTextString(m) }
+func (*PodSecurityContext) ProtoMessage() {}
+
+func (m *PodSpec) Reset() { *m = PodSpec{} }
+func (m *PodSpec) String() string { return proto.CompactTextString(m) }
+func (*PodSpec) ProtoMessage() {}
+
+func (m *PodStatus) Reset() { *m = PodStatus{} }
+func (m *PodStatus) String() string { return proto.CompactTextString(m) }
+func (*PodStatus) ProtoMessage() {}
+
+func (m *PodStatusResult) Reset() { *m = PodStatusResult{} }
+func (m *PodStatusResult) String() string { return proto.CompactTextString(m) }
+func (*PodStatusResult) ProtoMessage() {}
+
+func (m *PodTemplate) Reset() { *m = PodTemplate{} }
+func (m *PodTemplate) String() string { return proto.CompactTextString(m) }
+func (*PodTemplate) ProtoMessage() {}
+
+func (m *PodTemplateList) Reset() { *m = PodTemplateList{} }
+func (m *PodTemplateList) String() string { return proto.CompactTextString(m) }
+func (*PodTemplateList) ProtoMessage() {}
+
+func (m *PodTemplateSpec) Reset() { *m = PodTemplateSpec{} }
+func (m *PodTemplateSpec) String() string { return proto.CompactTextString(m) }
+func (*PodTemplateSpec) ProtoMessage() {}
+
+func (m *Preconditions) Reset() { *m = Preconditions{} }
+func (m *Preconditions) String() string { return proto.CompactTextString(m) }
+func (*Preconditions) ProtoMessage() {}
+
+func (m *PreferredSchedulingTerm) Reset() { *m = PreferredSchedulingTerm{} }
+func (m *PreferredSchedulingTerm) String() string { return proto.CompactTextString(m) }
+func (*PreferredSchedulingTerm) ProtoMessage() {}
+
+func (m *Probe) Reset() { *m = Probe{} }
+func (m *Probe) String() string { return proto.CompactTextString(m) }
+func (*Probe) ProtoMessage() {}
+
+func (m *RBDVolumeSource) Reset() { *m = RBDVolumeSource{} }
+func (m *RBDVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*RBDVolumeSource) ProtoMessage() {}
+
+func (m *RangeAllocation) Reset() { *m = RangeAllocation{} }
+func (m *RangeAllocation) String() string { return proto.CompactTextString(m) }
+func (*RangeAllocation) ProtoMessage() {}
+
+func (m *ReplicationController) Reset() { *m = ReplicationController{} }
+func (m *ReplicationController) String() string { return proto.CompactTextString(m) }
+func (*ReplicationController) ProtoMessage() {}
+
+func (m *ReplicationControllerList) Reset() { *m = ReplicationControllerList{} }
+func (m *ReplicationControllerList) String() string { return proto.CompactTextString(m) }
+func (*ReplicationControllerList) ProtoMessage() {}
+
+func (m *ReplicationControllerSpec) Reset() { *m = ReplicationControllerSpec{} }
+func (m *ReplicationControllerSpec) String() string { return proto.CompactTextString(m) }
+func (*ReplicationControllerSpec) ProtoMessage() {}
+
+func (m *ReplicationControllerStatus) Reset() { *m = ReplicationControllerStatus{} }
+func (m *ReplicationControllerStatus) String() string { return proto.CompactTextString(m) }
+func (*ReplicationControllerStatus) ProtoMessage() {}
+
+func (m *ResourceFieldSelector) Reset() { *m = ResourceFieldSelector{} }
+func (m *ResourceFieldSelector) String() string { return proto.CompactTextString(m) }
+func (*ResourceFieldSelector) ProtoMessage() {}
+
+func (m *ResourceQuota) Reset() { *m = ResourceQuota{} }
+func (m *ResourceQuota) String() string { return proto.CompactTextString(m) }
+func (*ResourceQuota) ProtoMessage() {}
+
+func (m *ResourceQuotaList) Reset() { *m = ResourceQuotaList{} }
+func (m *ResourceQuotaList) String() string { return proto.CompactTextString(m) }
+func (*ResourceQuotaList) ProtoMessage() {}
+
+func (m *ResourceQuotaSpec) Reset() { *m = ResourceQuotaSpec{} }
+func (m *ResourceQuotaSpec) String() string { return proto.CompactTextString(m) }
+func (*ResourceQuotaSpec) ProtoMessage() {}
+
+func (m *ResourceQuotaStatus) Reset() { *m = ResourceQuotaStatus{} }
+func (m *ResourceQuotaStatus) String() string { return proto.CompactTextString(m) }
+func (*ResourceQuotaStatus) ProtoMessage() {}
+
+func (m *ResourceRequirements) Reset() { *m = ResourceRequirements{} }
+func (m *ResourceRequirements) String() string { return proto.CompactTextString(m) }
+func (*ResourceRequirements) ProtoMessage() {}
+
+func (m *SELinuxOptions) Reset() { *m = SELinuxOptions{} }
+func (m *SELinuxOptions) String() string { return proto.CompactTextString(m) }
+func (*SELinuxOptions) ProtoMessage() {}
+
+func (m *Secret) Reset() { *m = Secret{} }
+func (m *Secret) String() string { return proto.CompactTextString(m) }
+func (*Secret) ProtoMessage() {}
+
+func (m *SecretKeySelector) Reset() { *m = SecretKeySelector{} }
+func (m *SecretKeySelector) String() string { return proto.CompactTextString(m) }
+func (*SecretKeySelector) ProtoMessage() {}
+
+func (m *SecretList) Reset() { *m = SecretList{} }
+func (m *SecretList) String() string { return proto.CompactTextString(m) }
+func (*SecretList) ProtoMessage() {}
+
+func (m *SecretVolumeSource) Reset() { *m = SecretVolumeSource{} }
+func (m *SecretVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*SecretVolumeSource) ProtoMessage() {}
+
+func (m *SecurityContext) Reset() { *m = SecurityContext{} }
+func (m *SecurityContext) String() string { return proto.CompactTextString(m) }
+func (*SecurityContext) ProtoMessage() {}
+
+func (m *SerializedReference) Reset() { *m = SerializedReference{} }
+func (m *SerializedReference) String() string { return proto.CompactTextString(m) }
+func (*SerializedReference) ProtoMessage() {}
+
+func (m *Service) Reset() { *m = Service{} }
+func (m *Service) String() string { return proto.CompactTextString(m) }
+func (*Service) ProtoMessage() {}
+
+func (m *ServiceAccount) Reset() { *m = ServiceAccount{} }
+func (m *ServiceAccount) String() string { return proto.CompactTextString(m) }
+func (*ServiceAccount) ProtoMessage() {}
+
+func (m *ServiceAccountList) Reset() { *m = ServiceAccountList{} }
+func (m *ServiceAccountList) String() string { return proto.CompactTextString(m) }
+func (*ServiceAccountList) ProtoMessage() {}
+
+func (m *ServiceList) Reset() { *m = ServiceList{} }
+func (m *ServiceList) String() string { return proto.CompactTextString(m) }
+func (*ServiceList) ProtoMessage() {}
+
+func (m *ServicePort) Reset() { *m = ServicePort{} }
+func (m *ServicePort) String() string { return proto.CompactTextString(m) }
+func (*ServicePort) ProtoMessage() {}
+
+func (m *ServiceProxyOptions) Reset() { *m = ServiceProxyOptions{} }
+func (m *ServiceProxyOptions) String() string { return proto.CompactTextString(m) }
+func (*ServiceProxyOptions) ProtoMessage() {}
+
+func (m *ServiceSpec) Reset() { *m = ServiceSpec{} }
+func (m *ServiceSpec) String() string { return proto.CompactTextString(m) }
+func (*ServiceSpec) ProtoMessage() {}
+
+func (m *ServiceStatus) Reset() { *m = ServiceStatus{} }
+func (m *ServiceStatus) String() string { return proto.CompactTextString(m) }
+func (*ServiceStatus) ProtoMessage() {}
+
+func (m *TCPSocketAction) Reset() { *m = TCPSocketAction{} }
+func (m *TCPSocketAction) String() string { return proto.CompactTextString(m) }
+func (*TCPSocketAction) ProtoMessage() {}
+
+func (m *Taint) Reset() { *m = Taint{} }
+func (m *Taint) String() string { return proto.CompactTextString(m) }
+func (*Taint) ProtoMessage() {}
+
+func (m *Toleration) Reset() { *m = Toleration{} }
+func (m *Toleration) String() string { return proto.CompactTextString(m) }
+func (*Toleration) ProtoMessage() {}
+
+func (m *Volume) Reset() { *m = Volume{} }
+func (m *Volume) String() string { return proto.CompactTextString(m) }
+func (*Volume) ProtoMessage() {}
+
+func (m *VolumeMount) Reset() { *m = VolumeMount{} }
+func (m *VolumeMount) String() string { return proto.CompactTextString(m) }
+func (*VolumeMount) ProtoMessage() {}
+
+func (m *VolumeSource) Reset() { *m = VolumeSource{} }
+func (m *VolumeSource) String() string { return proto.CompactTextString(m) }
+func (*VolumeSource) ProtoMessage() {}
+
+func (m *VsphereVirtualDiskVolumeSource) Reset() { *m = VsphereVirtualDiskVolumeSource{} }
+func (m *VsphereVirtualDiskVolumeSource) String() string { return proto.CompactTextString(m) }
+func (*VsphereVirtualDiskVolumeSource) ProtoMessage() {}
+
+func (m *WeightedPodAffinityTerm) Reset() { *m = WeightedPodAffinityTerm{} }
+func (m *WeightedPodAffinityTerm) String() string { return proto.CompactTextString(m) }
+func (*WeightedPodAffinityTerm) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*AWSElasticBlockStoreVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.AWSElasticBlockStoreVolumeSource")
+ proto.RegisterType((*Affinity)(nil), "k8s.io.kubernetes.pkg.api.v1.Affinity")
+ proto.RegisterType((*AttachedVolume)(nil), "k8s.io.kubernetes.pkg.api.v1.AttachedVolume")
+ proto.RegisterType((*AzureFileVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.AzureFileVolumeSource")
+ proto.RegisterType((*Binding)(nil), "k8s.io.kubernetes.pkg.api.v1.Binding")
+ proto.RegisterType((*Capabilities)(nil), "k8s.io.kubernetes.pkg.api.v1.Capabilities")
+ proto.RegisterType((*CephFSVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.CephFSVolumeSource")
+ proto.RegisterType((*CinderVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.CinderVolumeSource")
+ proto.RegisterType((*ComponentCondition)(nil), "k8s.io.kubernetes.pkg.api.v1.ComponentCondition")
+ proto.RegisterType((*ComponentStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.ComponentStatus")
+ proto.RegisterType((*ComponentStatusList)(nil), "k8s.io.kubernetes.pkg.api.v1.ComponentStatusList")
+ proto.RegisterType((*ConfigMap)(nil), "k8s.io.kubernetes.pkg.api.v1.ConfigMap")
+ proto.RegisterType((*ConfigMapKeySelector)(nil), "k8s.io.kubernetes.pkg.api.v1.ConfigMapKeySelector")
+ proto.RegisterType((*ConfigMapList)(nil), "k8s.io.kubernetes.pkg.api.v1.ConfigMapList")
+ proto.RegisterType((*ConfigMapVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.ConfigMapVolumeSource")
+ proto.RegisterType((*Container)(nil), "k8s.io.kubernetes.pkg.api.v1.Container")
+ proto.RegisterType((*ContainerImage)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerImage")
+ proto.RegisterType((*ContainerPort)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerPort")
+ proto.RegisterType((*ContainerState)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerState")
+ proto.RegisterType((*ContainerStateRunning)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerStateRunning")
+ proto.RegisterType((*ContainerStateTerminated)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerStateTerminated")
+ proto.RegisterType((*ContainerStateWaiting)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerStateWaiting")
+ proto.RegisterType((*ContainerStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.ContainerStatus")
+ proto.RegisterType((*DaemonEndpoint)(nil), "k8s.io.kubernetes.pkg.api.v1.DaemonEndpoint")
+ proto.RegisterType((*DeleteOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.DeleteOptions")
+ proto.RegisterType((*DownwardAPIVolumeFile)(nil), "k8s.io.kubernetes.pkg.api.v1.DownwardAPIVolumeFile")
+ proto.RegisterType((*DownwardAPIVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.DownwardAPIVolumeSource")
+ proto.RegisterType((*EmptyDirVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.EmptyDirVolumeSource")
+ proto.RegisterType((*EndpointAddress)(nil), "k8s.io.kubernetes.pkg.api.v1.EndpointAddress")
+ proto.RegisterType((*EndpointPort)(nil), "k8s.io.kubernetes.pkg.api.v1.EndpointPort")
+ proto.RegisterType((*EndpointSubset)(nil), "k8s.io.kubernetes.pkg.api.v1.EndpointSubset")
+ proto.RegisterType((*Endpoints)(nil), "k8s.io.kubernetes.pkg.api.v1.Endpoints")
+ proto.RegisterType((*EndpointsList)(nil), "k8s.io.kubernetes.pkg.api.v1.EndpointsList")
+ proto.RegisterType((*EnvVar)(nil), "k8s.io.kubernetes.pkg.api.v1.EnvVar")
+ proto.RegisterType((*EnvVarSource)(nil), "k8s.io.kubernetes.pkg.api.v1.EnvVarSource")
+ proto.RegisterType((*Event)(nil), "k8s.io.kubernetes.pkg.api.v1.Event")
+ proto.RegisterType((*EventList)(nil), "k8s.io.kubernetes.pkg.api.v1.EventList")
+ proto.RegisterType((*EventSource)(nil), "k8s.io.kubernetes.pkg.api.v1.EventSource")
+ proto.RegisterType((*ExecAction)(nil), "k8s.io.kubernetes.pkg.api.v1.ExecAction")
+ proto.RegisterType((*ExportOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.ExportOptions")
+ proto.RegisterType((*FCVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.FCVolumeSource")
+ proto.RegisterType((*FlexVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.FlexVolumeSource")
+ proto.RegisterType((*FlockerVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.FlockerVolumeSource")
+ proto.RegisterType((*GCEPersistentDiskVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.GCEPersistentDiskVolumeSource")
+ proto.RegisterType((*GitRepoVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.GitRepoVolumeSource")
+ proto.RegisterType((*GlusterfsVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.GlusterfsVolumeSource")
+ proto.RegisterType((*HTTPGetAction)(nil), "k8s.io.kubernetes.pkg.api.v1.HTTPGetAction")
+ proto.RegisterType((*HTTPHeader)(nil), "k8s.io.kubernetes.pkg.api.v1.HTTPHeader")
+ proto.RegisterType((*Handler)(nil), "k8s.io.kubernetes.pkg.api.v1.Handler")
+ proto.RegisterType((*HostPathVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.HostPathVolumeSource")
+ proto.RegisterType((*ISCSIVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.ISCSIVolumeSource")
+ proto.RegisterType((*KeyToPath)(nil), "k8s.io.kubernetes.pkg.api.v1.KeyToPath")
+ proto.RegisterType((*Lifecycle)(nil), "k8s.io.kubernetes.pkg.api.v1.Lifecycle")
+ proto.RegisterType((*LimitRange)(nil), "k8s.io.kubernetes.pkg.api.v1.LimitRange")
+ proto.RegisterType((*LimitRangeItem)(nil), "k8s.io.kubernetes.pkg.api.v1.LimitRangeItem")
+ proto.RegisterType((*LimitRangeList)(nil), "k8s.io.kubernetes.pkg.api.v1.LimitRangeList")
+ proto.RegisterType((*LimitRangeSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.LimitRangeSpec")
+ proto.RegisterType((*List)(nil), "k8s.io.kubernetes.pkg.api.v1.List")
+ proto.RegisterType((*ListOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.ListOptions")
+ proto.RegisterType((*LoadBalancerIngress)(nil), "k8s.io.kubernetes.pkg.api.v1.LoadBalancerIngress")
+ proto.RegisterType((*LoadBalancerStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.LoadBalancerStatus")
+ proto.RegisterType((*LocalObjectReference)(nil), "k8s.io.kubernetes.pkg.api.v1.LocalObjectReference")
+ proto.RegisterType((*NFSVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.NFSVolumeSource")
+ proto.RegisterType((*Namespace)(nil), "k8s.io.kubernetes.pkg.api.v1.Namespace")
+ proto.RegisterType((*NamespaceList)(nil), "k8s.io.kubernetes.pkg.api.v1.NamespaceList")
+ proto.RegisterType((*NamespaceSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.NamespaceSpec")
+ proto.RegisterType((*NamespaceStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.NamespaceStatus")
+ proto.RegisterType((*Node)(nil), "k8s.io.kubernetes.pkg.api.v1.Node")
+ proto.RegisterType((*NodeAddress)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeAddress")
+ proto.RegisterType((*NodeAffinity)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeAffinity")
+ proto.RegisterType((*NodeCondition)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeCondition")
+ proto.RegisterType((*NodeDaemonEndpoints)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeDaemonEndpoints")
+ proto.RegisterType((*NodeList)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeList")
+ proto.RegisterType((*NodeProxyOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeProxyOptions")
+ proto.RegisterType((*NodeSelector)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeSelector")
+ proto.RegisterType((*NodeSelectorRequirement)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeSelectorRequirement")
+ proto.RegisterType((*NodeSelectorTerm)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeSelectorTerm")
+ proto.RegisterType((*NodeSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeSpec")
+ proto.RegisterType((*NodeStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeStatus")
+ proto.RegisterType((*NodeSystemInfo)(nil), "k8s.io.kubernetes.pkg.api.v1.NodeSystemInfo")
+ proto.RegisterType((*ObjectFieldSelector)(nil), "k8s.io.kubernetes.pkg.api.v1.ObjectFieldSelector")
+ proto.RegisterType((*ObjectMeta)(nil), "k8s.io.kubernetes.pkg.api.v1.ObjectMeta")
+ proto.RegisterType((*ObjectReference)(nil), "k8s.io.kubernetes.pkg.api.v1.ObjectReference")
+ proto.RegisterType((*OwnerReference)(nil), "k8s.io.kubernetes.pkg.api.v1.OwnerReference")
+ proto.RegisterType((*PersistentVolume)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolume")
+ proto.RegisterType((*PersistentVolumeClaim)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaim")
+ proto.RegisterType((*PersistentVolumeClaimList)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaimList")
+ proto.RegisterType((*PersistentVolumeClaimSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaimSpec")
+ proto.RegisterType((*PersistentVolumeClaimStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaimStatus")
+ proto.RegisterType((*PersistentVolumeClaimVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaimVolumeSource")
+ proto.RegisterType((*PersistentVolumeList)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeList")
+ proto.RegisterType((*PersistentVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeSource")
+ proto.RegisterType((*PersistentVolumeSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeSpec")
+ proto.RegisterType((*PersistentVolumeStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.PersistentVolumeStatus")
+ proto.RegisterType((*Pod)(nil), "k8s.io.kubernetes.pkg.api.v1.Pod")
+ proto.RegisterType((*PodAffinity)(nil), "k8s.io.kubernetes.pkg.api.v1.PodAffinity")
+ proto.RegisterType((*PodAffinityTerm)(nil), "k8s.io.kubernetes.pkg.api.v1.PodAffinityTerm")
+ proto.RegisterType((*PodAntiAffinity)(nil), "k8s.io.kubernetes.pkg.api.v1.PodAntiAffinity")
+ proto.RegisterType((*PodAttachOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.PodAttachOptions")
+ proto.RegisterType((*PodCondition)(nil), "k8s.io.kubernetes.pkg.api.v1.PodCondition")
+ proto.RegisterType((*PodExecOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.PodExecOptions")
+ proto.RegisterType((*PodList)(nil), "k8s.io.kubernetes.pkg.api.v1.PodList")
+ proto.RegisterType((*PodLogOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.PodLogOptions")
+ proto.RegisterType((*PodProxyOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.PodProxyOptions")
+ proto.RegisterType((*PodSecurityContext)(nil), "k8s.io.kubernetes.pkg.api.v1.PodSecurityContext")
+ proto.RegisterType((*PodSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.PodSpec")
+ proto.RegisterType((*PodStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.PodStatus")
+ proto.RegisterType((*PodStatusResult)(nil), "k8s.io.kubernetes.pkg.api.v1.PodStatusResult")
+ proto.RegisterType((*PodTemplate)(nil), "k8s.io.kubernetes.pkg.api.v1.PodTemplate")
+ proto.RegisterType((*PodTemplateList)(nil), "k8s.io.kubernetes.pkg.api.v1.PodTemplateList")
+ proto.RegisterType((*PodTemplateSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec")
+ proto.RegisterType((*Preconditions)(nil), "k8s.io.kubernetes.pkg.api.v1.Preconditions")
+ proto.RegisterType((*PreferredSchedulingTerm)(nil), "k8s.io.kubernetes.pkg.api.v1.PreferredSchedulingTerm")
+ proto.RegisterType((*Probe)(nil), "k8s.io.kubernetes.pkg.api.v1.Probe")
+ proto.RegisterType((*RBDVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.RBDVolumeSource")
+ proto.RegisterType((*RangeAllocation)(nil), "k8s.io.kubernetes.pkg.api.v1.RangeAllocation")
+ proto.RegisterType((*ReplicationController)(nil), "k8s.io.kubernetes.pkg.api.v1.ReplicationController")
+ proto.RegisterType((*ReplicationControllerList)(nil), "k8s.io.kubernetes.pkg.api.v1.ReplicationControllerList")
+ proto.RegisterType((*ReplicationControllerSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.ReplicationControllerSpec")
+ proto.RegisterType((*ReplicationControllerStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.ReplicationControllerStatus")
+ proto.RegisterType((*ResourceFieldSelector)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceFieldSelector")
+ proto.RegisterType((*ResourceQuota)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceQuota")
+ proto.RegisterType((*ResourceQuotaList)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceQuotaList")
+ proto.RegisterType((*ResourceQuotaSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceQuotaSpec")
+ proto.RegisterType((*ResourceQuotaStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceQuotaStatus")
+ proto.RegisterType((*ResourceRequirements)(nil), "k8s.io.kubernetes.pkg.api.v1.ResourceRequirements")
+ proto.RegisterType((*SELinuxOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.SELinuxOptions")
+ proto.RegisterType((*Secret)(nil), "k8s.io.kubernetes.pkg.api.v1.Secret")
+ proto.RegisterType((*SecretKeySelector)(nil), "k8s.io.kubernetes.pkg.api.v1.SecretKeySelector")
+ proto.RegisterType((*SecretList)(nil), "k8s.io.kubernetes.pkg.api.v1.SecretList")
+ proto.RegisterType((*SecretVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.SecretVolumeSource")
+ proto.RegisterType((*SecurityContext)(nil), "k8s.io.kubernetes.pkg.api.v1.SecurityContext")
+ proto.RegisterType((*SerializedReference)(nil), "k8s.io.kubernetes.pkg.api.v1.SerializedReference")
+ proto.RegisterType((*Service)(nil), "k8s.io.kubernetes.pkg.api.v1.Service")
+ proto.RegisterType((*ServiceAccount)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceAccount")
+ proto.RegisterType((*ServiceAccountList)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceAccountList")
+ proto.RegisterType((*ServiceList)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceList")
+ proto.RegisterType((*ServicePort)(nil), "k8s.io.kubernetes.pkg.api.v1.ServicePort")
+ proto.RegisterType((*ServiceProxyOptions)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceProxyOptions")
+ proto.RegisterType((*ServiceSpec)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceSpec")
+ proto.RegisterType((*ServiceStatus)(nil), "k8s.io.kubernetes.pkg.api.v1.ServiceStatus")
+ proto.RegisterType((*TCPSocketAction)(nil), "k8s.io.kubernetes.pkg.api.v1.TCPSocketAction")
+ proto.RegisterType((*Taint)(nil), "k8s.io.kubernetes.pkg.api.v1.Taint")
+ proto.RegisterType((*Toleration)(nil), "k8s.io.kubernetes.pkg.api.v1.Toleration")
+ proto.RegisterType((*Volume)(nil), "k8s.io.kubernetes.pkg.api.v1.Volume")
+ proto.RegisterType((*VolumeMount)(nil), "k8s.io.kubernetes.pkg.api.v1.VolumeMount")
+ proto.RegisterType((*VolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.VolumeSource")
+ proto.RegisterType((*VsphereVirtualDiskVolumeSource)(nil), "k8s.io.kubernetes.pkg.api.v1.VsphereVirtualDiskVolumeSource")
+ proto.RegisterType((*WeightedPodAffinityTerm)(nil), "k8s.io.kubernetes.pkg.api.v1.WeightedPodAffinityTerm")
+}
+func (m *AWSElasticBlockStoreVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *AWSElasticBlockStoreVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.VolumeID)))
+ i += copy(data[i:], m.VolumeID)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Partition))
+ data[i] = 0x20
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *Affinity) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Affinity) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.NodeAffinity != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NodeAffinity.Size()))
+ n1, err := m.NodeAffinity.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ }
+ if m.PodAffinity != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PodAffinity.Size()))
+ n2, err := m.PodAffinity.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ }
+ if m.PodAntiAffinity != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PodAntiAffinity.Size()))
+ n3, err := m.PodAntiAffinity.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ }
+ return i, nil
+}
+
+func (m *AttachedVolume) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *AttachedVolume) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.DevicePath)))
+ i += copy(data[i:], m.DevicePath)
+ return i, nil
+}
+
+func (m *AzureFileVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *AzureFileVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SecretName)))
+ i += copy(data[i:], m.SecretName)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ShareName)))
+ i += copy(data[i:], m.ShareName)
+ data[i] = 0x18
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *Binding) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Binding) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n4, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Target.Size()))
+ n5, err := m.Target.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ return i, nil
+}
+
+func (m *Capabilities) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Capabilities) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Add) > 0 {
+ for _, s := range m.Add {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.Drop) > 0 {
+ for _, s := range m.Drop {
+ data[i] = 0x12
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *CephFSVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CephFSVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Monitors) > 0 {
+ for _, s := range m.Monitors {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.User)))
+ i += copy(data[i:], m.User)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SecretFile)))
+ i += copy(data[i:], m.SecretFile)
+ if m.SecretRef != nil {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecretRef.Size()))
+ n6, err := m.SecretRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ }
+ data[i] = 0x30
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *CinderVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CinderVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.VolumeID)))
+ i += copy(data[i:], m.VolumeID)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x18
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *ComponentCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ComponentCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Error)))
+ i += copy(data[i:], m.Error)
+ return i, nil
+}
+
+func (m *ComponentStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ComponentStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n7, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ComponentStatusList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ComponentStatusList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n8, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ConfigMap) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ConfigMap) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n9, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ if len(m.Data) > 0 {
+ for k := range m.Data {
+ data[i] = 0x12
+ i++
+ v := m.Data[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ return i, nil
+}
+
+func (m *ConfigMapKeySelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ConfigMapKeySelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LocalObjectReference.Size()))
+ n10, err := m.LocalObjectReference.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n10
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ return i, nil
+}
+
+func (m *ConfigMapList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ConfigMapList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n11, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n11
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ConfigMapVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ConfigMapVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LocalObjectReference.Size()))
+ n12, err := m.LocalObjectReference.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n12
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *Container) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Container) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Image)))
+ i += copy(data[i:], m.Image)
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.Args) > 0 {
+ for _, s := range m.Args {
+ data[i] = 0x22
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.WorkingDir)))
+ i += copy(data[i:], m.WorkingDir)
+ if len(m.Ports) > 0 {
+ for _, msg := range m.Ports {
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Env) > 0 {
+ for _, msg := range m.Env {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Resources.Size()))
+ n13, err := m.Resources.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n13
+ if len(m.VolumeMounts) > 0 {
+ for _, msg := range m.VolumeMounts {
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.LivenessProbe != nil {
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LivenessProbe.Size()))
+ n14, err := m.LivenessProbe.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n14
+ }
+ if m.ReadinessProbe != nil {
+ data[i] = 0x5a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ReadinessProbe.Size()))
+ n15, err := m.ReadinessProbe.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n15
+ }
+ if m.Lifecycle != nil {
+ data[i] = 0x62
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Lifecycle.Size()))
+ n16, err := m.Lifecycle.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n16
+ }
+ data[i] = 0x6a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.TerminationMessagePath)))
+ i += copy(data[i:], m.TerminationMessagePath)
+ data[i] = 0x72
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ImagePullPolicy)))
+ i += copy(data[i:], m.ImagePullPolicy)
+ if m.SecurityContext != nil {
+ data[i] = 0x7a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecurityContext.Size()))
+ n17, err := m.SecurityContext.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n17
+ }
+ data[i] = 0x80
+ i++
+ data[i] = 0x1
+ i++
+ if m.Stdin {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x88
+ i++
+ data[i] = 0x1
+ i++
+ if m.StdinOnce {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x90
+ i++
+ data[i] = 0x1
+ i++
+ if m.TTY {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *ContainerImage) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerImage) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Names) > 0 {
+ for _, s := range m.Names {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SizeBytes))
+ return i, nil
+}
+
+func (m *ContainerPort) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerPort) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.HostPort))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ContainerPort))
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Protocol)))
+ i += copy(data[i:], m.Protocol)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.HostIP)))
+ i += copy(data[i:], m.HostIP)
+ return i, nil
+}
+
+func (m *ContainerState) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerState) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Waiting != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Waiting.Size()))
+ n18, err := m.Waiting.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n18
+ }
+ if m.Running != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Running.Size()))
+ n19, err := m.Running.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n19
+ }
+ if m.Terminated != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Terminated.Size()))
+ n20, err := m.Terminated.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n20
+ }
+ return i, nil
+}
+
+func (m *ContainerStateRunning) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerStateRunning) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartedAt.Size()))
+ n21, err := m.StartedAt.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n21
+ return i, nil
+}
+
+func (m *ContainerStateTerminated) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerStateTerminated) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ExitCode))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Signal))
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartedAt.Size()))
+ n22, err := m.StartedAt.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n22
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FinishedAt.Size()))
+ n23, err := m.FinishedAt.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n23
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContainerID)))
+ i += copy(data[i:], m.ContainerID)
+ return i, nil
+}
+
+func (m *ContainerStateWaiting) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerStateWaiting) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *ContainerStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ContainerStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.State.Size()))
+ n24, err := m.State.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n24
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTerminationState.Size()))
+ n25, err := m.LastTerminationState.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n25
+ data[i] = 0x20
+ i++
+ if m.Ready {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RestartCount))
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Image)))
+ i += copy(data[i:], m.Image)
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ImageID)))
+ i += copy(data[i:], m.ImageID)
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContainerID)))
+ i += copy(data[i:], m.ContainerID)
+ return i, nil
+}
+
+func (m *DaemonEndpoint) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DaemonEndpoint) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port))
+ return i, nil
+}
+
+func (m *DeleteOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeleteOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.GracePeriodSeconds != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.GracePeriodSeconds))
+ }
+ if m.Preconditions != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Preconditions.Size()))
+ n26, err := m.Preconditions.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n26
+ }
+ if m.OrphanDependents != nil {
+ data[i] = 0x18
+ i++
+ if *m.OrphanDependents {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ return i, nil
+}
+
+func (m *DownwardAPIVolumeFile) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DownwardAPIVolumeFile) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ if m.FieldRef != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FieldRef.Size()))
+ n27, err := m.FieldRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n27
+ }
+ if m.ResourceFieldRef != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ResourceFieldRef.Size()))
+ n28, err := m.ResourceFieldRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n28
+ }
+ return i, nil
+}
+
+func (m *DownwardAPIVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DownwardAPIVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *EmptyDirVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EmptyDirVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Medium)))
+ i += copy(data[i:], m.Medium)
+ return i, nil
+}
+
+func (m *EndpointAddress) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EndpointAddress) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.IP)))
+ i += copy(data[i:], m.IP)
+ if m.TargetRef != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TargetRef.Size()))
+ n29, err := m.TargetRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n29
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Hostname)))
+ i += copy(data[i:], m.Hostname)
+ return i, nil
+}
+
+func (m *EndpointPort) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EndpointPort) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port))
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Protocol)))
+ i += copy(data[i:], m.Protocol)
+ return i, nil
+}
+
+func (m *EndpointSubset) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EndpointSubset) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Addresses) > 0 {
+ for _, msg := range m.Addresses {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.NotReadyAddresses) > 0 {
+ for _, msg := range m.NotReadyAddresses {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Ports) > 0 {
+ for _, msg := range m.Ports {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *Endpoints) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Endpoints) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n30, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n30
+ if len(m.Subsets) > 0 {
+ for _, msg := range m.Subsets {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *EndpointsList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EndpointsList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n31, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n31
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *EnvVar) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EnvVar) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Value)))
+ i += copy(data[i:], m.Value)
+ if m.ValueFrom != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ValueFrom.Size()))
+ n32, err := m.ValueFrom.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n32
+ }
+ return i, nil
+}
+
+func (m *EnvVarSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EnvVarSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.FieldRef != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FieldRef.Size()))
+ n33, err := m.FieldRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n33
+ }
+ if m.ResourceFieldRef != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ResourceFieldRef.Size()))
+ n34, err := m.ResourceFieldRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n34
+ }
+ if m.ConfigMapKeyRef != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ConfigMapKeyRef.Size()))
+ n35, err := m.ConfigMapKeyRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n35
+ }
+ if m.SecretKeyRef != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecretKeyRef.Size()))
+ n36, err := m.SecretKeyRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n36
+ }
+ return i, nil
+}
+
+func (m *Event) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Event) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n37, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n37
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.InvolvedObject.Size()))
+ n38, err := m.InvolvedObject.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n38
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Source.Size()))
+ n39, err := m.Source.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n39
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FirstTimestamp.Size()))
+ n40, err := m.FirstTimestamp.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n40
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTimestamp.Size()))
+ n41, err := m.LastTimestamp.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n41
+ data[i] = 0x40
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Count))
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ return i, nil
+}
+
+func (m *EventList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EventList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n42, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n42
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *EventSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *EventSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Component)))
+ i += copy(data[i:], m.Component)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Host)))
+ i += copy(data[i:], m.Host)
+ return i, nil
+}
+
+func (m *ExecAction) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ExecAction) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ExportOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ExportOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Export {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ if m.Exact {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *FCVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *FCVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.TargetWWNs) > 0 {
+ for _, s := range m.TargetWWNs {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if m.Lun != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Lun))
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x20
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *FlexVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *FlexVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Driver)))
+ i += copy(data[i:], m.Driver)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ if m.SecretRef != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecretRef.Size()))
+ n43, err := m.SecretRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n43
+ }
+ data[i] = 0x20
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if len(m.Options) > 0 {
+ for k := range m.Options {
+ data[i] = 0x2a
+ i++
+ v := m.Options[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ return i, nil
+}
+
+func (m *FlockerVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *FlockerVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.DatasetName)))
+ i += copy(data[i:], m.DatasetName)
+ return i, nil
+}
+
+func (m *GCEPersistentDiskVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GCEPersistentDiskVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.PDName)))
+ i += copy(data[i:], m.PDName)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Partition))
+ data[i] = 0x20
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *GitRepoVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GitRepoVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Repository)))
+ i += copy(data[i:], m.Repository)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Revision)))
+ i += copy(data[i:], m.Revision)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Directory)))
+ i += copy(data[i:], m.Directory)
+ return i, nil
+}
+
+func (m *GlusterfsVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *GlusterfsVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.EndpointsName)))
+ i += copy(data[i:], m.EndpointsName)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ data[i] = 0x18
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *HTTPGetAction) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HTTPGetAction) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port.Size()))
+ n44, err := m.Port.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n44
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Host)))
+ i += copy(data[i:], m.Host)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Scheme)))
+ i += copy(data[i:], m.Scheme)
+ if len(m.HTTPHeaders) > 0 {
+ for _, msg := range m.HTTPHeaders {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *HTTPHeader) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HTTPHeader) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Value)))
+ i += copy(data[i:], m.Value)
+ return i, nil
+}
+
+func (m *Handler) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Handler) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Exec != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Exec.Size()))
+ n45, err := m.Exec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n45
+ }
+ if m.HTTPGet != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.HTTPGet.Size()))
+ n46, err := m.HTTPGet.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n46
+ }
+ if m.TCPSocket != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TCPSocket.Size()))
+ n47, err := m.TCPSocket.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n47
+ }
+ return i, nil
+}
+
+func (m *HostPathVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HostPathVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ return i, nil
+}
+
+func (m *ISCSIVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ISCSIVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.TargetPortal)))
+ i += copy(data[i:], m.TargetPortal)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.IQN)))
+ i += copy(data[i:], m.IQN)
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Lun))
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ISCSIInterface)))
+ i += copy(data[i:], m.ISCSIInterface)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x30
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *KeyToPath) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *KeyToPath) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ return i, nil
+}
+
+func (m *Lifecycle) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Lifecycle) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.PostStart != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PostStart.Size()))
+ n48, err := m.PostStart.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n48
+ }
+ if m.PreStop != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PreStop.Size()))
+ n49, err := m.PreStop.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n49
+ }
+ return i, nil
+}
+
+func (m *LimitRange) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LimitRange) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n50, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n50
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n51, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n51
+ return i, nil
+}
+
+func (m *LimitRangeItem) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LimitRangeItem) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ if len(m.Max) > 0 {
+ for k := range m.Max {
+ data[i] = 0x12
+ i++
+ v := m.Max[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n52, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n52
+ }
+ }
+ if len(m.Min) > 0 {
+ for k := range m.Min {
+ data[i] = 0x1a
+ i++
+ v := m.Min[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n53, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n53
+ }
+ }
+ if len(m.Default) > 0 {
+ for k := range m.Default {
+ data[i] = 0x22
+ i++
+ v := m.Default[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n54, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n54
+ }
+ }
+ if len(m.DefaultRequest) > 0 {
+ for k := range m.DefaultRequest {
+ data[i] = 0x2a
+ i++
+ v := m.DefaultRequest[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n55, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n55
+ }
+ }
+ if len(m.MaxLimitRequestRatio) > 0 {
+ for k := range m.MaxLimitRequestRatio {
+ data[i] = 0x32
+ i++
+ v := m.MaxLimitRequestRatio[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n56, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n56
+ }
+ }
+ return i, nil
+}
+
+func (m *LimitRangeList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LimitRangeList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n57, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n57
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LimitRangeSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LimitRangeSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Limits) > 0 {
+ for _, msg := range m.Limits {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *List) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *List) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n58, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n58
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ListOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ListOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.LabelSelector)))
+ i += copy(data[i:], m.LabelSelector)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FieldSelector)))
+ i += copy(data[i:], m.FieldSelector)
+ data[i] = 0x18
+ i++
+ if m.Watch {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ResourceVersion)))
+ i += copy(data[i:], m.ResourceVersion)
+ if m.TimeoutSeconds != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.TimeoutSeconds))
+ }
+ return i, nil
+}
+
+func (m *LoadBalancerIngress) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LoadBalancerIngress) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.IP)))
+ i += copy(data[i:], m.IP)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Hostname)))
+ i += copy(data[i:], m.Hostname)
+ return i, nil
+}
+
+func (m *LoadBalancerStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LoadBalancerStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Ingress) > 0 {
+ for _, msg := range m.Ingress {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LocalObjectReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LocalObjectReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ return i, nil
+}
+
+func (m *NFSVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NFSVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Server)))
+ i += copy(data[i:], m.Server)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ data[i] = 0x18
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *Namespace) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Namespace) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n59, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n59
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n60, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n60
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n61, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n61
+ return i, nil
+}
+
+func (m *NamespaceList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NamespaceList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n62, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n62
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NamespaceSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NamespaceSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Finalizers) > 0 {
+ for _, s := range m.Finalizers {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *NamespaceStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NamespaceStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Phase)))
+ i += copy(data[i:], m.Phase)
+ return i, nil
+}
+
+func (m *Node) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Node) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n63, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n63
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n64, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n64
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n65, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n65
+ return i, nil
+}
+
+func (m *NodeAddress) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeAddress) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Address)))
+ i += copy(data[i:], m.Address)
+ return i, nil
+}
+
+func (m *NodeAffinity) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeAffinity) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RequiredDuringSchedulingIgnoredDuringExecution.Size()))
+ n66, err := m.RequiredDuringSchedulingIgnoredDuringExecution.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n66
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, msg := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastHeartbeatTime.Size()))
+ n67, err := m.LastHeartbeatTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n67
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n68, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n68
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *NodeDaemonEndpoints) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeDaemonEndpoints) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.KubeletEndpoint.Size()))
+ n69, err := m.KubeletEndpoint.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n69
+ return i, nil
+}
+
+func (m *NodeList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n70, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n70
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeProxyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeProxyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ return i, nil
+}
+
+func (m *NodeSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.NodeSelectorTerms) > 0 {
+ for _, msg := range m.NodeSelectorTerms {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeSelectorRequirement) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeSelectorRequirement) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeSelectorTerm) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeSelectorTerm) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.MatchExpressions) > 0 {
+ for _, msg := range m.MatchExpressions {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.PodCIDR)))
+ i += copy(data[i:], m.PodCIDR)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ExternalID)))
+ i += copy(data[i:], m.ExternalID)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ProviderID)))
+ i += copy(data[i:], m.ProviderID)
+ data[i] = 0x20
+ i++
+ if m.Unschedulable {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *NodeStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Capacity) > 0 {
+ for k := range m.Capacity {
+ data[i] = 0xa
+ i++
+ v := m.Capacity[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n71, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n71
+ }
+ }
+ if len(m.Allocatable) > 0 {
+ for k := range m.Allocatable {
+ data[i] = 0x12
+ i++
+ v := m.Allocatable[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n72, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n72
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Phase)))
+ i += copy(data[i:], m.Phase)
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Addresses) > 0 {
+ for _, msg := range m.Addresses {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DaemonEndpoints.Size()))
+ n73, err := m.DaemonEndpoints.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n73
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NodeInfo.Size()))
+ n74, err := m.NodeInfo.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n74
+ if len(m.Images) > 0 {
+ for _, msg := range m.Images {
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.VolumesInUse) > 0 {
+ for _, s := range m.VolumesInUse {
+ data[i] = 0x4a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.VolumesAttached) > 0 {
+ for _, msg := range m.VolumesAttached {
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NodeSystemInfo) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NodeSystemInfo) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.MachineID)))
+ i += copy(data[i:], m.MachineID)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SystemUUID)))
+ i += copy(data[i:], m.SystemUUID)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.BootID)))
+ i += copy(data[i:], m.BootID)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.KernelVersion)))
+ i += copy(data[i:], m.KernelVersion)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.OSImage)))
+ i += copy(data[i:], m.OSImage)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContainerRuntimeVersion)))
+ i += copy(data[i:], m.ContainerRuntimeVersion)
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.KubeletVersion)))
+ i += copy(data[i:], m.KubeletVersion)
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.KubeProxyVersion)))
+ i += copy(data[i:], m.KubeProxyVersion)
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.OperatingSystem)))
+ i += copy(data[i:], m.OperatingSystem)
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Architecture)))
+ i += copy(data[i:], m.Architecture)
+ return i, nil
+}
+
+func (m *ObjectFieldSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ObjectFieldSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FieldPath)))
+ i += copy(data[i:], m.FieldPath)
+ return i, nil
+}
+
+func (m *ObjectMeta) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ObjectMeta) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.GenerateName)))
+ i += copy(data[i:], m.GenerateName)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Namespace)))
+ i += copy(data[i:], m.Namespace)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SelfLink)))
+ i += copy(data[i:], m.SelfLink)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.UID)))
+ i += copy(data[i:], m.UID)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ResourceVersion)))
+ i += copy(data[i:], m.ResourceVersion)
+ data[i] = 0x38
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Generation))
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CreationTimestamp.Size()))
+ n75, err := m.CreationTimestamp.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n75
+ if m.DeletionTimestamp != nil {
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DeletionTimestamp.Size()))
+ n76, err := m.DeletionTimestamp.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n76
+ }
+ if m.DeletionGracePeriodSeconds != nil {
+ data[i] = 0x50
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.DeletionGracePeriodSeconds))
+ }
+ if len(m.Labels) > 0 {
+ for k := range m.Labels {
+ data[i] = 0x5a
+ i++
+ v := m.Labels[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.Annotations) > 0 {
+ for k := range m.Annotations {
+ data[i] = 0x62
+ i++
+ v := m.Annotations[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.OwnerReferences) > 0 {
+ for _, msg := range m.OwnerReferences {
+ data[i] = 0x6a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Finalizers) > 0 {
+ for _, s := range m.Finalizers {
+ data[i] = 0x72
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ObjectReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ObjectReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Namespace)))
+ i += copy(data[i:], m.Namespace)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.UID)))
+ i += copy(data[i:], m.UID)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ResourceVersion)))
+ i += copy(data[i:], m.ResourceVersion)
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FieldPath)))
+ i += copy(data[i:], m.FieldPath)
+ return i, nil
+}
+
+func (m *OwnerReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *OwnerReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.UID)))
+ i += copy(data[i:], m.UID)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ if m.Controller != nil {
+ data[i] = 0x30
+ i++
+ if *m.Controller {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ return i, nil
+}
+
+func (m *PersistentVolume) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolume) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n77, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n77
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n78, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n78
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n79, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n79
+ return i, nil
+}
+
+func (m *PersistentVolumeClaim) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeClaim) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n80, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n80
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n81, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n81
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n82, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n82
+ return i, nil
+}
+
+func (m *PersistentVolumeClaimList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeClaimList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n83, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n83
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PersistentVolumeClaimSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeClaimSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Resources.Size()))
+ n84, err := m.Resources.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n84
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.VolumeName)))
+ i += copy(data[i:], m.VolumeName)
+ if m.Selector != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n85, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n85
+ }
+ return i, nil
+}
+
+func (m *PersistentVolumeClaimStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeClaimStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Phase)))
+ i += copy(data[i:], m.Phase)
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ data[i] = 0x12
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.Capacity) > 0 {
+ for k := range m.Capacity {
+ data[i] = 0x1a
+ i++
+ v := m.Capacity[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n86, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n86
+ }
+ }
+ return i, nil
+}
+
+func (m *PersistentVolumeClaimVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeClaimVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ClaimName)))
+ i += copy(data[i:], m.ClaimName)
+ data[i] = 0x10
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *PersistentVolumeList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n87, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n87
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PersistentVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.GCEPersistentDisk != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.GCEPersistentDisk.Size()))
+ n88, err := m.GCEPersistentDisk.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n88
+ }
+ if m.AWSElasticBlockStore != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AWSElasticBlockStore.Size()))
+ n89, err := m.AWSElasticBlockStore.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n89
+ }
+ if m.HostPath != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.HostPath.Size()))
+ n90, err := m.HostPath.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n90
+ }
+ if m.Glusterfs != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Glusterfs.Size()))
+ n91, err := m.Glusterfs.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n91
+ }
+ if m.NFS != nil {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NFS.Size()))
+ n92, err := m.NFS.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n92
+ }
+ if m.RBD != nil {
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RBD.Size()))
+ n93, err := m.RBD.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n93
+ }
+ if m.ISCSI != nil {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ISCSI.Size()))
+ n94, err := m.ISCSI.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n94
+ }
+ if m.Cinder != nil {
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Cinder.Size()))
+ n95, err := m.Cinder.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n95
+ }
+ if m.CephFS != nil {
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CephFS.Size()))
+ n96, err := m.CephFS.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n96
+ }
+ if m.FC != nil {
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FC.Size()))
+ n97, err := m.FC.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n97
+ }
+ if m.Flocker != nil {
+ data[i] = 0x5a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Flocker.Size()))
+ n98, err := m.Flocker.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n98
+ }
+ if m.FlexVolume != nil {
+ data[i] = 0x62
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FlexVolume.Size()))
+ n99, err := m.FlexVolume.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n99
+ }
+ if m.AzureFile != nil {
+ data[i] = 0x6a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AzureFile.Size()))
+ n100, err := m.AzureFile.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n100
+ }
+ if m.VsphereVolume != nil {
+ data[i] = 0x72
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.VsphereVolume.Size()))
+ n101, err := m.VsphereVolume.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n101
+ }
+ return i, nil
+}
+
+func (m *PersistentVolumeSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Capacity) > 0 {
+ for k := range m.Capacity {
+ data[i] = 0xa
+ i++
+ v := m.Capacity[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n102, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n102
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PersistentVolumeSource.Size()))
+ n103, err := m.PersistentVolumeSource.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n103
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if m.ClaimRef != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ClaimRef.Size()))
+ n104, err := m.ClaimRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n104
+ }
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.PersistentVolumeReclaimPolicy)))
+ i += copy(data[i:], m.PersistentVolumeReclaimPolicy)
+ return i, nil
+}
+
+func (m *PersistentVolumeStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PersistentVolumeStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Phase)))
+ i += copy(data[i:], m.Phase)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ return i, nil
+}
+
+func (m *Pod) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Pod) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n105, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n105
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n106, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n106
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n107, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n107
+ return i, nil
+}
+
+func (m *PodAffinity) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodAffinity) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.RequiredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, msg := range m.RequiredDuringSchedulingIgnoredDuringExecution {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, msg := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodAffinityTerm) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodAffinityTerm) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.LabelSelector != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LabelSelector.Size()))
+ n108, err := m.LabelSelector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n108
+ }
+ if len(m.Namespaces) > 0 {
+ for _, s := range m.Namespaces {
+ data[i] = 0x12
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.TopologyKey)))
+ i += copy(data[i:], m.TopologyKey)
+ return i, nil
+}
+
+func (m *PodAntiAffinity) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodAntiAffinity) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.RequiredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, msg := range m.RequiredDuringSchedulingIgnoredDuringExecution {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, msg := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodAttachOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodAttachOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Stdin {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ if m.Stdout {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x18
+ i++
+ if m.Stderr {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x20
+ i++
+ if m.TTY {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Container)))
+ i += copy(data[i:], m.Container)
+ return i, nil
+}
+
+func (m *PodCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
+ n109, err := m.LastProbeTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n109
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n110, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n110
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *PodExecOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodExecOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Stdin {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ if m.Stdout {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x18
+ i++
+ if m.Stderr {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x20
+ i++
+ if m.TTY {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Container)))
+ i += copy(data[i:], m.Container)
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ data[i] = 0x32
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *PodList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n111, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n111
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodLogOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodLogOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Container)))
+ i += copy(data[i:], m.Container)
+ data[i] = 0x10
+ i++
+ if m.Follow {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x18
+ i++
+ if m.Previous {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if m.SinceSeconds != nil {
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.SinceSeconds))
+ }
+ if m.SinceTime != nil {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SinceTime.Size()))
+ n112, err := m.SinceTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n112
+ }
+ data[i] = 0x30
+ i++
+ if m.Timestamps {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if m.TailLines != nil {
+ data[i] = 0x38
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.TailLines))
+ }
+ if m.LimitBytes != nil {
+ data[i] = 0x40
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.LimitBytes))
+ }
+ return i, nil
+}
+
+func (m *PodProxyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodProxyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ return i, nil
+}
+
+func (m *PodSecurityContext) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodSecurityContext) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.SELinuxOptions != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SELinuxOptions.Size()))
+ n113, err := m.SELinuxOptions.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n113
+ }
+ if m.RunAsUser != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.RunAsUser))
+ }
+ if m.RunAsNonRoot != nil {
+ data[i] = 0x18
+ i++
+ if *m.RunAsNonRoot {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ if len(m.SupplementalGroups) > 0 {
+ for _, num := range m.SupplementalGroups {
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(num))
+ }
+ }
+ if m.FSGroup != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.FSGroup))
+ }
+ return i, nil
+}
+
+func (m *PodSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Volumes) > 0 {
+ for _, msg := range m.Volumes {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Containers) > 0 {
+ for _, msg := range m.Containers {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.RestartPolicy)))
+ i += copy(data[i:], m.RestartPolicy)
+ if m.TerminationGracePeriodSeconds != nil {
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.TerminationGracePeriodSeconds))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ActiveDeadlineSeconds))
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.DNSPolicy)))
+ i += copy(data[i:], m.DNSPolicy)
+ if len(m.NodeSelector) > 0 {
+ for k := range m.NodeSelector {
+ data[i] = 0x3a
+ i++
+ v := m.NodeSelector[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ServiceAccountName)))
+ i += copy(data[i:], m.ServiceAccountName)
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.DeprecatedServiceAccount)))
+ i += copy(data[i:], m.DeprecatedServiceAccount)
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.NodeName)))
+ i += copy(data[i:], m.NodeName)
+ data[i] = 0x58
+ i++
+ if m.HostNetwork {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x60
+ i++
+ if m.HostPID {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x68
+ i++
+ if m.HostIPC {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if m.SecurityContext != nil {
+ data[i] = 0x72
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecurityContext.Size()))
+ n114, err := m.SecurityContext.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n114
+ }
+ if len(m.ImagePullSecrets) > 0 {
+ for _, msg := range m.ImagePullSecrets {
+ data[i] = 0x7a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x82
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Hostname)))
+ i += copy(data[i:], m.Hostname)
+ data[i] = 0x8a
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Subdomain)))
+ i += copy(data[i:], m.Subdomain)
+ return i, nil
+}
+
+func (m *PodStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Phase)))
+ i += copy(data[i:], m.Phase)
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.HostIP)))
+ i += copy(data[i:], m.HostIP)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.PodIP)))
+ i += copy(data[i:], m.PodIP)
+ if m.StartTime != nil {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartTime.Size()))
+ n115, err := m.StartTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n115
+ }
+ if len(m.ContainerStatuses) > 0 {
+ for _, msg := range m.ContainerStatuses {
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodStatusResult) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodStatusResult) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n116, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n116
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n117, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n117
+ return i, nil
+}
+
+func (m *PodTemplate) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodTemplate) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n118, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n118
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n119, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n119
+ return i, nil
+}
+
+func (m *PodTemplateList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodTemplateList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n120, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n120
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodTemplateSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodTemplateSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n121, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n121
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n122, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n122
+ return i, nil
+}
+
+func (m *Preconditions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Preconditions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.UID != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(*m.UID)))
+ i += copy(data[i:], *m.UID)
+ }
+ return i, nil
+}
+
+func (m *PreferredSchedulingTerm) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PreferredSchedulingTerm) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Weight))
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Preference.Size()))
+ n123, err := m.Preference.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n123
+ return i, nil
+}
+
+func (m *Probe) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Probe) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Handler.Size()))
+ n124, err := m.Handler.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n124
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.InitialDelaySeconds))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TimeoutSeconds))
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PeriodSeconds))
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SuccessThreshold))
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FailureThreshold))
+ return i, nil
+}
+
+func (m *RBDVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RBDVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.CephMonitors) > 0 {
+ for _, s := range m.CephMonitors {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.RBDImage)))
+ i += copy(data[i:], m.RBDImage)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.RBDPool)))
+ i += copy(data[i:], m.RBDPool)
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.RadosUser)))
+ i += copy(data[i:], m.RadosUser)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Keyring)))
+ i += copy(data[i:], m.Keyring)
+ if m.SecretRef != nil {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SecretRef.Size()))
+ n125, err := m.SecretRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n125
+ }
+ data[i] = 0x40
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *RangeAllocation) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RangeAllocation) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n126, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n126
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Range)))
+ i += copy(data[i:], m.Range)
+ if m.Data != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Data)))
+ i += copy(data[i:], m.Data)
+ }
+ return i, nil
+}
+
+func (m *ReplicationController) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicationController) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n127, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n127
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n128, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n128
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n129, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n129
+ return i, nil
+}
+
+func (m *ReplicationControllerList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicationControllerList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n130, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n130
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ReplicationControllerSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicationControllerSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Replicas))
+ }
+ if len(m.Selector) > 0 {
+ for k := range m.Selector {
+ data[i] = 0x12
+ i++
+ v := m.Selector[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if m.Template != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n131, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n131
+ }
+ return i, nil
+}
+
+func (m *ReplicationControllerStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicationControllerStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FullyLabeledReplicas))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObservedGeneration))
+ return i, nil
+}
+
+func (m *ResourceFieldSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceFieldSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContainerName)))
+ i += copy(data[i:], m.ContainerName)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Resource)))
+ i += copy(data[i:], m.Resource)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Divisor.Size()))
+ n132, err := m.Divisor.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n132
+ return i, nil
+}
+
+func (m *ResourceQuota) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceQuota) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n133, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n133
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n134, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n134
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n135, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n135
+ return i, nil
+}
+
+func (m *ResourceQuotaList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceQuotaList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n136, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n136
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ResourceQuotaSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceQuotaSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Hard) > 0 {
+ for k := range m.Hard {
+ data[i] = 0xa
+ i++
+ v := m.Hard[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n137, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n137
+ }
+ }
+ if len(m.Scopes) > 0 {
+ for _, s := range m.Scopes {
+ data[i] = 0x12
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ResourceQuotaStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceQuotaStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Hard) > 0 {
+ for k := range m.Hard {
+ data[i] = 0xa
+ i++
+ v := m.Hard[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n138, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n138
+ }
+ }
+ if len(m.Used) > 0 {
+ for k := range m.Used {
+ data[i] = 0x12
+ i++
+ v := m.Used[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n139, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n139
+ }
+ }
+ return i, nil
+}
+
+func (m *ResourceRequirements) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ResourceRequirements) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Limits) > 0 {
+ for k := range m.Limits {
+ data[i] = 0xa
+ i++
+ v := m.Limits[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n140, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n140
+ }
+ }
+ if len(m.Requests) > 0 {
+ for k := range m.Requests {
+ data[i] = 0x12
+ i++
+ v := m.Requests[k]
+ msgSize := (&v).Size()
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + msgSize + sovGenerated(uint64(msgSize))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64((&v).Size()))
+ n141, err := (&v).MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n141
+ }
+ }
+ return i, nil
+}
+
+func (m *SELinuxOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SELinuxOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.User)))
+ i += copy(data[i:], m.User)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Role)))
+ i += copy(data[i:], m.Role)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Level)))
+ i += copy(data[i:], m.Level)
+ return i, nil
+}
+
+func (m *Secret) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Secret) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n142, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n142
+ if len(m.Data) > 0 {
+ for k := range m.Data {
+ data[i] = 0x12
+ i++
+ v := m.Data[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ return i, nil
+}
+
+func (m *SecretKeySelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SecretKeySelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LocalObjectReference.Size()))
+ n143, err := m.LocalObjectReference.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n143
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ return i, nil
+}
+
+func (m *SecretList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SecretList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n144, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n144
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *SecretVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SecretVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SecretName)))
+ i += copy(data[i:], m.SecretName)
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *SecurityContext) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SecurityContext) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Capabilities != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Capabilities.Size()))
+ n145, err := m.Capabilities.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n145
+ }
+ if m.Privileged != nil {
+ data[i] = 0x10
+ i++
+ if *m.Privileged {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ if m.SELinuxOptions != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SELinuxOptions.Size()))
+ n146, err := m.SELinuxOptions.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n146
+ }
+ if m.RunAsUser != nil {
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.RunAsUser))
+ }
+ if m.RunAsNonRoot != nil {
+ data[i] = 0x28
+ i++
+ if *m.RunAsNonRoot {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ if m.ReadOnlyRootFilesystem != nil {
+ data[i] = 0x30
+ i++
+ if *m.ReadOnlyRootFilesystem {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ return i, nil
+}
+
+func (m *SerializedReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SerializedReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Reference.Size()))
+ n147, err := m.Reference.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n147
+ return i, nil
+}
+
+func (m *Service) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Service) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n148, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n148
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n149, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n149
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n150, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n150
+ return i, nil
+}
+
+func (m *ServiceAccount) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceAccount) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n151, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n151
+ if len(m.Secrets) > 0 {
+ for _, msg := range m.Secrets {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.ImagePullSecrets) > 0 {
+ for _, msg := range m.ImagePullSecrets {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ServiceAccountList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceAccountList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n152, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n152
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ServiceList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n153, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n153
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ServicePort) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServicePort) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Protocol)))
+ i += copy(data[i:], m.Protocol)
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port))
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TargetPort.Size()))
+ n154, err := m.TargetPort.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n154
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NodePort))
+ return i, nil
+}
+
+func (m *ServiceProxyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceProxyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ return i, nil
+}
+
+func (m *ServiceSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Ports) > 0 {
+ for _, msg := range m.Ports {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Selector) > 0 {
+ for k := range m.Selector {
+ data[i] = 0x12
+ i++
+ v := m.Selector[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ClusterIP)))
+ i += copy(data[i:], m.ClusterIP)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ if len(m.ExternalIPs) > 0 {
+ for _, s := range m.ExternalIPs {
+ data[i] = 0x2a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.DeprecatedPublicIPs) > 0 {
+ for _, s := range m.DeprecatedPublicIPs {
+ data[i] = 0x32
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SessionAffinity)))
+ i += copy(data[i:], m.SessionAffinity)
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.LoadBalancerIP)))
+ i += copy(data[i:], m.LoadBalancerIP)
+ if len(m.LoadBalancerSourceRanges) > 0 {
+ for _, s := range m.LoadBalancerSourceRanges {
+ data[i] = 0x4a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ServiceStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ServiceStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LoadBalancer.Size()))
+ n155, err := m.LoadBalancer.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n155
+ return i, nil
+}
+
+func (m *TCPSocketAction) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *TCPSocketAction) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port.Size()))
+ n156, err := m.Port.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n156
+ return i, nil
+}
+
+func (m *Taint) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Taint) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Value)))
+ i += copy(data[i:], m.Value)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Effect)))
+ i += copy(data[i:], m.Effect)
+ return i, nil
+}
+
+func (m *Toleration) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Toleration) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Value)))
+ i += copy(data[i:], m.Value)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Effect)))
+ i += copy(data[i:], m.Effect)
+ return i, nil
+}
+
+func (m *Volume) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Volume) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.VolumeSource.Size()))
+ n157, err := m.VolumeSource.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n157
+ return i, nil
+}
+
+func (m *VolumeMount) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *VolumeMount) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x10
+ i++
+ if m.ReadOnly {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.MountPath)))
+ i += copy(data[i:], m.MountPath)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SubPath)))
+ i += copy(data[i:], m.SubPath)
+ return i, nil
+}
+
+func (m *VolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *VolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.HostPath != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.HostPath.Size()))
+ n158, err := m.HostPath.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n158
+ }
+ if m.EmptyDir != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.EmptyDir.Size()))
+ n159, err := m.EmptyDir.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n159
+ }
+ if m.GCEPersistentDisk != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.GCEPersistentDisk.Size()))
+ n160, err := m.GCEPersistentDisk.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n160
+ }
+ if m.AWSElasticBlockStore != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AWSElasticBlockStore.Size()))
+ n161, err := m.AWSElasticBlockStore.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n161
+ }
+ if m.GitRepo != nil {
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.GitRepo.Size()))
+ n162, err := m.GitRepo.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n162
+ }
+ if m.Secret != nil {
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Secret.Size()))
+ n163, err := m.Secret.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n163
+ }
+ if m.NFS != nil {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NFS.Size()))
+ n164, err := m.NFS.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n164
+ }
+ if m.ISCSI != nil {
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ISCSI.Size()))
+ n165, err := m.ISCSI.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n165
+ }
+ if m.Glusterfs != nil {
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Glusterfs.Size()))
+ n166, err := m.Glusterfs.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n166
+ }
+ if m.PersistentVolumeClaim != nil {
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PersistentVolumeClaim.Size()))
+ n167, err := m.PersistentVolumeClaim.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n167
+ }
+ if m.RBD != nil {
+ data[i] = 0x5a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RBD.Size()))
+ n168, err := m.RBD.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n168
+ }
+ if m.FlexVolume != nil {
+ data[i] = 0x62
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FlexVolume.Size()))
+ n169, err := m.FlexVolume.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n169
+ }
+ if m.Cinder != nil {
+ data[i] = 0x6a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Cinder.Size()))
+ n170, err := m.Cinder.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n170
+ }
+ if m.CephFS != nil {
+ data[i] = 0x72
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CephFS.Size()))
+ n171, err := m.CephFS.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n171
+ }
+ if m.Flocker != nil {
+ data[i] = 0x7a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Flocker.Size()))
+ n172, err := m.Flocker.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n172
+ }
+ if m.DownwardAPI != nil {
+ data[i] = 0x82
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DownwardAPI.Size()))
+ n173, err := m.DownwardAPI.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n173
+ }
+ if m.FC != nil {
+ data[i] = 0x8a
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FC.Size()))
+ n174, err := m.FC.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n174
+ }
+ if m.AzureFile != nil {
+ data[i] = 0x92
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AzureFile.Size()))
+ n175, err := m.AzureFile.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n175
+ }
+ if m.ConfigMap != nil {
+ data[i] = 0x9a
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ConfigMap.Size()))
+ n176, err := m.ConfigMap.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n176
+ }
+ if m.VsphereVolume != nil {
+ data[i] = 0xa2
+ i++
+ data[i] = 0x1
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.VsphereVolume.Size()))
+ n177, err := m.VsphereVolume.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n177
+ }
+ return i, nil
+}
+
+func (m *VsphereVirtualDiskVolumeSource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *VsphereVirtualDiskVolumeSource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.VolumePath)))
+ i += copy(data[i:], m.VolumePath)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FSType)))
+ i += copy(data[i:], m.FSType)
+ return i, nil
+}
+
+func (m *WeightedPodAffinityTerm) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *WeightedPodAffinityTerm) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Weight))
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PodAffinityTerm.Size()))
+ n178, err := m.PodAffinityTerm.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n178
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *AWSElasticBlockStoreVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.VolumeID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Partition))
+ n += 2
+ return n
+}
+
+func (m *Affinity) Size() (n int) {
+ var l int
+ _ = l
+ if m.NodeAffinity != nil {
+ l = m.NodeAffinity.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.PodAffinity != nil {
+ l = m.PodAffinity.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.PodAntiAffinity != nil {
+ l = m.PodAntiAffinity.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *AttachedVolume) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.DevicePath)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *AzureFileVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.SecretName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ShareName)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *Binding) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Target.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Capabilities) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Add) > 0 {
+ for _, s := range m.Add {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Drop) > 0 {
+ for _, s := range m.Drop {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *CephFSVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Monitors) > 0 {
+ for _, s := range m.Monitors {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.User)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.SecretFile)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.SecretRef != nil {
+ l = m.SecretRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 2
+ return n
+}
+
+func (m *CinderVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.VolumeID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *ComponentCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Error)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ComponentStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ComponentStatusList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ConfigMap) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Data) > 0 {
+ for k, v := range m.Data {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *ConfigMapKeySelector) Size() (n int) {
+ var l int
+ _ = l
+ l = m.LocalObjectReference.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ConfigMapList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ConfigMapVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = m.LocalObjectReference.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *Container) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Image)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Args) > 0 {
+ for _, s := range m.Args {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.WorkingDir)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Ports) > 0 {
+ for _, e := range m.Ports {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Env) > 0 {
+ for _, e := range m.Env {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.Resources.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.VolumeMounts) > 0 {
+ for _, e := range m.VolumeMounts {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.LivenessProbe != nil {
+ l = m.LivenessProbe.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ReadinessProbe != nil {
+ l = m.ReadinessProbe.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Lifecycle != nil {
+ l = m.Lifecycle.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = len(m.TerminationMessagePath)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ImagePullPolicy)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.SecurityContext != nil {
+ l = m.SecurityContext.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 3
+ n += 3
+ n += 3
+ return n
+}
+
+func (m *ContainerImage) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Names) > 0 {
+ for _, s := range m.Names {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ n += 1 + sovGenerated(uint64(m.SizeBytes))
+ return n
+}
+
+func (m *ContainerPort) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.HostPort))
+ n += 1 + sovGenerated(uint64(m.ContainerPort))
+ l = len(m.Protocol)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.HostIP)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ContainerState) Size() (n int) {
+ var l int
+ _ = l
+ if m.Waiting != nil {
+ l = m.Waiting.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Running != nil {
+ l = m.Running.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Terminated != nil {
+ l = m.Terminated.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ContainerStateRunning) Size() (n int) {
+ var l int
+ _ = l
+ l = m.StartedAt.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ContainerStateTerminated) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.ExitCode))
+ n += 1 + sovGenerated(uint64(m.Signal))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.StartedAt.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.FinishedAt.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ContainerID)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ContainerStateWaiting) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ContainerStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.State.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTerminationState.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ n += 1 + sovGenerated(uint64(m.RestartCount))
+ l = len(m.Image)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ImageID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ContainerID)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *DaemonEndpoint) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Port))
+ return n
+}
+
+func (m *DeleteOptions) Size() (n int) {
+ var l int
+ _ = l
+ if m.GracePeriodSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.GracePeriodSeconds))
+ }
+ if m.Preconditions != nil {
+ l = m.Preconditions.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.OrphanDependents != nil {
+ n += 2
+ }
+ return n
+}
+
+func (m *DownwardAPIVolumeFile) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.FieldRef != nil {
+ l = m.FieldRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ResourceFieldRef != nil {
+ l = m.ResourceFieldRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *DownwardAPIVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *EmptyDirVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Medium)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *EndpointAddress) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.IP)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.TargetRef != nil {
+ l = m.TargetRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = len(m.Hostname)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *EndpointPort) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Port))
+ l = len(m.Protocol)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *EndpointSubset) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Addresses) > 0 {
+ for _, e := range m.Addresses {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.NotReadyAddresses) > 0 {
+ for _, e := range m.NotReadyAddresses {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Ports) > 0 {
+ for _, e := range m.Ports {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *Endpoints) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Subsets) > 0 {
+ for _, e := range m.Subsets {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *EndpointsList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *EnvVar) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Value)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.ValueFrom != nil {
+ l = m.ValueFrom.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *EnvVarSource) Size() (n int) {
+ var l int
+ _ = l
+ if m.FieldRef != nil {
+ l = m.FieldRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ResourceFieldRef != nil {
+ l = m.ResourceFieldRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ConfigMapKeyRef != nil {
+ l = m.ConfigMapKeyRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.SecretKeyRef != nil {
+ l = m.SecretKeyRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *Event) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.InvolvedObject.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Source.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.FirstTimestamp.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTimestamp.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Count))
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *EventList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *EventSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Component)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Host)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ExecAction) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ExportOptions) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 2
+ return n
+}
+
+func (m *FCVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.TargetWWNs) > 0 {
+ for _, s := range m.TargetWWNs {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.Lun != nil {
+ n += 1 + sovGenerated(uint64(*m.Lun))
+ }
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *FlexVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Driver)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.SecretRef != nil {
+ l = m.SecretRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 2
+ if len(m.Options) > 0 {
+ for k, v := range m.Options {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *FlockerVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.DatasetName)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GCEPersistentDiskVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.PDName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Partition))
+ n += 2
+ return n
+}
+
+func (m *GitRepoVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Repository)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Revision)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Directory)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *GlusterfsVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.EndpointsName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *HTTPGetAction) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Port.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Host)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Scheme)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.HTTPHeaders) > 0 {
+ for _, e := range m.HTTPHeaders {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *HTTPHeader) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Value)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Handler) Size() (n int) {
+ var l int
+ _ = l
+ if m.Exec != nil {
+ l = m.Exec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.HTTPGet != nil {
+ l = m.HTTPGet.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.TCPSocket != nil {
+ l = m.TCPSocket.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *HostPathVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ISCSIVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.TargetPortal)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.IQN)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Lun))
+ l = len(m.ISCSIInterface)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *KeyToPath) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Lifecycle) Size() (n int) {
+ var l int
+ _ = l
+ if m.PostStart != nil {
+ l = m.PostStart.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.PreStop != nil {
+ l = m.PreStop.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *LimitRange) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *LimitRangeItem) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Max) > 0 {
+ for k, v := range m.Max {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Min) > 0 {
+ for k, v := range m.Min {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Default) > 0 {
+ for k, v := range m.Default {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.DefaultRequest) > 0 {
+ for k, v := range m.DefaultRequest {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.MaxLimitRequestRatio) > 0 {
+ for k, v := range m.MaxLimitRequestRatio {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *LimitRangeList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LimitRangeSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Limits) > 0 {
+ for _, e := range m.Limits {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *List) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ListOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.LabelSelector)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FieldSelector)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ l = len(m.ResourceVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.TimeoutSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
+ }
+ return n
+}
+
+func (m *LoadBalancerIngress) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.IP)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Hostname)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *LoadBalancerStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Ingress) > 0 {
+ for _, e := range m.Ingress {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LocalObjectReference) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NFSVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Server)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *Namespace) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NamespaceList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NamespaceSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Finalizers) > 0 {
+ for _, s := range m.Finalizers {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NamespaceStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Phase)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Node) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NodeAddress) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Address)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NodeAffinity) Size() (n int) {
+ var l int
+ _ = l
+ if m.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ l = m.RequiredDuringSchedulingIgnoredDuringExecution.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, e := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastHeartbeatTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NodeDaemonEndpoints) Size() (n int) {
+ var l int
+ _ = l
+ l = m.KubeletEndpoint.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NodeList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeProxyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NodeSelector) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.NodeSelectorTerms) > 0 {
+ for _, e := range m.NodeSelectorTerms {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeSelectorRequirement) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeSelectorTerm) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.MatchExpressions) > 0 {
+ for _, e := range m.MatchExpressions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.PodCIDR)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ExternalID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ProviderID)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *NodeStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Capacity) > 0 {
+ for k, v := range m.Capacity {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Allocatable) > 0 {
+ for k, v := range m.Allocatable {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = len(m.Phase)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Addresses) > 0 {
+ for _, e := range m.Addresses {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.DaemonEndpoints.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.NodeInfo.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Images) > 0 {
+ for _, e := range m.Images {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.VolumesInUse) > 0 {
+ for _, s := range m.VolumesInUse {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.VolumesAttached) > 0 {
+ for _, e := range m.VolumesAttached {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NodeSystemInfo) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.MachineID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.SystemUUID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.BootID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.KernelVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.OSImage)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ContainerRuntimeVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.KubeletVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.KubeProxyVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.OperatingSystem)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Architecture)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ObjectFieldSelector) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FieldPath)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ObjectMeta) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.GenerateName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Namespace)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.SelfLink)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.UID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ResourceVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Generation))
+ l = m.CreationTimestamp.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.DeletionTimestamp != nil {
+ l = m.DeletionTimestamp.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.DeletionGracePeriodSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.DeletionGracePeriodSeconds))
+ }
+ if len(m.Labels) > 0 {
+ for k, v := range m.Labels {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Annotations) > 0 {
+ for k, v := range m.Annotations {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.OwnerReferences) > 0 {
+ for _, e := range m.OwnerReferences {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Finalizers) > 0 {
+ for _, s := range m.Finalizers {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ObjectReference) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Namespace)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.UID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ResourceVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FieldPath)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *OwnerReference) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.UID)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Controller != nil {
+ n += 2
+ }
+ return n
+}
+
+func (m *PersistentVolume) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PersistentVolumeClaim) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PersistentVolumeClaimList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PersistentVolumeClaimSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.Resources.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.VolumeName)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *PersistentVolumeClaimStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Phase)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Capacity) > 0 {
+ for k, v := range m.Capacity {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *PersistentVolumeClaimVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.ClaimName)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *PersistentVolumeList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PersistentVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if m.GCEPersistentDisk != nil {
+ l = m.GCEPersistentDisk.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.AWSElasticBlockStore != nil {
+ l = m.AWSElasticBlockStore.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.HostPath != nil {
+ l = m.HostPath.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Glusterfs != nil {
+ l = m.Glusterfs.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.NFS != nil {
+ l = m.NFS.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.RBD != nil {
+ l = m.RBD.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ISCSI != nil {
+ l = m.ISCSI.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Cinder != nil {
+ l = m.Cinder.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.CephFS != nil {
+ l = m.CephFS.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.FC != nil {
+ l = m.FC.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Flocker != nil {
+ l = m.Flocker.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.FlexVolume != nil {
+ l = m.FlexVolume.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.AzureFile != nil {
+ l = m.AzureFile.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.VsphereVolume != nil {
+ l = m.VsphereVolume.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *PersistentVolumeSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Capacity) > 0 {
+ for k, v := range m.Capacity {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = m.PersistentVolumeSource.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.AccessModes) > 0 {
+ for _, s := range m.AccessModes {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.ClaimRef != nil {
+ l = m.ClaimRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = len(m.PersistentVolumeReclaimPolicy)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PersistentVolumeStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Phase)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Pod) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodAffinity) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.RequiredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, e := range m.RequiredDuringSchedulingIgnoredDuringExecution {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, e := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodAffinityTerm) Size() (n int) {
+ var l int
+ _ = l
+ if m.LabelSelector != nil {
+ l = m.LabelSelector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if len(m.Namespaces) > 0 {
+ for _, s := range m.Namespaces {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.TopologyKey)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodAntiAffinity) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.RequiredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, e := range m.RequiredDuringSchedulingIgnoredDuringExecution {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
+ for _, e := range m.PreferredDuringSchedulingIgnoredDuringExecution {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodAttachOptions) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 2
+ n += 2
+ n += 2
+ l = len(m.Container)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastProbeTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodExecOptions) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 2
+ n += 2
+ n += 2
+ l = len(m.Container)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Command) > 0 {
+ for _, s := range m.Command {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodLogOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Container)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ n += 2
+ if m.SinceSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.SinceSeconds))
+ }
+ if m.SinceTime != nil {
+ l = m.SinceTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 2
+ if m.TailLines != nil {
+ n += 1 + sovGenerated(uint64(*m.TailLines))
+ }
+ if m.LimitBytes != nil {
+ n += 1 + sovGenerated(uint64(*m.LimitBytes))
+ }
+ return n
+}
+
+func (m *PodProxyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodSecurityContext) Size() (n int) {
+ var l int
+ _ = l
+ if m.SELinuxOptions != nil {
+ l = m.SELinuxOptions.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.RunAsUser != nil {
+ n += 1 + sovGenerated(uint64(*m.RunAsUser))
+ }
+ if m.RunAsNonRoot != nil {
+ n += 2
+ }
+ if len(m.SupplementalGroups) > 0 {
+ for _, e := range m.SupplementalGroups {
+ n += 1 + sovGenerated(uint64(e))
+ }
+ }
+ if m.FSGroup != nil {
+ n += 1 + sovGenerated(uint64(*m.FSGroup))
+ }
+ return n
+}
+
+func (m *PodSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Volumes) > 0 {
+ for _, e := range m.Volumes {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Containers) > 0 {
+ for _, e := range m.Containers {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.RestartPolicy)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.TerminationGracePeriodSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.TerminationGracePeriodSeconds))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
+ }
+ l = len(m.DNSPolicy)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.NodeSelector) > 0 {
+ for k, v := range m.NodeSelector {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = len(m.ServiceAccountName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.DeprecatedServiceAccount)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.NodeName)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ n += 2
+ n += 2
+ if m.SecurityContext != nil {
+ l = m.SecurityContext.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if len(m.ImagePullSecrets) > 0 {
+ for _, e := range m.ImagePullSecrets {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.Hostname)
+ n += 2 + l + sovGenerated(uint64(l))
+ l = len(m.Subdomain)
+ n += 2 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Phase)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.HostIP)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.PodIP)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.StartTime != nil {
+ l = m.StartTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if len(m.ContainerStatuses) > 0 {
+ for _, e := range m.ContainerStatuses {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodStatusResult) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodTemplate) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodTemplateList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodTemplateSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Preconditions) Size() (n int) {
+ var l int
+ _ = l
+ if m.UID != nil {
+ l = len(*m.UID)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *PreferredSchedulingTerm) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Weight))
+ l = m.Preference.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Probe) Size() (n int) {
+ var l int
+ _ = l
+ l = m.Handler.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.InitialDelaySeconds))
+ n += 1 + sovGenerated(uint64(m.TimeoutSeconds))
+ n += 1 + sovGenerated(uint64(m.PeriodSeconds))
+ n += 1 + sovGenerated(uint64(m.SuccessThreshold))
+ n += 1 + sovGenerated(uint64(m.FailureThreshold))
+ return n
+}
+
+func (m *RBDVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.CephMonitors) > 0 {
+ for _, s := range m.CephMonitors {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.RBDImage)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.RBDPool)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.RadosUser)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Keyring)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.SecretRef != nil {
+ l = m.SecretRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 2
+ return n
+}
+
+func (m *RangeAllocation) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Range)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Data != nil {
+ l = len(m.Data)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ReplicationController) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ReplicationControllerList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ReplicationControllerSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ n += 1 + sovGenerated(uint64(*m.Replicas))
+ }
+ if len(m.Selector) > 0 {
+ for k, v := range m.Selector {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if m.Template != nil {
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ReplicationControllerStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
+ n += 1 + sovGenerated(uint64(m.ObservedGeneration))
+ return n
+}
+
+func (m *ResourceFieldSelector) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.ContainerName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Resource)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Divisor.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ResourceQuota) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ResourceQuotaList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ResourceQuotaSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Hard) > 0 {
+ for k, v := range m.Hard {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Scopes) > 0 {
+ for _, s := range m.Scopes {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ResourceQuotaStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Hard) > 0 {
+ for k, v := range m.Hard {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Used) > 0 {
+ for k, v := range m.Used {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *ResourceRequirements) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Limits) > 0 {
+ for k, v := range m.Limits {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.Requests) > 0 {
+ for k, v := range m.Requests {
+ _ = k
+ _ = v
+ l = v.Size()
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ return n
+}
+
+func (m *SELinuxOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.User)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Role)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Level)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Secret) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Data) > 0 {
+ for k, v := range m.Data {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *SecretKeySelector) Size() (n int) {
+ var l int
+ _ = l
+ l = m.LocalObjectReference.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *SecretList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *SecretVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.SecretName)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *SecurityContext) Size() (n int) {
+ var l int
+ _ = l
+ if m.Capabilities != nil {
+ l = m.Capabilities.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Privileged != nil {
+ n += 2
+ }
+ if m.SELinuxOptions != nil {
+ l = m.SELinuxOptions.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.RunAsUser != nil {
+ n += 1 + sovGenerated(uint64(*m.RunAsUser))
+ }
+ if m.RunAsNonRoot != nil {
+ n += 2
+ }
+ if m.ReadOnlyRootFilesystem != nil {
+ n += 2
+ }
+ return n
+}
+
+func (m *SerializedReference) Size() (n int) {
+ var l int
+ _ = l
+ l = m.Reference.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Service) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ServiceAccount) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Secrets) > 0 {
+ for _, e := range m.Secrets {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.ImagePullSecrets) > 0 {
+ for _, e := range m.ImagePullSecrets {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ServiceAccountList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ServiceList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ServicePort) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Protocol)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.Port))
+ l = m.TargetPort.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.NodePort))
+ return n
+}
+
+func (m *ServiceProxyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ServiceSpec) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Ports) > 0 {
+ for _, e := range m.Ports {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Selector) > 0 {
+ for k, v := range m.Selector {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = len(m.ClusterIP)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.ExternalIPs) > 0 {
+ for _, s := range m.ExternalIPs {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.DeprecatedPublicIPs) > 0 {
+ for _, s := range m.DeprecatedPublicIPs {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.SessionAffinity)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.LoadBalancerIP)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.LoadBalancerSourceRanges) > 0 {
+ for _, s := range m.LoadBalancerSourceRanges {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ServiceStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = m.LoadBalancer.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *TCPSocketAction) Size() (n int) {
+ var l int
+ _ = l
+ l = m.Port.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Taint) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Value)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Effect)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Toleration) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Value)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Effect)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Volume) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.VolumeSource.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *VolumeMount) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ l = len(m.MountPath)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.SubPath)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *VolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ if m.HostPath != nil {
+ l = m.HostPath.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.EmptyDir != nil {
+ l = m.EmptyDir.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.GCEPersistentDisk != nil {
+ l = m.GCEPersistentDisk.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.AWSElasticBlockStore != nil {
+ l = m.AWSElasticBlockStore.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.GitRepo != nil {
+ l = m.GitRepo.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Secret != nil {
+ l = m.Secret.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.NFS != nil {
+ l = m.NFS.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ISCSI != nil {
+ l = m.ISCSI.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Glusterfs != nil {
+ l = m.Glusterfs.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.PersistentVolumeClaim != nil {
+ l = m.PersistentVolumeClaim.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.RBD != nil {
+ l = m.RBD.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.FlexVolume != nil {
+ l = m.FlexVolume.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Cinder != nil {
+ l = m.Cinder.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.CephFS != nil {
+ l = m.CephFS.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Flocker != nil {
+ l = m.Flocker.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.DownwardAPI != nil {
+ l = m.DownwardAPI.Size()
+ n += 2 + l + sovGenerated(uint64(l))
+ }
+ if m.FC != nil {
+ l = m.FC.Size()
+ n += 2 + l + sovGenerated(uint64(l))
+ }
+ if m.AzureFile != nil {
+ l = m.AzureFile.Size()
+ n += 2 + l + sovGenerated(uint64(l))
+ }
+ if m.ConfigMap != nil {
+ l = m.ConfigMap.Size()
+ n += 2 + l + sovGenerated(uint64(l))
+ }
+ if m.VsphereVolume != nil {
+ l = m.VsphereVolume.Size()
+ n += 2 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *VsphereVirtualDiskVolumeSource) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.VolumePath)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FSType)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *WeightedPodAffinityTerm) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Weight))
+ l = m.PodAffinityTerm.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *AWSElasticBlockStoreVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: AWSElasticBlockStoreVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AWSElasticBlockStoreVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumeID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
+ }
+ m.Partition = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Partition |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Affinity) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Affinity: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Affinity: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodeAffinity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.NodeAffinity == nil {
+ m.NodeAffinity = &NodeAffinity{}
+ }
+ if err := m.NodeAffinity.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodAffinity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PodAffinity == nil {
+ m.PodAffinity = &PodAffinity{}
+ }
+ if err := m.PodAffinity.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodAntiAffinity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PodAntiAffinity == nil {
+ m.PodAntiAffinity = &PodAntiAffinity{}
+ }
+ if err := m.PodAntiAffinity.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *AttachedVolume) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: AttachedVolume: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AttachedVolume: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = UniqueVolumeName(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DevicePath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DevicePath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *AzureFileVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: AzureFileVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AzureFileVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SecretName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ShareName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ShareName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Binding) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Binding: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Binding: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Target.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Capabilities) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Capabilities: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Capabilities: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Add = append(m.Add, Capability(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Drop", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Drop = append(m.Drop, Capability(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CephFSVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CephFSVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CephFSVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Monitors", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Monitors = append(m.Monitors, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.User = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretFile", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SecretFile = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecretRef == nil {
+ m.SecretRef = &LocalObjectReference{}
+ }
+ if err := m.SecretRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CinderVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CinderVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CinderVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumeID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ComponentCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ComponentCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ComponentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = ComponentConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Error = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ComponentStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ComponentStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ComponentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, ComponentCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ComponentStatusList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ComponentStatusList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ComponentStatusList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ComponentStatus{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ConfigMap) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ConfigMap: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ConfigMap: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Data == nil {
+ m.Data = make(map[string]string)
+ }
+ m.Data[mapkey] = mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ConfigMapKeySelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ConfigMapKeySelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ConfigMapKeySelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LocalObjectReference", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LocalObjectReference.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ConfigMapList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ConfigMapList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ConfigMapList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ConfigMap{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ConfigMapVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ConfigMapVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ConfigMapVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LocalObjectReference", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LocalObjectReference.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, KeyToPath{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Container) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Container: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Container: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Image = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Command = append(m.Command, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Args = append(m.Args, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field WorkingDir", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.WorkingDir = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ports = append(m.Ports, ContainerPort{})
+ if err := m.Ports[len(m.Ports)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Env", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Env = append(m.Env, EnvVar{})
+ if err := m.Env[len(m.Env)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Resources.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeMounts", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumeMounts = append(m.VolumeMounts, VolumeMount{})
+ if err := m.VolumeMounts[len(m.VolumeMounts)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LivenessProbe", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.LivenessProbe == nil {
+ m.LivenessProbe = &Probe{}
+ }
+ if err := m.LivenessProbe.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadinessProbe", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ReadinessProbe == nil {
+ m.ReadinessProbe = &Probe{}
+ }
+ if err := m.ReadinessProbe.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Lifecycle", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Lifecycle == nil {
+ m.Lifecycle = &Lifecycle{}
+ }
+ if err := m.Lifecycle.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TerminationMessagePath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TerminationMessagePath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 14:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ImagePullPolicy", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ImagePullPolicy = PullPolicy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 15:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecurityContext", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecurityContext == nil {
+ m.SecurityContext = &SecurityContext{}
+ }
+ if err := m.SecurityContext.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 16:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stdin = bool(v != 0)
+ case 17:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StdinOnce", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.StdinOnce = bool(v != 0)
+ case 18:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TTY", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TTY = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerImage) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerImage: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerImage: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Names = append(m.Names, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SizeBytes", wireType)
+ }
+ m.SizeBytes = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.SizeBytes |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerPort) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerPort: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerPort: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPort", wireType)
+ }
+ m.HostPort = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.HostPort |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerPort", wireType)
+ }
+ m.ContainerPort = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ContainerPort |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Protocol = Protocol(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostIP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.HostIP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerState) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerState: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Waiting", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Waiting == nil {
+ m.Waiting = &ContainerStateWaiting{}
+ }
+ if err := m.Waiting.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Running", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Running == nil {
+ m.Running = &ContainerStateRunning{}
+ }
+ if err := m.Running.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Terminated", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Terminated == nil {
+ m.Terminated = &ContainerStateTerminated{}
+ }
+ if err := m.Terminated.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerStateRunning) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerStateRunning: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerStateRunning: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.StartedAt.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerStateTerminated) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerStateTerminated: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerStateTerminated: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ExitCode", wireType)
+ }
+ m.ExitCode = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ExitCode |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType)
+ }
+ m.Signal = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Signal |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.StartedAt.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FinishedAt", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.FinishedAt.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContainerID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerStateWaiting) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerStateWaiting: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerStateWaiting: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ContainerStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ContainerStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ContainerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.State.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTerminationState", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTerminationState.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ready", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Ready = bool(v != 0)
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RestartCount", wireType)
+ }
+ m.RestartCount = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.RestartCount |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Image = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ImageID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ImageID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContainerID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DaemonEndpoint) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DaemonEndpoint: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DaemonEndpoint: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ m.Port = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Port |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeleteOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeleteOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeleteOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GracePeriodSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.GracePeriodSeconds = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Preconditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Preconditions == nil {
+ m.Preconditions = &Preconditions{}
+ }
+ if err := m.Preconditions.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field OrphanDependents", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.OrphanDependents = &b
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DownwardAPIVolumeFile) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DownwardAPIVolumeFile: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DownwardAPIVolumeFile: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FieldRef == nil {
+ m.FieldRef = &ObjectFieldSelector{}
+ }
+ if err := m.FieldRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceFieldRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ResourceFieldRef == nil {
+ m.ResourceFieldRef = &ResourceFieldSelector{}
+ }
+ if err := m.ResourceFieldRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DownwardAPIVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DownwardAPIVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DownwardAPIVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, DownwardAPIVolumeFile{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EmptyDirVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EmptyDirVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EmptyDirVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Medium", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Medium = StorageMedium(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EndpointAddress) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EndpointAddress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EndpointAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.IP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.TargetRef == nil {
+ m.TargetRef = &ObjectReference{}
+ }
+ if err := m.TargetRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Hostname = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EndpointPort) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EndpointPort: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EndpointPort: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ m.Port = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Port |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Protocol = Protocol(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EndpointSubset) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EndpointSubset: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EndpointSubset: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Addresses = append(m.Addresses, EndpointAddress{})
+ if err := m.Addresses[len(m.Addresses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NotReadyAddresses", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NotReadyAddresses = append(m.NotReadyAddresses, EndpointAddress{})
+ if err := m.NotReadyAddresses[len(m.NotReadyAddresses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ports = append(m.Ports, EndpointPort{})
+ if err := m.Ports[len(m.Ports)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Endpoints) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Endpoints: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Endpoints: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subsets", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subsets = append(m.Subsets, EndpointSubset{})
+ if err := m.Subsets[len(m.Subsets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EndpointsList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EndpointsList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EndpointsList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Endpoints{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EnvVar) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EnvVar: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EnvVar: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Value = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ValueFrom", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ValueFrom == nil {
+ m.ValueFrom = &EnvVarSource{}
+ }
+ if err := m.ValueFrom.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EnvVarSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EnvVarSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EnvVarSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FieldRef == nil {
+ m.FieldRef = &ObjectFieldSelector{}
+ }
+ if err := m.FieldRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceFieldRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ResourceFieldRef == nil {
+ m.ResourceFieldRef = &ResourceFieldSelector{}
+ }
+ if err := m.ResourceFieldRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ConfigMapKeyRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ConfigMapKeyRef == nil {
+ m.ConfigMapKeyRef = &ConfigMapKeySelector{}
+ }
+ if err := m.ConfigMapKeyRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretKeyRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecretKeyRef == nil {
+ m.SecretKeyRef = &SecretKeySelector{}
+ }
+ if err := m.SecretKeyRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Event) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Event: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field InvolvedObject", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.InvolvedObject.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Source.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FirstTimestamp", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.FirstTimestamp.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTimestamp", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTimestamp.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+ }
+ m.Count = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Count |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EventList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EventList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Event{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *EventSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: EventSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Component = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Host = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ExecAction) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ExecAction: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExecAction: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Command = append(m.Command, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ExportOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Export = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Exact = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *FCVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: FCVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FCVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetWWNs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TargetWWNs = append(m.TargetWWNs, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Lun", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Lun = &v
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *FlexVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: FlexVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FlexVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Driver = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecretRef == nil {
+ m.SecretRef = &LocalObjectReference{}
+ }
+ if err := m.SecretRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Options == nil {
+ m.Options = make(map[string]string)
+ }
+ m.Options[mapkey] = mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *FlockerVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: FlockerVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FlockerVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DatasetName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DatasetName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GCEPersistentDiskVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GCEPersistentDiskVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GCEPersistentDiskVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PDName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PDName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
+ }
+ m.Partition = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Partition |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GitRepoVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GitRepoVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GitRepoVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Repository", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Repository = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Revision = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Directory = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GlusterfsVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GlusterfsVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GlusterfsVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field EndpointsName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.EndpointsName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HTTPGetAction) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HTTPGetAction: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HTTPGetAction: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Port.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Host = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Scheme", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Scheme = URIScheme(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HTTPHeaders", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.HTTPHeaders = append(m.HTTPHeaders, HTTPHeader{})
+ if err := m.HTTPHeaders[len(m.HTTPHeaders)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HTTPHeader) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HTTPHeader: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HTTPHeader: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Value = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Handler) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Handler: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Handler: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Exec == nil {
+ m.Exec = &ExecAction{}
+ }
+ if err := m.Exec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HTTPGet", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.HTTPGet == nil {
+ m.HTTPGet = &HTTPGetAction{}
+ }
+ if err := m.HTTPGet.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TCPSocket", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.TCPSocket == nil {
+ m.TCPSocket = &TCPSocketAction{}
+ }
+ if err := m.TCPSocket.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HostPathVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HostPathVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HostPathVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ISCSIVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ISCSIVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ISCSIVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetPortal", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TargetPortal = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IQN", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.IQN = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Lun", wireType)
+ }
+ m.Lun = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Lun |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ISCSIInterface", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ISCSIInterface = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *KeyToPath) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: KeyToPath: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: KeyToPath: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Lifecycle) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Lifecycle: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Lifecycle: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PostStart", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PostStart == nil {
+ m.PostStart = &Handler{}
+ }
+ if err := m.PostStart.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreStop", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PreStop == nil {
+ m.PreStop = &Handler{}
+ }
+ if err := m.PreStop.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LimitRange) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LimitRange: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LimitRange: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LimitRangeItem) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LimitRangeItem: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LimitRangeItem: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = LimitType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Max == nil {
+ m.Max = make(ResourceList)
+ }
+ m.Max[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Min == nil {
+ m.Min = make(ResourceList)
+ }
+ m.Min[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Default == nil {
+ m.Default = make(ResourceList)
+ }
+ m.Default[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DefaultRequest", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.DefaultRequest == nil {
+ m.DefaultRequest = make(ResourceList)
+ }
+ m.DefaultRequest[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxLimitRequestRatio", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.MaxLimitRequestRatio == nil {
+ m.MaxLimitRequestRatio = make(ResourceList)
+ }
+ m.MaxLimitRequestRatio[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LimitRangeList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LimitRangeList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LimitRangeList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, LimitRange{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LimitRangeSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LimitRangeSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LimitRangeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Limits", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Limits = append(m.Limits, LimitRangeItem{})
+ if err := m.Limits[len(m.Limits)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *List) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: List: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, k8s_io_kubernetes_pkg_runtime.RawExtension{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ListOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ListOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.LabelSelector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FieldSelector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Watch = bool(v != 0)
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TimeoutSeconds = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LoadBalancerIngress) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LoadBalancerIngress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LoadBalancerIngress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.IP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Hostname = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LoadBalancerStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LoadBalancerStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LoadBalancerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ingress = append(m.Ingress, LoadBalancerIngress{})
+ if err := m.Ingress[len(m.Ingress)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LocalObjectReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LocalObjectReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LocalObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NFSVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NFSVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NFSVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Server = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Namespace) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Namespace: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NamespaceList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NamespaceList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NamespaceList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Namespace{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NamespaceSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NamespaceSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NamespaceSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Finalizers = append(m.Finalizers, FinalizerName(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NamespaceStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NamespaceStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NamespaceStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Phase = NamespacePhase(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Node) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Node: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeAddress) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeAddress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = NodeAddressType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Address = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeAffinity) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeAffinity: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeAffinity: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RequiredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ m.RequiredDuringSchedulingIgnoredDuringExecution = &NodeSelector{}
+ }
+ if err := m.RequiredDuringSchedulingIgnoredDuringExecution.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreferredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PreferredDuringSchedulingIgnoredDuringExecution = append(m.PreferredDuringSchedulingIgnoredDuringExecution, PreferredSchedulingTerm{})
+ if err := m.PreferredDuringSchedulingIgnoredDuringExecution[len(m.PreferredDuringSchedulingIgnoredDuringExecution)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = NodeConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastHeartbeatTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastHeartbeatTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeDaemonEndpoints) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeDaemonEndpoints: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeDaemonEndpoints: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field KubeletEndpoint", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.KubeletEndpoint.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Node{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeProxyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeProxyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeProxyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodeSelectorTerms", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NodeSelectorTerms = append(m.NodeSelectorTerms, NodeSelectorTerm{})
+ if err := m.NodeSelectorTerms[len(m.NodeSelectorTerms)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeSelectorRequirement) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeSelectorRequirement: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = NodeSelectorOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Values = append(m.Values, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeSelectorTerm) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeSelectorTerm: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeSelectorTerm: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MatchExpressions = append(m.MatchExpressions, NodeSelectorRequirement{})
+ if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodCIDR", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PodCIDR = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ExternalID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ExternalID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ProviderID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ProviderID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Unschedulable", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Unschedulable = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Capacity == nil {
+ m.Capacity = make(ResourceList)
+ }
+ m.Capacity[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Allocatable", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Allocatable == nil {
+ m.Allocatable = make(ResourceList)
+ }
+ m.Allocatable[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Phase = NodePhase(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, NodeCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Addresses = append(m.Addresses, NodeAddress{})
+ if err := m.Addresses[len(m.Addresses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DaemonEndpoints", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.DaemonEndpoints.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodeInfo", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.NodeInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Images", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Images = append(m.Images, ContainerImage{})
+ if err := m.Images[len(m.Images)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumesInUse", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumesInUse = append(m.VolumesInUse, UniqueVolumeName(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumesAttached", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumesAttached = append(m.VolumesAttached, AttachedVolume{})
+ if err := m.VolumesAttached[len(m.VolumesAttached)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NodeSystemInfo) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NodeSystemInfo: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NodeSystemInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MachineID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MachineID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SystemUUID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SystemUUID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BootID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.BootID = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field KernelVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.KernelVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field OSImage", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.OSImage = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerRuntimeVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContainerRuntimeVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field KubeletVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.KubeletVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field KubeProxyVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.KubeProxyVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field OperatingSystem", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.OperatingSystem = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Architecture", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Architecture = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ObjectFieldSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ObjectFieldSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ObjectFieldSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldPath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FieldPath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ObjectMeta) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ObjectMeta: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ObjectMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GenerateName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.GenerateName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Namespace = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SelfLink = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.UID = k8s_io_kubernetes_pkg_types.UID(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
+ }
+ m.Generation = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Generation |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestamp", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.CreationTimestamp.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestamp", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.DeletionTimestamp == nil {
+ m.DeletionTimestamp = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.DeletionTimestamp.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DeletionGracePeriodSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.DeletionGracePeriodSeconds = &v
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Labels == nil {
+ m.Labels = make(map[string]string)
+ }
+ m.Labels[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Annotations == nil {
+ m.Annotations = make(map[string]string)
+ }
+ m.Annotations[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.OwnerReferences = append(m.OwnerReferences, OwnerReference{})
+ if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 14:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Finalizers = append(m.Finalizers, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ObjectReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ObjectReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Namespace = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.UID = k8s_io_kubernetes_pkg_types.UID(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldPath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FieldPath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *OwnerReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: OwnerReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.UID = k8s_io_kubernetes_pkg_types.UID(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.Controller = &b
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolume) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolume: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolume: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeClaim) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeClaim: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeClaim: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeClaimList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeClaimList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeClaimList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PersistentVolumeClaim{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeClaimSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeClaimSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeClaimSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AccessModes", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.AccessModes = append(m.AccessModes, PersistentVolumeAccessMode(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Resources.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumeName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &k8s_io_kubernetes_pkg_api_unversioned.LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeClaimStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeClaimStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeClaimStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Phase = PersistentVolumeClaimPhase(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AccessModes", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.AccessModes = append(m.AccessModes, PersistentVolumeAccessMode(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Capacity == nil {
+ m.Capacity = make(ResourceList)
+ }
+ m.Capacity[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeClaimVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeClaimVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeClaimVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClaimName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ClaimName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PersistentVolume{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GCEPersistentDisk", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.GCEPersistentDisk == nil {
+ m.GCEPersistentDisk = &GCEPersistentDiskVolumeSource{}
+ }
+ if err := m.GCEPersistentDisk.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AWSElasticBlockStore", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.AWSElasticBlockStore == nil {
+ m.AWSElasticBlockStore = &AWSElasticBlockStoreVolumeSource{}
+ }
+ if err := m.AWSElasticBlockStore.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.HostPath == nil {
+ m.HostPath = &HostPathVolumeSource{}
+ }
+ if err := m.HostPath.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Glusterfs", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Glusterfs == nil {
+ m.Glusterfs = &GlusterfsVolumeSource{}
+ }
+ if err := m.Glusterfs.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NFS", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.NFS == nil {
+ m.NFS = &NFSVolumeSource{}
+ }
+ if err := m.NFS.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RBD", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.RBD == nil {
+ m.RBD = &RBDVolumeSource{}
+ }
+ if err := m.RBD.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ISCSI", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ISCSI == nil {
+ m.ISCSI = &ISCSIVolumeSource{}
+ }
+ if err := m.ISCSI.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Cinder", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Cinder == nil {
+ m.Cinder = &CinderVolumeSource{}
+ }
+ if err := m.Cinder.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CephFS", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CephFS == nil {
+ m.CephFS = &CephFSVolumeSource{}
+ }
+ if err := m.CephFS.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FC", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FC == nil {
+ m.FC = &FCVolumeSource{}
+ }
+ if err := m.FC.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Flocker", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Flocker == nil {
+ m.Flocker = &FlockerVolumeSource{}
+ }
+ if err := m.Flocker.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FlexVolume", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FlexVolume == nil {
+ m.FlexVolume = &FlexVolumeSource{}
+ }
+ if err := m.FlexVolume.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AzureFile", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.AzureFile == nil {
+ m.AzureFile = &AzureFileVolumeSource{}
+ }
+ if err := m.AzureFile.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 14:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VsphereVolume", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.VsphereVolume == nil {
+ m.VsphereVolume = &VsphereVirtualDiskVolumeSource{}
+ }
+ if err := m.VsphereVolume.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Capacity == nil {
+ m.Capacity = make(ResourceList)
+ }
+ m.Capacity[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeSource", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.PersistentVolumeSource.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AccessModes", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.AccessModes = append(m.AccessModes, PersistentVolumeAccessMode(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClaimRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ClaimRef == nil {
+ m.ClaimRef = &ObjectReference{}
+ }
+ if err := m.ClaimRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeReclaimPolicy", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimPolicy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PersistentVolumeStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PersistentVolumeStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PersistentVolumeStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Phase = PersistentVolumePhase(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Pod) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Pod: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Pod: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodAffinity) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodAffinity: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodAffinity: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RequiredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RequiredDuringSchedulingIgnoredDuringExecution = append(m.RequiredDuringSchedulingIgnoredDuringExecution, PodAffinityTerm{})
+ if err := m.RequiredDuringSchedulingIgnoredDuringExecution[len(m.RequiredDuringSchedulingIgnoredDuringExecution)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreferredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PreferredDuringSchedulingIgnoredDuringExecution = append(m.PreferredDuringSchedulingIgnoredDuringExecution, WeightedPodAffinityTerm{})
+ if err := m.PreferredDuringSchedulingIgnoredDuringExecution[len(m.PreferredDuringSchedulingIgnoredDuringExecution)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodAffinityTerm) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodAffinityTerm: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodAffinityTerm: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.LabelSelector == nil {
+ m.LabelSelector = &k8s_io_kubernetes_pkg_api_unversioned.LabelSelector{}
+ }
+ if err := m.LabelSelector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Namespaces = append(m.Namespaces, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TopologyKey", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TopologyKey = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodAntiAffinity) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodAntiAffinity: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodAntiAffinity: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RequiredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RequiredDuringSchedulingIgnoredDuringExecution = append(m.RequiredDuringSchedulingIgnoredDuringExecution, PodAffinityTerm{})
+ if err := m.RequiredDuringSchedulingIgnoredDuringExecution[len(m.RequiredDuringSchedulingIgnoredDuringExecution)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreferredDuringSchedulingIgnoredDuringExecution", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PreferredDuringSchedulingIgnoredDuringExecution = append(m.PreferredDuringSchedulingIgnoredDuringExecution, WeightedPodAffinityTerm{})
+ if err := m.PreferredDuringSchedulingIgnoredDuringExecution[len(m.PreferredDuringSchedulingIgnoredDuringExecution)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodAttachOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodAttachOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodAttachOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stdin = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stdout = bool(v != 0)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stderr = bool(v != 0)
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TTY", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TTY = bool(v != 0)
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Container = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = PodConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodExecOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodExecOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodExecOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stdin = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stdout = bool(v != 0)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Stderr = bool(v != 0)
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TTY", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TTY = bool(v != 0)
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Container = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Command = append(m.Command, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Pod{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodLogOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodLogOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodLogOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Container = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Follow", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Follow = bool(v != 0)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Previous", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Previous = bool(v != 0)
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SinceSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.SinceSeconds = &v
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SinceTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SinceTime == nil {
+ m.SinceTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.SinceTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Timestamps = bool(v != 0)
+ case 7:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TailLines", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TailLines = &v
+ case 8:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LimitBytes", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.LimitBytes = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodProxyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodProxyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodProxyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodSecurityContext) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodSecurityContext: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodSecurityContext: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SELinuxOptions == nil {
+ m.SELinuxOptions = &SELinuxOptions{}
+ }
+ if err := m.SELinuxOptions.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.RunAsUser = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAsNonRoot", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.RunAsNonRoot = &b
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.SupplementalGroups = append(m.SupplementalGroups, v)
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.FSGroup = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Volumes = append(m.Volumes, Volume{})
+ if err := m.Volumes[len(m.Volumes)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Containers", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Containers = append(m.Containers, Container{})
+ if err := m.Containers[len(m.Containers)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RestartPolicy", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RestartPolicy = RestartPolicy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TerminationGracePeriodSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TerminationGracePeriodSeconds = &v
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ActiveDeadlineSeconds = &v
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DNSPolicy", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DNSPolicy = DNSPolicy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.NodeSelector == nil {
+ m.NodeSelector = make(map[string]string)
+ }
+ m.NodeSelector[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServiceAccountName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedServiceAccount", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DeprecatedServiceAccount = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NodeName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 11:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostNetwork = bool(v != 0)
+ case 12:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostPID = bool(v != 0)
+ case 13:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostIPC = bool(v != 0)
+ case 14:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecurityContext", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecurityContext == nil {
+ m.SecurityContext = &PodSecurityContext{}
+ }
+ if err := m.SecurityContext.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 15:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ImagePullSecrets", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ImagePullSecrets = append(m.ImagePullSecrets, LocalObjectReference{})
+ if err := m.ImagePullSecrets[len(m.ImagePullSecrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 16:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Hostname = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 17:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subdomain", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subdomain = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Phase = PodPhase(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, PodCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostIP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.HostIP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodIP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.PodIP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.StartTime == nil {
+ m.StartTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.StartTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerStatuses", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContainerStatuses = append(m.ContainerStatuses, ContainerStatus{})
+ if err := m.ContainerStatuses[len(m.ContainerStatuses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodStatusResult) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodStatusResult: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodStatusResult: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodTemplate) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodTemplate: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodTemplateList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodTemplateList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodTemplateList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PodTemplate{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodTemplateSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodTemplateSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Preconditions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Preconditions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Preconditions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ s := k8s_io_kubernetes_pkg_types.UID(data[iNdEx:postIndex])
+ m.UID = &s
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PreferredSchedulingTerm) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PreferredSchedulingTerm: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PreferredSchedulingTerm: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
+ }
+ m.Weight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Weight |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Preference", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Preference.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Probe) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Probe: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Probe: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Handler", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Handler.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field InitialDelaySeconds", wireType)
+ }
+ m.InitialDelaySeconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.InitialDelaySeconds |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
+ }
+ m.TimeoutSeconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.TimeoutSeconds |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PeriodSeconds", wireType)
+ }
+ m.PeriodSeconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.PeriodSeconds |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SuccessThreshold", wireType)
+ }
+ m.SuccessThreshold = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.SuccessThreshold |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FailureThreshold", wireType)
+ }
+ m.FailureThreshold = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.FailureThreshold |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RBDVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RBDVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RBDVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CephMonitors", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.CephMonitors = append(m.CephMonitors, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RBDImage", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RBDImage = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RBDPool", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RBDPool = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RadosUser", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RadosUser = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Keyring", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Keyring = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SecretRef == nil {
+ m.SecretRef = &LocalObjectReference{}
+ }
+ if err := m.SecretRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RangeAllocation) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RangeAllocation: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RangeAllocation: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Range = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ byteLen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Data = append(m.Data[:0], data[iNdEx:postIndex]...)
+ if m.Data == nil {
+ m.Data = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicationController) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicationController: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicationController: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicationControllerList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicationControllerList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicationControllerList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ReplicationController{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicationControllerSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicationControllerSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicationControllerSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Replicas = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Selector == nil {
+ m.Selector = make(map[string]string)
+ }
+ m.Selector[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Template == nil {
+ m.Template = &PodTemplateSpec{}
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicationControllerStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicationControllerStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicationControllerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
+ }
+ m.FullyLabeledReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ m.ObservedGeneration = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ObservedGeneration |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceFieldSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceFieldSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceFieldSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContainerName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContainerName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Resource = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Divisor", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Divisor.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceQuota) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceQuota: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceQuota: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceQuotaList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceQuotaList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceQuotaList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ResourceQuota{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceQuotaSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceQuotaSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceQuotaSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hard", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Hard == nil {
+ m.Hard = make(ResourceList)
+ }
+ m.Hard[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Scopes", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Scopes = append(m.Scopes, ResourceQuotaScope(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceQuotaStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceQuotaStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceQuotaStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hard", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Hard == nil {
+ m.Hard = make(ResourceList)
+ }
+ m.Hard[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Used == nil {
+ m.Used = make(ResourceList)
+ }
+ m.Used[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ResourceRequirements) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ResourceRequirements: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ResourceRequirements: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Limits", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Limits == nil {
+ m.Limits = make(ResourceList)
+ }
+ m.Limits[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := ResourceName(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapmsglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapmsglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postmsgIndex := iNdEx + mapmsglen
+ if mapmsglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if postmsgIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := &k8s_io_kubernetes_pkg_api_resource.Quantity{}
+ if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {
+ return err
+ }
+ iNdEx = postmsgIndex
+ if m.Requests == nil {
+ m.Requests = make(ResourceList)
+ }
+ m.Requests[ResourceName(mapkey)] = *mapvalue
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SELinuxOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SELinuxOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SELinuxOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.User = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Role = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Level = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Secret) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Secret: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Secret: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var mapbyteLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ mapbyteLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intMapbyteLen := int(mapbyteLen)
+ if intMapbyteLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postbytesIndex := iNdEx + intMapbyteLen
+ if postbytesIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := make([]byte, mapbyteLen)
+ copy(mapvalue, data[iNdEx:postbytesIndex])
+ iNdEx = postbytesIndex
+ if m.Data == nil {
+ m.Data = make(map[string][]byte)
+ }
+ m.Data[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = SecretType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SecretKeySelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SecretKeySelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SecretKeySelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LocalObjectReference", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LocalObjectReference.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SecretList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SecretList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SecretList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Secret{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SecretVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SecretVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SecretVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SecretName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, KeyToPath{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SecurityContext) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SecurityContext: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SecurityContext: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Capabilities == nil {
+ m.Capabilities = &Capabilities{}
+ }
+ if err := m.Capabilities.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.Privileged = &b
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SELinuxOptions == nil {
+ m.SELinuxOptions = &SELinuxOptions{}
+ }
+ if err := m.SELinuxOptions.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.RunAsUser = &v
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAsNonRoot", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.RunAsNonRoot = &b
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.ReadOnlyRootFilesystem = &b
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SerializedReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SerializedReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SerializedReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reference", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Reference.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Service) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Service: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Service: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceAccount) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceAccount: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceAccount: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Secrets", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Secrets = append(m.Secrets, ObjectReference{})
+ if err := m.Secrets[len(m.Secrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ImagePullSecrets", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ImagePullSecrets = append(m.ImagePullSecrets, LocalObjectReference{})
+ if err := m.ImagePullSecrets[len(m.ImagePullSecrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceAccountList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceAccountList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceAccountList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ServiceAccount{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Service{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServicePort) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServicePort: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServicePort: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Protocol = Protocol(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ m.Port = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Port |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetPort", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.TargetPort.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NodePort", wireType)
+ }
+ m.NodePort = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.NodePort |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceProxyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceProxyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceProxyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ports = append(m.Ports, ServicePort{})
+ if err := m.Ports[len(m.Ports)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Selector == nil {
+ m.Selector = make(map[string]string)
+ }
+ m.Selector[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClusterIP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ClusterIP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = ServiceType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ExternalIPs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ExternalIPs = append(m.ExternalIPs, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedPublicIPs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DeprecatedPublicIPs = append(m.DeprecatedPublicIPs, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SessionAffinity", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SessionAffinity = ServiceAffinity(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerIP", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.LoadBalancerIP = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerSourceRanges", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.LoadBalancerSourceRanges = append(m.LoadBalancerSourceRanges, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ServiceStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ServiceStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ServiceStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LoadBalancer.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *TCPSocketAction) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: TCPSocketAction: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: TCPSocketAction: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Port.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Taint) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Taint: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Taint: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Value = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Effect", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Effect = TaintEffect(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Toleration) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Toleration: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Toleration: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = TolerationOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Value = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Effect", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Effect = TaintEffect(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Volume) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Volume: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Volume: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeSource", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.VolumeSource.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *VolumeMount) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: VolumeMount: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: VolumeMount: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnly = bool(v != 0)
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MountPath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MountPath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SubPath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SubPath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *VolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: VolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: VolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.HostPath == nil {
+ m.HostPath = &HostPathVolumeSource{}
+ }
+ if err := m.HostPath.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field EmptyDir", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.EmptyDir == nil {
+ m.EmptyDir = &EmptyDirVolumeSource{}
+ }
+ if err := m.EmptyDir.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GCEPersistentDisk", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.GCEPersistentDisk == nil {
+ m.GCEPersistentDisk = &GCEPersistentDiskVolumeSource{}
+ }
+ if err := m.GCEPersistentDisk.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AWSElasticBlockStore", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.AWSElasticBlockStore == nil {
+ m.AWSElasticBlockStore = &AWSElasticBlockStoreVolumeSource{}
+ }
+ if err := m.AWSElasticBlockStore.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field GitRepo", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.GitRepo == nil {
+ m.GitRepo = &GitRepoVolumeSource{}
+ }
+ if err := m.GitRepo.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Secret == nil {
+ m.Secret = &SecretVolumeSource{}
+ }
+ if err := m.Secret.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NFS", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.NFS == nil {
+ m.NFS = &NFSVolumeSource{}
+ }
+ if err := m.NFS.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ISCSI", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ISCSI == nil {
+ m.ISCSI = &ISCSIVolumeSource{}
+ }
+ if err := m.ISCSI.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Glusterfs", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Glusterfs == nil {
+ m.Glusterfs = &GlusterfsVolumeSource{}
+ }
+ if err := m.Glusterfs.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaim", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PersistentVolumeClaim == nil {
+ m.PersistentVolumeClaim = &PersistentVolumeClaimVolumeSource{}
+ }
+ if err := m.PersistentVolumeClaim.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RBD", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.RBD == nil {
+ m.RBD = &RBDVolumeSource{}
+ }
+ if err := m.RBD.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FlexVolume", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FlexVolume == nil {
+ m.FlexVolume = &FlexVolumeSource{}
+ }
+ if err := m.FlexVolume.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Cinder", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Cinder == nil {
+ m.Cinder = &CinderVolumeSource{}
+ }
+ if err := m.Cinder.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 14:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CephFS", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CephFS == nil {
+ m.CephFS = &CephFSVolumeSource{}
+ }
+ if err := m.CephFS.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 15:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Flocker", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Flocker == nil {
+ m.Flocker = &FlockerVolumeSource{}
+ }
+ if err := m.Flocker.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 16:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DownwardAPI", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.DownwardAPI == nil {
+ m.DownwardAPI = &DownwardAPIVolumeSource{}
+ }
+ if err := m.DownwardAPI.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 17:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FC", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FC == nil {
+ m.FC = &FCVolumeSource{}
+ }
+ if err := m.FC.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 18:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AzureFile", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.AzureFile == nil {
+ m.AzureFile = &AzureFileVolumeSource{}
+ }
+ if err := m.AzureFile.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 19:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ConfigMap", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.ConfigMap == nil {
+ m.ConfigMap = &ConfigMapVolumeSource{}
+ }
+ if err := m.ConfigMap.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 20:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VsphereVolume", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.VsphereVolume == nil {
+ m.VsphereVolume = &VsphereVirtualDiskVolumeSource{}
+ }
+ if err := m.VsphereVolume.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *VsphereVirtualDiskVolumeSource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: VsphereVirtualDiskVolumeSource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: VsphereVirtualDiskVolumeSource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumePath", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumePath = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FSType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *WeightedPodAffinityTerm) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: WeightedPodAffinityTerm: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: WeightedPodAffinityTerm: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
+ }
+ m.Weight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Weight |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodAffinityTerm", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.PodAffinityTerm.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/generated.proto b/vendor/k8s.io/kubernetes/pkg/api/v1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..4a99eec8854fc9dd49930036c431183e7f564481
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/generated.proto
@@ -0,0 +1,2924 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.api.v1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1";
+
+// 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.
+message AWSElasticBlockStoreVolumeSource {
+ // Unique ID of the persistent disk resource in AWS (Amazon EBS volume).
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ optional string volumeID = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ // TODO: how do we prevent errors in the filesystem from compromising the machine
+ optional string fsType = 2;
+
+ // 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).
+ optional int32 partition = 3;
+
+ // Specify "true" to force and set the ReadOnly property in VolumeMounts to "true".
+ // If omitted, the default is "false".
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ optional bool readOnly = 4;
+}
+
+// Affinity is a group of affinity scheduling rules.
+message Affinity {
+ // Describes node affinity scheduling rules for the pod.
+ optional NodeAffinity nodeAffinity = 1;
+
+ // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
+ optional PodAffinity podAffinity = 2;
+
+ // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
+ optional PodAntiAffinity podAntiAffinity = 3;
+}
+
+// AttachedVolume describes a volume attached to a node
+message AttachedVolume {
+ // Name of the attached volume
+ optional string name = 1;
+
+ // DevicePath represents the device path where the volume should be avilable
+ optional string devicePath = 2;
+}
+
+// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
+message AzureFileVolumeSource {
+ // the name of secret that contains Azure Storage Account Name and Key
+ optional string secretName = 1;
+
+ // Share Name
+ optional string shareName = 2;
+
+ // Defaults to false (read/write). ReadOnly here will force
+ // the ReadOnly setting in VolumeMounts.
+ optional bool readOnly = 3;
+}
+
+// Binding ties one object to another.
+// For example, a pod is bound to a node by a scheduler.
+message Binding {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // The target object that you want to bind to the standard object.
+ optional ObjectReference target = 2;
+}
+
+// Adds and removes POSIX capabilities from running containers.
+message Capabilities {
+ // Added capabilities
+ repeated string add = 1;
+
+ // Removed capabilities
+ repeated string drop = 2;
+}
+
+// Represents a Ceph Filesystem mount that lasts the lifetime of a pod
+// Cephfs volumes do not support ownership management or SELinux relabeling.
+message CephFSVolumeSource {
+ // Required: Monitors is a collection of Ceph monitors
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ repeated string monitors = 1;
+
+ // Optional: Used as the mounted root, rather than the full Ceph tree, default is /
+ optional string path = 2;
+
+ // Optional: User is the rados user name, default is admin
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ optional string user = 3;
+
+ // Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ optional string secretFile = 4;
+
+ // Optional: SecretRef is reference to the authentication secret for User, default is empty.
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ optional LocalObjectReference secretRef = 5;
+
+ // Optional: Defaults to false (read/write). ReadOnly here will force
+ // the ReadOnly setting in VolumeMounts.
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ optional bool readOnly = 6;
+}
+
+// Represents a cinder volume resource in Openstack.
+// A Cinder volume must exist before mounting to a container.
+// The volume must also be in the same region as the kubelet.
+// Cinder volumes support ownership management and SELinux relabeling.
+message CinderVolumeSource {
+ // volume id used to identify the volume in cinder
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ optional string volumeID = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ optional string fsType = 2;
+
+ // Optional: Defaults to false (read/write). ReadOnly here will force
+ // the ReadOnly setting in VolumeMounts.
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ optional bool readOnly = 3;
+}
+
+// Information about the condition of a component.
+message ComponentCondition {
+ // Type of condition for a component.
+ // Valid value: "Healthy"
+ optional string type = 1;
+
+ // Status of the condition for a component.
+ // Valid values for "Healthy": "True", "False", or "Unknown".
+ optional string status = 2;
+
+ // Message about the condition for a component.
+ // For example, information about a health check.
+ optional string message = 3;
+
+ // Condition error code for a component.
+ // For example, a health check error code.
+ optional string error = 4;
+}
+
+// ComponentStatus (and ComponentStatusList) holds the cluster validation info.
+message ComponentStatus {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // List of component conditions observed
+ repeated ComponentCondition conditions = 2;
+}
+
+// Status of all the conditions for the component as a list of ComponentStatus objects.
+message ComponentStatusList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of ComponentStatus objects.
+ repeated ComponentStatus items = 2;
+}
+
+// ConfigMap holds configuration data for pods to consume.
+message ConfigMap {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Data contains the configuration data.
+ // Each key must be a valid DNS_SUBDOMAIN with an optional leading dot.
+ map<string, string> data = 2;
+}
+
+// Selects a key from a ConfigMap.
+message ConfigMapKeySelector {
+ // The ConfigMap to select from.
+ optional LocalObjectReference localObjectReference = 1;
+
+ // The key to select.
+ optional string key = 2;
+}
+
+// ConfigMapList is a resource containing a list of ConfigMap objects.
+message ConfigMapList {
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of ConfigMaps.
+ repeated ConfigMap items = 2;
+}
+
+// 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.
+message ConfigMapVolumeSource {
+ optional LocalObjectReference localObjectReference = 1;
+
+ // 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. Paths must be relative and may not contain
+ // the '..' path or start with '..'.
+ repeated KeyToPath items = 2;
+}
+
+// A single application container that you want to run within a pod.
+message Container {
+ // Name of the container specified as a DNS_LABEL.
+ // Each container in a pod must have a unique name (DNS_LABEL).
+ // Cannot be updated.
+ optional string name = 1;
+
+ // Docker image name.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md
+ optional string image = 2;
+
+ // 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. The $(VAR_NAME) syntax
+ // can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded,
+ // regardless of whether the variable exists or not.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands
+ repeated string command = 3;
+
+ // 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. The $(VAR_NAME) syntax
+ // can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded,
+ // regardless of whether the variable exists or not.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands
+ repeated string args = 4;
+
+ // 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.
+ optional string workingDir = 5;
+
+ // 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.
+ repeated ContainerPort ports = 6;
+
+ // List of environment variables to set in the container.
+ // Cannot be updated.
+ repeated EnvVar env = 7;
+
+ // Compute Resources required by this container.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources
+ optional ResourceRequirements resources = 8;
+
+ // Pod volumes to mount into the container's filesystem.
+ // Cannot be updated.
+ repeated VolumeMount volumeMounts = 9;
+
+ // Periodic probe of container liveness.
+ // Container will be restarted if the probe fails.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ optional Probe livenessProbe = 10;
+
+ // Periodic probe of container service readiness.
+ // Container will be removed from service endpoints if the probe fails.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ optional Probe readinessProbe = 11;
+
+ // Actions that the management system should take in response to container lifecycle events.
+ // Cannot be updated.
+ optional Lifecycle lifecycle = 12;
+
+ // 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.
+ // Defaults to /dev/termination-log.
+ // Cannot be updated.
+ optional string terminationMessagePath = 13;
+
+ // Image pull policy.
+ // One of Always, Never, IfNotPresent.
+ // Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#updating-images
+ optional string imagePullPolicy = 14;
+
+ // Security options the pod should run with.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md
+ optional SecurityContext securityContext = 15;
+
+ // 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.
+ optional bool stdin = 16;
+
+ // 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
+ optional bool stdinOnce = 17;
+
+ // Whether this container should allocate a TTY for itself, also requires 'stdin' to be true.
+ // Default is false.
+ optional bool tty = 18;
+}
+
+// Describe a container image
+message ContainerImage {
+ // Names by which this image is known.
+ // e.g. ["gcr.io/google_containers/hyperkube:v1.0.7", "dockerhub.io/google_containers/hyperkube:v1.0.7"]
+ repeated string names = 1;
+
+ // The size of the image in bytes.
+ optional int64 sizeBytes = 2;
+}
+
+// ContainerPort represents a network port in a single container.
+message ContainerPort {
+ // 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.
+ optional string name = 1;
+
+ // 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.
+ optional int32 hostPort = 2;
+
+ // Number of port to expose on the pod's IP address.
+ // This must be a valid port number, 0 < x < 65536.
+ optional int32 containerPort = 3;
+
+ // Protocol for port. Must be UDP or TCP.
+ // Defaults to "TCP".
+ optional string protocol = 4;
+
+ // What host IP to bind the external port to.
+ optional string hostIP = 5;
+}
+
+// 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.
+message ContainerState {
+ // Details about a waiting container
+ optional ContainerStateWaiting waiting = 1;
+
+ // Details about a running container
+ optional ContainerStateRunning running = 2;
+
+ // Details about a terminated container
+ optional ContainerStateTerminated terminated = 3;
+}
+
+// ContainerStateRunning is a running state of a container.
+message ContainerStateRunning {
+ // Time at which the container was last (re-)started
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startedAt = 1;
+}
+
+// ContainerStateTerminated is a terminated state of a container.
+message ContainerStateTerminated {
+ // Exit status from the last termination of the container
+ optional int32 exitCode = 1;
+
+ // Signal from the last termination of the container
+ optional int32 signal = 2;
+
+ // (brief) reason from the last termination of the container
+ optional string reason = 3;
+
+ // Message regarding the last termination of the container
+ optional string message = 4;
+
+ // Time at which previous execution of the container started
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startedAt = 5;
+
+ // Time at which the container last terminated
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time finishedAt = 6;
+
+ // Container's ID in the format 'docker://<container_id>'
+ optional string containerID = 7;
+}
+
+// ContainerStateWaiting is a waiting state of a container.
+message ContainerStateWaiting {
+ // (brief) reason the container is not yet running.
+ optional string reason = 1;
+
+ // Message regarding why the container is not yet running.
+ optional string message = 2;
+}
+
+// ContainerStatus contains details for the current status of this container.
+message ContainerStatus {
+ // This must be a DNS_LABEL. Each container in a pod must have a unique name.
+ // Cannot be updated.
+ optional string name = 1;
+
+ // Details about the container's current condition.
+ optional ContainerState state = 2;
+
+ // Details about the container's last termination condition.
+ optional ContainerState lastState = 3;
+
+ // Specifies whether the container has passed its readiness probe.
+ optional bool ready = 4;
+
+ // The number of times the container has been restarted, currently based on
+ // the number of dead containers that have not yet been removed.
+ // Note that this is calculated from dead containers. But those containers are subject to
+ // garbage collection. This value will get capped at 5 by GC.
+ optional int32 restartCount = 5;
+
+ // The image the container is running.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md
+ // TODO(dchen1107): Which image the container is running with?
+ optional string image = 6;
+
+ // ImageID of the container's image.
+ optional string imageID = 7;
+
+ // Container's ID in the format 'docker://<container_id>'.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#container-information
+ optional string containerID = 8;
+}
+
+// DaemonEndpoint contains information about a single Daemon endpoint.
+message DaemonEndpoint {
+ // Port number of the given endpoint.
+ optional int32 Port = 1;
+}
+
+// DeleteOptions may be provided when deleting an API object
+message DeleteOptions {
+ // 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.
+ optional int64 gracePeriodSeconds = 1;
+
+ // Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be
+ // returned.
+ optional Preconditions preconditions = 2;
+
+ // Should the dependent objects be orphaned. If true/false, the "orphan"
+ // finalizer will be added to/removed from the object's finalizers list.
+ optional bool orphanDependents = 3;
+}
+
+// DownwardAPIVolumeFile represents information to create the file containing the pod field
+message DownwardAPIVolumeFile {
+ // 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 '..'
+ optional string path = 1;
+
+ // Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.
+ optional ObjectFieldSelector fieldRef = 2;
+
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ optional ResourceFieldSelector resourceFieldRef = 3;
+}
+
+// DownwardAPIVolumeSource represents a volume containing downward API info.
+// Downward API volumes support ownership management and SELinux relabeling.
+message DownwardAPIVolumeSource {
+ // Items is a list of downward API volume file
+ repeated DownwardAPIVolumeFile items = 1;
+}
+
+// Represents an empty directory for a pod.
+// Empty directory volumes support ownership management and SELinux relabeling.
+message EmptyDirVolumeSource {
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir
+ optional string medium = 1;
+}
+
+// EndpointAddress is a tuple that describes single IP address.
+message EndpointAddress {
+ // The IP of this endpoint.
+ // May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16),
+ // or link-local multicast ((224.0.0.0/24).
+ // IPv6 is also accepted but not fully supported on all platforms. Also, certain
+ // kubernetes components, like kube-proxy, are not IPv6 ready.
+ // TODO: This should allow hostname or IP, See #4447.
+ optional string ip = 1;
+
+ // The Hostname of this endpoint
+ optional string hostname = 3;
+
+ // Reference to object providing the endpoint.
+ optional ObjectReference targetRef = 2;
+}
+
+// EndpointPort is a tuple that describes a single port.
+message EndpointPort {
+ // The name of this port (corresponds to ServicePort.Name).
+ // Must be a DNS_LABEL.
+ // Optional only if one port is defined.
+ optional string name = 1;
+
+ // The port number of the endpoint.
+ optional int32 port = 2;
+
+ // The IP protocol for this port.
+ // Must be UDP or TCP.
+ // Default is TCP.
+ optional string protocol = 3;
+}
+
+// EndpointSubset is a group of addresses with a common set of ports. The
+// expanded set of endpoints is the Cartesian product of Addresses x Ports.
+// For example, given:
+// {
+// Addresses: [{"ip": "10.10.1.1"}, {"ip": "10.10.2.2"}],
+// Ports: [{"name": "a", "port": 8675}, {"name": "b", "port": 309}]
+// }
+// The resulting set of endpoints can be viewed as:
+// a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
+// b: [ 10.10.1.1:309, 10.10.2.2:309 ]
+message EndpointSubset {
+ // IP addresses which offer the related ports that are marked as ready. These endpoints
+ // should be considered safe for load balancers and clients to utilize.
+ repeated EndpointAddress addresses = 1;
+
+ // IP addresses which offer the related ports but are not currently marked as ready
+ // because they have not yet finished starting, have recently failed a readiness check,
+ // or have recently failed a liveness check.
+ repeated EndpointAddress notReadyAddresses = 2;
+
+ // Port numbers available on the related IP addresses.
+ repeated EndpointPort ports = 3;
+}
+
+// Endpoints is a collection of endpoints that implement the actual service. Example:
+// Name: "mysvc",
+// Subsets: [
+// {
+// Addresses: [{"ip": "10.10.1.1"}, {"ip": "10.10.2.2"}],
+// Ports: [{"name": "a", "port": 8675}, {"name": "b", "port": 309}]
+// },
+// {
+// Addresses: [{"ip": "10.10.3.3"}],
+// Ports: [{"name": "a", "port": 93}, {"name": "b", "port": 76}]
+// },
+// ]
+message Endpoints {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // The set of all endpoints is the union of all subsets. Addresses are placed into
+ // subsets according to the IPs they share. A single address with multiple ports,
+ // some of which are ready and some of which are not (because they come from
+ // different containers) will result in the address being displayed in different
+ // subsets for the different ports. No address will appear in both Addresses and
+ // NotReadyAddresses in the same subset.
+ // Sets of addresses and ports that comprise a service.
+ repeated EndpointSubset subsets = 2;
+}
+
+// EndpointsList is a list of endpoints.
+message EndpointsList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of endpoints.
+ repeated Endpoints items = 2;
+}
+
+// EnvVar represents an environment variable present in a Container.
+message EnvVar {
+ // Name of the environment variable. Must be a C_IDENTIFIER.
+ optional string name = 1;
+
+ // Variable references $(VAR_NAME) are expanded
+ // using the previous 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. The $(VAR_NAME)
+ // syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped
+ // references will never be expanded, regardless of whether the variable
+ // exists or not.
+ // Defaults to "".
+ optional string value = 2;
+
+ // Source for the environment variable's value. Cannot be used if value is not empty.
+ optional EnvVarSource valueFrom = 3;
+}
+
+// EnvVarSource represents a source for the value of an EnvVar.
+message EnvVarSource {
+ // Selects a field of the pod; only name and namespace are supported.
+ optional ObjectFieldSelector fieldRef = 1;
+
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ optional ResourceFieldSelector resourceFieldRef = 2;
+
+ // Selects a key of a ConfigMap.
+ optional ConfigMapKeySelector configMapKeyRef = 3;
+
+ // Selects a key of a secret in the pod's namespace
+ optional SecretKeySelector secretKeyRef = 4;
+}
+
+// Event is a report of an event somewhere in the cluster.
+// TODO: Decide whether to store these separately or with the object they apply to.
+message Event {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // The object that this event is about.
+ optional ObjectReference involvedObject = 2;
+
+ // This should be a short, machine understandable string that gives the reason
+ // for the transition into the object's current status.
+ // TODO: provide exact specification for format.
+ optional string reason = 3;
+
+ // A human-readable description of the status of this operation.
+ // TODO: decide on maximum length.
+ optional string message = 4;
+
+ // The component reporting this event. Should be a short machine understandable string.
+ optional EventSource source = 5;
+
+ // The time at which the event was first recorded. (Time of server receipt is in TypeMeta.)
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time firstTimestamp = 6;
+
+ // The time at which the most recent occurrence of this event was recorded.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTimestamp = 7;
+
+ // The number of times this event has occurred.
+ optional int32 count = 8;
+
+ // Type of this event (Normal, Warning), new types could be added in the future
+ optional string type = 9;
+}
+
+// EventList is a list of events.
+message EventList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of events
+ repeated Event items = 2;
+}
+
+// EventSource contains information for an event.
+message EventSource {
+ // Component from which the event is generated.
+ optional string component = 1;
+
+ // Host name on which the event is generated.
+ optional string host = 2;
+}
+
+// ExecAction describes a "run in container" action.
+message ExecAction {
+ // 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.
+ repeated string command = 1;
+}
+
+// ExportOptions is the query options to the standard REST get call.
+message ExportOptions {
+ // Should this value be exported. Export strips fields that a user can not specify.
+ optional bool export = 1;
+
+ // Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
+ optional bool exact = 2;
+}
+
+// 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.
+message FCVolumeSource {
+ // Required: FC target world wide names (WWNs)
+ repeated string targetWWNs = 1;
+
+ // Required: FC target lun number
+ optional int32 lun = 2;
+
+ // 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
+ optional string fsType = 3;
+
+ // Optional: Defaults to false (read/write). ReadOnly here will force
+ // the ReadOnly setting in VolumeMounts.
+ optional bool readOnly = 4;
+}
+
+// FlexVolume represents a generic volume resource that is
+// provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.
+message FlexVolumeSource {
+ // Driver is the name of the driver to use for this volume.
+ optional string driver = 1;
+
+ // 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.
+ optional string fsType = 2;
+
+ // 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.
+ optional LocalObjectReference secretRef = 3;
+
+ // Optional: Defaults to false (read/write). ReadOnly here will force
+ // the ReadOnly setting in VolumeMounts.
+ optional bool readOnly = 4;
+
+ // Optional: Extra command options if any.
+ map<string, string> options = 5;
+}
+
+// Represents a Flocker volume mounted by the Flocker agent.
+// Flocker volumes do not support ownership management or SELinux relabeling.
+message FlockerVolumeSource {
+ // Required: the volume name. This is going to be store on metadata -> name on the payload for Flocker
+ optional string datasetName = 1;
+}
+
+// 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.
+message GCEPersistentDiskVolumeSource {
+ // Unique name of the PD resource in GCE. Used to identify the disk in GCE.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ optional string pdName = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ // TODO: how do we prevent errors in the filesystem from compromising the machine
+ optional string fsType = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ optional int32 partition = 3;
+
+ // ReadOnly here will force the ReadOnly setting in VolumeMounts.
+ // Defaults to false.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ optional bool readOnly = 4;
+}
+
+// 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.
+message GitRepoVolumeSource {
+ // Repository URL
+ optional string repository = 1;
+
+ // Commit hash for the specified revision.
+ optional string revision = 2;
+
+ // 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.
+ optional string directory = 3;
+}
+
+// Represents a Glusterfs mount that lasts the lifetime of a pod.
+// Glusterfs volumes do not support ownership management or SELinux relabeling.
+message GlusterfsVolumeSource {
+ // EndpointsName is the endpoint name that details Glusterfs topology.
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ optional string endpoints = 1;
+
+ // Path is the Glusterfs volume path.
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ optional string path = 2;
+
+ // ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions.
+ // Defaults to false.
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ optional bool readOnly = 3;
+}
+
+// HTTPGetAction describes an action based on HTTP Get requests.
+message HTTPGetAction {
+ // Path to access on the HTTP server.
+ optional string path = 1;
+
+ // 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.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString port = 2;
+
+ // Host name to connect to, defaults to the pod IP. You probably want to set
+ // "Host" in httpHeaders instead.
+ optional string host = 3;
+
+ // Scheme to use for connecting to the host.
+ // Defaults to HTTP.
+ optional string scheme = 4;
+
+ // Custom headers to set in the request. HTTP allows repeated headers.
+ repeated HTTPHeader httpHeaders = 5;
+}
+
+// HTTPHeader describes a custom header to be used in HTTP probes
+message HTTPHeader {
+ // The header field name
+ optional string name = 1;
+
+ // The header field value
+ optional string value = 2;
+}
+
+// Handler defines a specific action that should be taken
+// TODO: pass structured data to these actions, and document that data here.
+message Handler {
+ // One and only one of the following should be specified.
+ // Exec specifies the action to take.
+ optional ExecAction exec = 1;
+
+ // HTTPGet specifies the http request to perform.
+ optional HTTPGetAction httpGet = 2;
+
+ // TCPSocket specifies an action involving a TCP port.
+ // TCP hooks not yet supported
+ // TODO: implement a realistic TCP lifecycle hook
+ optional TCPSocketAction tcpSocket = 3;
+}
+
+// Represents a host path mapped into a pod.
+// Host path volumes do not support ownership management or SELinux relabeling.
+message HostPathVolumeSource {
+ // Path of the directory on the host.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
+ optional string path = 1;
+}
+
+// Represents an ISCSI disk.
+// ISCSI volumes can only be mounted as read/write once.
+// ISCSI volumes support ownership management and SELinux relabeling.
+message ISCSIVolumeSource {
+ // 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).
+ optional string targetPortal = 1;
+
+ // Target iSCSI Qualified Name.
+ optional string iqn = 2;
+
+ // iSCSI target lun number.
+ optional int32 lun = 3;
+
+ // Optional: Defaults to 'default' (tcp). iSCSI interface name that uses an iSCSI transport.
+ optional string iscsiInterface = 4;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#iscsi
+ // TODO: how do we prevent errors in the filesystem from compromising the machine
+ optional string fsType = 5;
+
+ // ReadOnly here will force the ReadOnly setting in VolumeMounts.
+ // Defaults to false.
+ optional bool readOnly = 6;
+}
+
+// Maps a string key to a path within a volume.
+message KeyToPath {
+ // The key to project.
+ optional string key = 1;
+
+ // 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 '..'.
+ optional string path = 2;
+}
+
+// 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.
+message Lifecycle {
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details
+ optional Handler postStart = 1;
+
+ // PreStop is called immediately before a container is terminated.
+ // The container is terminated after the handler completes.
+ // The reason for termination is passed to the handler.
+ // Regardless of the outcome of the handler, the container is eventually terminated.
+ // Other management of the container blocks until the hook completes.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details
+ optional Handler preStop = 2;
+}
+
+// LimitRange sets resource usage limits for each kind of resource in a Namespace.
+message LimitRange {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the limits enforced.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional LimitRangeSpec spec = 2;
+}
+
+// LimitRangeItem defines a min/max usage limit for any resource that matches on kind.
+message LimitRangeItem {
+ // Type of resource that this limit applies to.
+ optional string type = 1;
+
+ // Max usage constraints on this kind by resource name.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> max = 2;
+
+ // Min usage constraints on this kind by resource name.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> min = 3;
+
+ // Default resource requirement limit value by resource name if resource limit is omitted.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> default = 4;
+
+ // DefaultRequest is the default resource requirement request value by resource name if resource request is omitted.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> defaultRequest = 5;
+
+ // 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.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> maxLimitRequestRatio = 6;
+}
+
+// LimitRangeList is a list of LimitRange items.
+message LimitRangeList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of LimitRange objects.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_limit_range.md
+ repeated LimitRange items = 2;
+}
+
+// LimitRangeSpec defines a min/max usage limit for resources that match on kind.
+message LimitRangeSpec {
+ // Limits is the list of LimitRangeItem objects that are enforced.
+ repeated LimitRangeItem limits = 1;
+}
+
+// List holds a list of objects, which may not be known by the server.
+message List {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of objects
+ repeated k8s.io.kubernetes.pkg.runtime.RawExtension items = 2;
+}
+
+// ListOptions is the query options to a standard REST list call.
+message ListOptions {
+ // A selector to restrict the list of returned objects by their labels.
+ // Defaults to everything.
+ optional string labelSelector = 1;
+
+ // A selector to restrict the list of returned objects by their fields.
+ // Defaults to everything.
+ optional string fieldSelector = 2;
+
+ // Watch for changes to the described resources and return them as a stream of
+ // add, update, and remove notifications. Specify resourceVersion.
+ optional bool watch = 3;
+
+ // When specified with a watch call, shows changes that occur after that particular version of a resource.
+ // Defaults to changes from the beginning of history.
+ optional string resourceVersion = 4;
+
+ // Timeout for the list/watch call.
+ optional int64 timeoutSeconds = 5;
+}
+
+// LoadBalancerIngress represents the status of a load-balancer ingress point:
+// traffic intended for the service should be sent to an ingress point.
+message LoadBalancerIngress {
+ // IP is set for load-balancer ingress points that are IP based
+ // (typically GCE or OpenStack load-balancers)
+ optional string ip = 1;
+
+ // Hostname is set for load-balancer ingress points that are DNS based
+ // (typically AWS load-balancers)
+ optional string hostname = 2;
+}
+
+// LoadBalancerStatus represents the status of a load-balancer.
+message LoadBalancerStatus {
+ // Ingress is a list containing ingress points for the load-balancer.
+ // Traffic intended for the service should be sent to these ingress points.
+ repeated LoadBalancerIngress ingress = 1;
+}
+
+// LocalObjectReference contains enough information to let you locate the
+// referenced object inside the same namespace.
+message LocalObjectReference {
+ // Name of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ // TODO: Add other useful fields. apiVersion, kind, uid?
+ optional string name = 1;
+}
+
+// Represents an NFS mount that lasts the lifetime of a pod.
+// NFS volumes do not support ownership management or SELinux relabeling.
+message NFSVolumeSource {
+ // Server is the hostname or IP address of the NFS server.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ optional string server = 1;
+
+ // Path that is exported by the NFS server.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ optional string path = 2;
+
+ // ReadOnly here will force
+ // the NFS export to be mounted with read-only permissions.
+ // Defaults to false.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ optional bool readOnly = 3;
+}
+
+// Namespace provides a scope for Names.
+// Use of multiple namespaces is optional.
+message Namespace {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the behavior of the Namespace.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional NamespaceSpec spec = 2;
+
+ // Status describes the current status of a Namespace.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional NamespaceStatus status = 3;
+}
+
+// NamespaceList is a list of Namespaces.
+message NamespaceList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Namespace objects in the list.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ repeated Namespace items = 2;
+}
+
+// NamespaceSpec describes the attributes on a Namespace.
+message NamespaceSpec {
+ // Finalizers is an opaque list of values that must be empty to permanently remove object from storage.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#finalizers
+ repeated string finalizers = 1;
+}
+
+// NamespaceStatus is information about the current status of a Namespace.
+message NamespaceStatus {
+ // Phase is the current lifecycle phase of the namespace.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#phases
+ optional string phase = 1;
+}
+
+// Node is a worker node in Kubernetes, formerly known as minion.
+// Each node will have a unique identifier in the cache (i.e. in etcd).
+message Node {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the behavior of a node.
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional NodeSpec spec = 2;
+
+ // Most recently observed status of the node.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional NodeStatus status = 3;
+}
+
+// NodeAddress contains information for the node's address.
+message NodeAddress {
+ // Node address type, one of Hostname, ExternalIP or InternalIP.
+ optional string type = 1;
+
+ // The node address.
+ optional string address = 2;
+}
+
+// Node affinity is a group of node affinity scheduling rules.
+message NodeAffinity {
+ // 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.
+ optional NodeSelector requiredDuringSchedulingIgnoredDuringExecution = 1;
+
+ // 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.
+ repeated PreferredSchedulingTerm preferredDuringSchedulingIgnoredDuringExecution = 2;
+}
+
+// NodeCondition contains condition infromation for a node.
+message NodeCondition {
+ // Type of node condition.
+ optional string type = 1;
+
+ // Status of the condition, one of True, False, Unknown.
+ optional string status = 2;
+
+ // Last time we got an update on a given condition.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastHeartbeatTime = 3;
+
+ // Last time the condition transit from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // (brief) reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// NodeDaemonEndpoints lists ports opened by daemons running on the Node.
+message NodeDaemonEndpoints {
+ // Endpoint on which Kubelet is listening.
+ optional DaemonEndpoint kubeletEndpoint = 1;
+}
+
+// NodeList is the whole list of all Nodes which have been registered with master.
+message NodeList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of nodes
+ repeated Node items = 2;
+}
+
+// NodeProxyOptions is the query options to a Node's proxy call.
+message NodeProxyOptions {
+ // Path is the URL path to use for the current proxy request to node.
+ optional string path = 1;
+}
+
+// A node selector represents the union of the results of one or more label queries
+// over a set of nodes; that is, it represents the OR of the selectors represented
+// by the node selector terms.
+message NodeSelector {
+ // Required. A list of node selector terms. The terms are ORed.
+ repeated NodeSelectorTerm nodeSelectorTerms = 1;
+}
+
+// A node selector requirement is a selector that contains values, a key, and an operator
+// that relates the key and values.
+message NodeSelectorRequirement {
+ // The label key that the selector applies to.
+ optional string key = 1;
+
+ // Represents a key's relationship to a set of values.
+ // Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
+ optional string operator = 2;
+
+ // 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.
+ repeated string values = 3;
+}
+
+// A null or empty node selector term matches no objects.
+message NodeSelectorTerm {
+ // Required. A list of node selector requirements. The requirements are ANDed.
+ repeated NodeSelectorRequirement matchExpressions = 1;
+}
+
+// NodeSpec describes the attributes that a node is created with.
+message NodeSpec {
+ // PodCIDR represents the pod IP range assigned to the node.
+ optional string podCIDR = 1;
+
+ // External ID of the node assigned by some machine database (e.g. a cloud provider).
+ // Deprecated.
+ optional string externalID = 2;
+
+ // ID of the node assigned by the cloud provider in the format: <ProviderName>://<ProviderSpecificNodeID>
+ optional string providerID = 3;
+
+ // Unschedulable controls node schedulability of new pods. By default, node is schedulable.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#manual-node-administration"`
+ optional bool unschedulable = 4;
+}
+
+// NodeStatus is information about the current status of a node.
+message NodeStatus {
+ // Capacity represents the total resources of a node.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity for more details.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> capacity = 1;
+
+ // Allocatable represents the resources of a node that are available for scheduling.
+ // Defaults to Capacity.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> allocatable = 2;
+
+ // NodePhase is the recently observed lifecycle phase of the node.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-phase
+ optional string phase = 3;
+
+ // Conditions is an array of current observed node conditions.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-condition
+ repeated NodeCondition conditions = 4;
+
+ // List of addresses reachable to the node.
+ // Queried from cloud provider, if available.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-addresses
+ repeated NodeAddress addresses = 5;
+
+ // Endpoints of daemons running on the Node.
+ optional NodeDaemonEndpoints daemonEndpoints = 6;
+
+ // Set of ids/uuids to uniquely identify the node.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-info
+ optional NodeSystemInfo nodeInfo = 7;
+
+ // List of container images on this node
+ repeated ContainerImage images = 8;
+
+ // List of attachable volumes in use (mounted) by the node.
+ repeated string volumesInUse = 9;
+
+ // List of volumes that are attached to the node.
+ repeated AttachedVolume volumesAttached = 10;
+}
+
+// NodeSystemInfo is a set of ids/uuids to uniquely identify the node.
+message NodeSystemInfo {
+ // Machine ID reported by the node.
+ optional string machineID = 1;
+
+ // System UUID reported by the node.
+ optional string systemUUID = 2;
+
+ // Boot ID reported by the node.
+ optional string bootID = 3;
+
+ // Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64).
+ optional string kernelVersion = 4;
+
+ // OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).
+ optional string osImage = 5;
+
+ // ContainerRuntime Version reported by the node through runtime remote API (e.g. docker://1.5.0).
+ optional string containerRuntimeVersion = 6;
+
+ // Kubelet Version reported by the node.
+ optional string kubeletVersion = 7;
+
+ // KubeProxy Version reported by the node.
+ optional string kubeProxyVersion = 8;
+
+ // The Operating System reported by the node
+ optional string operatingSystem = 9;
+
+ // The Architecture reported by the node
+ optional string architecture = 10;
+}
+
+// ObjectFieldSelector selects an APIVersioned field of an object.
+message ObjectFieldSelector {
+ // Version of the schema the FieldPath is written in terms of, defaults to "v1".
+ optional string apiVersion = 1;
+
+ // Path of the field to select in the specified API version.
+ optional string fieldPath = 2;
+}
+
+// ObjectMeta is metadata that all persisted resources must have, which includes all objects
+// users must create.
+message ObjectMeta {
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#idempotency
+ optional string generateName = 2;
+
+ // Namespace defines the space within 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://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ optional string namespace = 3;
+
+ // SelfLink is a URL representing this object.
+ // Populated by the system.
+ // Read-only.
+ optional string selfLink = 4;
+
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ optional string uid = 5;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ optional string resourceVersion = 6;
+
+ // A sequence number representing a specific generation of the desired state.
+ // Populated by the system. Read-only.
+ optional int64 generation = 7;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time creationTimestamp = 8;
+
+ // 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 will be deleted (no longer visible from
+ // resource lists, and not reachable by name) after the time in this field. Once 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. Once the resource is deleted in the API, the Kubelet
+ // will send a hard termination signal to the container.
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time deletionTimestamp = 9;
+
+ // 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.
+ optional int64 deletionGracePeriodSeconds = 10;
+
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/labels.md
+ // TODO: replace map[string]string with labels.LabelSet type
+ map<string, string> labels = 11;
+
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/annotations.md
+ map<string, string> annotations = 12;
+
+ // 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.
+ repeated OwnerReference ownerReferences = 13;
+
+ // 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.
+ repeated string finalizers = 14;
+}
+
+// ObjectReference contains enough information to let you inspect or modify the referred object.
+message ObjectReference {
+ // Kind of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional string kind = 1;
+
+ // Namespace of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ optional string namespace = 2;
+
+ // Name of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 3;
+
+ // UID of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ optional string uid = 4;
+
+ // API version of the referent.
+ optional string apiVersion = 5;
+
+ // Specific resourceVersion to which this reference is made, if any.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ optional string resourceVersion = 6;
+
+ // 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.
+ // TODO: this design is not final and this field is subject to change in the future.
+ optional string fieldPath = 7;
+}
+
+// OwnerReference contains enough information to let you identify an owning
+// object. Currently, an owning object must be in the same namespace, so there
+// is no namespace field.
+message OwnerReference {
+ // API version of the referent.
+ optional string apiVersion = 5;
+
+ // Kind of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional string kind = 1;
+
+ // Name of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 3;
+
+ // UID of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ optional string uid = 4;
+
+ // If true, this reference points to the managing controller.
+ optional bool controller = 6;
+}
+
+// PersistentVolume (PV) is a storage resource provisioned by an administrator.
+// It is analogous to a node.
+// More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md
+message PersistentVolume {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines a specification of a persistent volume owned by the cluster.
+ // Provisioned by an administrator.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes
+ optional PersistentVolumeSpec spec = 2;
+
+ // Status represents the current information/status for the persistent volume.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes
+ optional PersistentVolumeStatus status = 3;
+}
+
+// PersistentVolumeClaim is a user's request for and claim to a persistent volume
+message PersistentVolumeClaim {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the desired characteristics of a volume requested by a pod author.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ optional PersistentVolumeClaimSpec spec = 2;
+
+ // Status represents the current information/status of a persistent volume claim.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ optional PersistentVolumeClaimStatus status = 3;
+}
+
+// PersistentVolumeClaimList is a list of PersistentVolumeClaim items.
+message PersistentVolumeClaimList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // A list of persistent volume claims.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ repeated PersistentVolumeClaim items = 2;
+}
+
+// PersistentVolumeClaimSpec describes the common attributes of storage devices
+// and allows a Source for provider-specific attributes
+message PersistentVolumeClaimSpec {
+ // AccessModes contains the desired access modes the volume should have.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1
+ repeated string accessModes = 1;
+
+ // A label query over volumes to consider for binding.
+ optional k8s.io.kubernetes.pkg.api.unversioned.LabelSelector selector = 4;
+
+ // Resources represents the minimum resources the volume should have.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources
+ optional ResourceRequirements resources = 2;
+
+ // VolumeName is the binding reference to the PersistentVolume backing this claim.
+ optional string volumeName = 3;
+}
+
+// PersistentVolumeClaimStatus is the current status of a persistent volume claim.
+message PersistentVolumeClaimStatus {
+ // Phase represents the current phase of PersistentVolumeClaim.
+ optional string phase = 1;
+
+ // AccessModes contains the actual access modes the volume backing the PVC has.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1
+ repeated string accessModes = 2;
+
+ // Represents the actual resources of the underlying volume.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> capacity = 3;
+}
+
+// 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).
+message PersistentVolumeClaimVolumeSource {
+ // ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ optional string claimName = 1;
+
+ // Will force the ReadOnly setting in VolumeMounts.
+ // Default false.
+ optional bool readOnly = 2;
+}
+
+// PersistentVolumeList is a list of PersistentVolume items.
+message PersistentVolumeList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of persistent volumes.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md
+ repeated PersistentVolume items = 2;
+}
+
+// PersistentVolumeSource is similar to VolumeSource but meant for the
+// administrator who creates PVs. Exactly one of its members must be set.
+message PersistentVolumeSource {
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ optional GCEPersistentDiskVolumeSource gcePersistentDisk = 1;
+
+ // AWSElasticBlockStore represents an AWS Disk resource that is attached to a
+ // kubelet's host machine and then exposed to the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ optional AWSElasticBlockStoreVolumeSource awsElasticBlockStore = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
+ optional HostPathVolumeSource hostPath = 3;
+
+ // Glusterfs represents a Glusterfs volume that is attached to a host and
+ // exposed to the pod. Provisioned by an admin.
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md
+ optional GlusterfsVolumeSource glusterfs = 4;
+
+ // NFS represents an NFS mount on the host. Provisioned by an admin.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ optional NFSVolumeSource nfs = 5;
+
+ // RBD represents a Rados Block Device mount on the host that shares a pod's lifetime.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md
+ optional RBDVolumeSource rbd = 6;
+
+ // 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.
+ optional ISCSIVolumeSource iscsi = 7;
+
+ // Cinder represents a cinder volume attached and mounted on kubelets host machine
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ optional CinderVolumeSource cinder = 8;
+
+ // CephFS represents a Ceph FS mount on the host that shares a pod's lifetime
+ optional CephFSVolumeSource cephfs = 9;
+
+ // FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
+ optional FCVolumeSource fc = 10;
+
+ // 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
+ optional FlockerVolumeSource flocker = 11;
+
+ // FlexVolume represents a generic volume resource that is
+ // provisioned/attached using a exec based plugin. This is an
+ // alpha feature and may change in future.
+ optional FlexVolumeSource flexVolume = 12;
+
+ // AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
+ optional AzureFileVolumeSource azureFile = 13;
+
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ optional VsphereVirtualDiskVolumeSource vsphereVolume = 14;
+}
+
+// PersistentVolumeSpec is the specification of a persistent volume.
+message PersistentVolumeSpec {
+ // A description of the persistent volume's resources and capacity.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> capacity = 1;
+
+ // The actual volume backing the persistent volume.
+ optional PersistentVolumeSource persistentVolumeSource = 2;
+
+ // AccessModes contains all ways the volume can be mounted.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes
+ repeated string accessModes = 3;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#binding
+ optional ObjectReference claimRef = 4;
+
+ // What happens to a persistent volume when released from its claim.
+ // Valid options are Retain (default) and Recycle.
+ // Recyling must be supported by the volume plugin underlying this persistent volume.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#recycling-policy
+ optional string persistentVolumeReclaimPolicy = 5;
+}
+
+// PersistentVolumeStatus is the current status of a persistent volume.
+message PersistentVolumeStatus {
+ // Phase indicates if a volume is available, bound to a claim, or released by a claim.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#phase
+ optional string phase = 1;
+
+ // A human-readable message indicating details about why the volume is in this state.
+ optional string message = 2;
+
+ // Reason is a brief CamelCase string that describes any failure and is meant
+ // for machine parsing and tidy display in the CLI.
+ optional string reason = 3;
+}
+
+// Pod is a collection of containers that can run on a host. This resource is created
+// by clients and scheduled onto hosts.
+message Pod {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior of the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional PodSpec spec = 2;
+
+ // Most recently observed status of the pod.
+ // This data may not be up to date.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional PodStatus status = 3;
+}
+
+// Pod affinity is a group of inter pod affinity scheduling rules.
+message PodAffinity {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ repeated PodAffinityTerm requiredDuringSchedulingIgnoredDuringExecution = 1;
+
+ // 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.
+ repeated WeightedPodAffinityTerm preferredDuringSchedulingIgnoredDuringExecution = 2;
+}
+
+// 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 <topologyKey> tches that of any node on which
+// a pod of the set of pods is running
+message PodAffinityTerm {
+ // A label query over a set of resources, in this case pods.
+ optional k8s.io.kubernetes.pkg.api.unversioned.LabelSelector labelSelector = 1;
+
+ // namespaces specifies which namespaces the labelSelector applies to (matches against);
+ // nil list means "this pod's namespace," empty list means "all namespaces"
+ // The json tag here is not "omitempty" since we need to distinguish nil and empty.
+ // See https://golang.org/pkg/encoding/json/#Marshal for more details.
+ repeated string namespaces = 2;
+
+ // 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.
+ // For PreferredDuringScheduling pod anti-affinity, empty topologyKey is interpreted as "all topologies"
+ // ("all topologies" here means all the topologyKeys indicated by scheduler command-line argument --failure-domains);
+ // for affinity and for RequiredDuringScheduling pod anti-affinity, empty topologyKey is not allowed.
+ optional string topologyKey = 3;
+}
+
+// Pod anti affinity is a group of inter pod anti affinity scheduling rules.
+message PodAntiAffinity {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ repeated PodAffinityTerm requiredDuringSchedulingIgnoredDuringExecution = 1;
+
+ // 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.
+ repeated WeightedPodAffinityTerm preferredDuringSchedulingIgnoredDuringExecution = 2;
+}
+
+// PodAttachOptions is the query options to a Pod's remote attach call.
+// ---
+// TODO: merge w/ PodExecOptions below for stdin, stdout, etc
+// and also when we cut V2, we should export a "StreamOptions" or somesuch that contains Stdin, Stdout, Stder and TTY
+message PodAttachOptions {
+ // Stdin if true, redirects the standard input stream of the pod for this call.
+ // Defaults to false.
+ optional bool stdin = 1;
+
+ // Stdout if true indicates that stdout is to be redirected for the attach call.
+ // Defaults to true.
+ optional bool stdout = 2;
+
+ // Stderr if true indicates that stderr is to be redirected for the attach call.
+ // Defaults to true.
+ optional bool stderr = 3;
+
+ // TTY 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.
+ optional bool tty = 4;
+
+ // The container in which to execute the command.
+ // Defaults to only container if there is only one container in the pod.
+ optional string container = 5;
+}
+
+// PodCondition contains details for the current condition of this pod.
+message PodCondition {
+ // Type is the type of the condition.
+ // Currently only Ready.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ optional string type = 1;
+
+ // Status is the status of the condition.
+ // Can be True, False, Unknown.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ optional string status = 2;
+
+ // Last time we probed the condition.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastProbeTime = 3;
+
+ // Last time the condition transitioned from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // Unique, one-word, CamelCase reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human-readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// PodExecOptions is the query options to a Pod's remote exec call.
+// ---
+// TODO: This is largely identical to PodAttachOptions above, make sure they stay in sync and see about merging
+// and also when we cut V2, we should export a "StreamOptions" or somesuch that contains Stdin, Stdout, Stder and TTY
+message PodExecOptions {
+ // Redirect the standard input stream of the pod for this call.
+ // Defaults to false.
+ optional bool stdin = 1;
+
+ // Redirect the standard output stream of the pod for this call.
+ // Defaults to true.
+ optional bool stdout = 2;
+
+ // Redirect the standard error stream of the pod for this call.
+ // Defaults to true.
+ optional bool stderr = 3;
+
+ // TTY if true indicates that a tty will be allocated for the exec call.
+ // Defaults to false.
+ optional bool tty = 4;
+
+ // Container in which to execute the command.
+ // Defaults to only container if there is only one container in the pod.
+ optional string container = 5;
+
+ // Command is the remote command to execute. argv array. Not executed within a shell.
+ repeated string command = 6;
+}
+
+// PodList is a list of Pods.
+message PodList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of pods.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pods.md
+ repeated Pod items = 2;
+}
+
+// PodLogOptions is the query options for a Pod's logs REST call.
+message PodLogOptions {
+ // The container for which to stream logs. Defaults to only container if there is one container in the pod.
+ optional string container = 1;
+
+ // Follow the log stream of the pod. Defaults to false.
+ optional bool follow = 2;
+
+ // Return previous terminated container logs. Defaults to false.
+ optional bool previous = 3;
+
+ // A relative time in seconds before the current time from which to show logs. If this value
+ // precedes the time a pod was started, only logs since the pod start will be returned.
+ // If this value is in the future, no logs will be returned.
+ // Only one of sinceSeconds or sinceTime may be specified.
+ optional int64 sinceSeconds = 4;
+
+ // An RFC3339 timestamp from which to show logs. If this value
+ // precedes the time a pod was started, only logs since the pod start will be returned.
+ // If this value is in the future, no logs will be returned.
+ // Only one of sinceSeconds or sinceTime may be specified.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time sinceTime = 5;
+
+ // If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line
+ // of log output. Defaults to false.
+ optional bool timestamps = 6;
+
+ // If set, the number of lines from the end of the logs to show. If not specified,
+ // logs are shown from the creation of the container or sinceSeconds or sinceTime
+ optional int64 tailLines = 7;
+
+ // If set, the number of bytes to read from the server before terminating the
+ // log output. This may not display a complete final line of logging, and may return
+ // slightly more or slightly less than the specified limit.
+ optional int64 limitBytes = 8;
+}
+
+// PodProxyOptions is the query options to a Pod's proxy call.
+message PodProxyOptions {
+ // Path is the URL path to use for the current proxy request to pod.
+ optional string path = 1;
+}
+
+// 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.
+message PodSecurityContext {
+ // 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.
+ optional SELinuxOptions seLinuxOptions = 1;
+
+ // 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.
+ optional int64 runAsUser = 2;
+
+ // 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.
+ optional bool runAsNonRoot = 3;
+
+ // 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.
+ repeated int64 supplementalGroups = 4;
+
+ // 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.
+ optional int64 fsGroup = 5;
+}
+
+// PodSpec is a description of a pod.
+message PodSpec {
+ // List of volumes that can be mounted by containers belonging to the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md
+ repeated Volume volumes = 1;
+
+ // 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.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md
+ repeated Container containers = 2;
+
+ // Restart policy for all containers within the pod.
+ // One of Always, OnFailure, Never.
+ // Default to Always.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#restartpolicy
+ optional string restartPolicy = 3;
+
+ // 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 delete immediately.
+ // 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.
+ optional int64 terminationGracePeriodSeconds = 4;
+
+ // 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.
+ optional int64 activeDeadlineSeconds = 5;
+
+ // Set DNS policy for containers within the pod.
+ // One of 'ClusterFirst' or 'Default'.
+ // Defaults to "ClusterFirst".
+ optional string dnsPolicy = 6;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/node-selection/README.md
+ map<string, string> nodeSelector = 7;
+
+ // ServiceAccountName is the name of the ServiceAccount to use to run this pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md
+ optional string serviceAccountName = 8;
+
+ // DeprecatedServiceAccount is a depreciated alias for ServiceAccountName.
+ // Deprecated: Use serviceAccountName instead.
+ optional string serviceAccount = 9;
+
+ // 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.
+ optional string nodeName = 10;
+
+ // 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.
+ optional bool hostNetwork = 11;
+
+ // Use the host's pid namespace.
+ // Optional: Default to false.
+ optional bool hostPID = 12;
+
+ // Use the host's ipc namespace.
+ // Optional: Default to false.
+ optional bool hostIPC = 13;
+
+ // SecurityContext holds pod-level security attributes and common container settings.
+ // Optional: Defaults to empty. See type description for default values of each field.
+ optional PodSecurityContext securityContext = 14;
+
+ // 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. For example,
+ // in the case of docker, only DockerConfig type secrets are honored.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#specifying-imagepullsecrets-on-a-pod
+ repeated LocalObjectReference imagePullSecrets = 15;
+
+ // Specifies the hostname of the Pod
+ // If not specified, the pod's hostname will be set to a system-defined value.
+ optional string hostname = 16;
+
+ // If specified, the fully qualified Pod hostname will be "<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>".
+ // If not specified, the pod will not have a domainname at all.
+ optional string subdomain = 17;
+}
+
+// PodStatus represents information about the status of a pod. Status may trail the actual
+// state of a system.
+message PodStatus {
+ // Current condition of the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-phase
+ optional string phase = 1;
+
+ // Current service state of pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ repeated PodCondition conditions = 2;
+
+ // A human readable message indicating details about why the pod is in this condition.
+ optional string message = 3;
+
+ // A brief CamelCase message indicating details about why the pod is in this state.
+ // e.g. 'OutOfDisk'
+ optional string reason = 4;
+
+ // IP address of the host to which the pod is assigned. Empty if not yet scheduled.
+ optional string hostIP = 5;
+
+ // IP address allocated to the pod. Routable at least within the cluster.
+ // Empty if not yet allocated.
+ optional string podIP = 6;
+
+ // 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.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startTime = 7;
+
+ // The list has one entry per container in the manifest. Each entry is currently the output
+ // of `docker inspect`.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-statuses
+ repeated ContainerStatus containerStatuses = 8;
+}
+
+// PodStatusResult is a wrapper for PodStatus returned by kubelet that can be encode/decoded
+message PodStatusResult {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Most recently observed status of the pod.
+ // This data may not be up to date.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional PodStatus status = 2;
+}
+
+// PodTemplate describes a template for creating copies of a predefined pod.
+message PodTemplate {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Template defines the pods that will be created from this pod template.
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional PodTemplateSpec template = 2;
+}
+
+// PodTemplateList is a list of PodTemplates.
+message PodTemplateList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of pod templates
+ repeated PodTemplate items = 2;
+}
+
+// PodTemplateSpec describes the data a pod should have when created from a template
+message PodTemplateSpec {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior of the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional PodSpec spec = 2;
+}
+
+// Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
+message Preconditions {
+ // Specifies the target UID.
+ optional string uid = 1;
+}
+
+// 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).
+message PreferredSchedulingTerm {
+ // Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
+ optional int32 weight = 1;
+
+ // A node selector term, associated with the corresponding weight.
+ optional NodeSelectorTerm preference = 2;
+}
+
+// Probe describes a health check to be performed against a container to determine whether it is
+// alive or ready to receive traffic.
+message Probe {
+ // The action taken to determine the health of a container
+ optional Handler handler = 1;
+
+ // Number of seconds after the container has started before liveness probes are initiated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ optional int32 initialDelaySeconds = 2;
+
+ // Number of seconds after which the probe times out.
+ // Defaults to 1 second. Minimum value is 1.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ optional int32 timeoutSeconds = 3;
+
+ // How often (in seconds) to perform the probe.
+ // Default to 10 seconds. Minimum value is 1.
+ optional int32 periodSeconds = 4;
+
+ // Minimum consecutive successes for the probe to be considered successful after having failed.
+ // Defaults to 1. Must be 1 for liveness. Minimum value is 1.
+ optional int32 successThreshold = 5;
+
+ // Minimum consecutive failures for the probe to be considered failed after having succeeded.
+ // Defaults to 3. Minimum value is 1.
+ optional int32 failureThreshold = 6;
+}
+
+// Represents a Rados Block Device mount that lasts the lifetime of a pod.
+// RBD volumes support ownership management and SELinux relabeling.
+message RBDVolumeSource {
+ // A collection of Ceph monitors.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ repeated string monitors = 1;
+
+ // The rados image name.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ optional string image = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#rbd
+ // TODO: how do we prevent errors in the filesystem from compromising the machine
+ optional string fsType = 3;
+
+ // The rados pool name.
+ // Default is rbd.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it.
+ optional string pool = 4;
+
+ // The rados user name.
+ // Default is admin.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ optional string user = 5;
+
+ // Keyring is the path to key ring for RBDUser.
+ // Default is /etc/ceph/keyring.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ optional string keyring = 6;
+
+ // SecretRef is name of the authentication secret for RBDUser. If provided
+ // overrides keyring.
+ // Default is nil.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ optional LocalObjectReference secretRef = 7;
+
+ // ReadOnly here will force the ReadOnly setting in VolumeMounts.
+ // Defaults to false.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ optional bool readOnly = 8;
+}
+
+// RangeAllocation is not a public type.
+message RangeAllocation {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Range is string that identifies the range represented by 'data'.
+ optional string range = 2;
+
+ // Data is a bit array containing all allocated addresses in the previous segment.
+ optional bytes data = 3;
+}
+
+// ReplicationController represents the configuration of a replication controller.
+message ReplicationController {
+ // If the Labels of a ReplicationController are empty, they are defaulted to
+ // be the same as the Pod(s) that the replication controller manages.
+ // Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the specification of the desired behavior of the replication controller.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ReplicationControllerSpec spec = 2;
+
+ // Status is the most recently observed status of the replication controller.
+ // This data may be out of date by some window of time.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ReplicationControllerStatus status = 3;
+}
+
+// ReplicationControllerList is a collection of replication controllers.
+message ReplicationControllerList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of replication controllers.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md
+ repeated ReplicationController items = 2;
+}
+
+// ReplicationControllerSpec is the specification of a replication controller.
+message ReplicationControllerSpec {
+ // Replicas is the number of desired replicas.
+ // This is a pointer to distinguish between explicit zero and unspecified.
+ // Defaults to 1.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ optional int32 replicas = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ map<string, string> selector = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ optional PodTemplateSpec template = 3;
+}
+
+// ReplicationControllerStatus represents the current status of a replication
+// controller.
+message ReplicationControllerStatus {
+ // Replicas is the most recently oberved number of replicas.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ optional int32 replicas = 1;
+
+ // The number of pods that have labels matching the labels of the pod template of the replication controller.
+ optional int32 fullyLabeledReplicas = 2;
+
+ // ObservedGeneration reflects the generation of the most recently observed replication controller.
+ optional int64 observedGeneration = 3;
+}
+
+// ResourceFieldSelector represents container resources (cpu, memory) and their output format
+message ResourceFieldSelector {
+ // Container name: required for volumes, optional for env vars
+ optional string containerName = 1;
+
+ // Required: resource to select
+ optional string resource = 2;
+
+ // Specifies the output format of the exposed resources, defaults to "1"
+ optional k8s.io.kubernetes.pkg.api.resource.Quantity divisor = 3;
+}
+
+// ResourceQuota sets aggregate quota restrictions enforced per namespace
+message ResourceQuota {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the desired quota.
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ResourceQuotaSpec spec = 2;
+
+ // Status defines the actual enforced quota and its current usage.
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ResourceQuotaStatus status = 3;
+}
+
+// ResourceQuotaList is a list of ResourceQuota items.
+message ResourceQuotaList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of ResourceQuota objects.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ repeated ResourceQuota items = 2;
+}
+
+// ResourceQuotaSpec defines the desired hard limits to enforce for Quota.
+message ResourceQuotaSpec {
+ // Hard is the set of desired hard limits for each named resource.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> hard = 1;
+
+ // A collection of filters that must match each object tracked by a quota.
+ // If not specified, the quota matches all objects.
+ repeated string scopes = 2;
+}
+
+// ResourceQuotaStatus defines the enforced hard limits and observed use.
+message ResourceQuotaStatus {
+ // Hard is the set of enforced hard limits for each named resource.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> hard = 1;
+
+ // Used is the current observed total usage of the resource in the namespace.
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> used = 2;
+}
+
+// ResourceRequirements describes the compute resource requirements.
+message ResourceRequirements {
+ // Limits describes the maximum amount of compute resources allowed.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> limits = 1;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications
+ map<string, k8s.io.kubernetes.pkg.api.resource.Quantity> requests = 2;
+}
+
+// SELinuxOptions are the labels to be applied to the container
+message SELinuxOptions {
+ // User is a SELinux user label that applies to the container.
+ optional string user = 1;
+
+ // Role is a SELinux role label that applies to the container.
+ optional string role = 2;
+
+ // Type is a SELinux type label that applies to the container.
+ optional string type = 3;
+
+ // Level is SELinux level label that applies to the container.
+ optional string level = 4;
+}
+
+// Secret holds secret data of a certain type. The total bytes of the values in
+// the Data field must be less than MaxSecretSize bytes.
+message Secret {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Data contains the secret data. Each key must be a valid DNS_SUBDOMAIN
+ // or leading dot followed by valid DNS_SUBDOMAIN.
+ // 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
+ map<string, bytes> data = 2;
+
+ // Used to facilitate programmatic handling of secret data.
+ optional string type = 3;
+}
+
+// SecretKeySelector selects a key of a Secret.
+message SecretKeySelector {
+ // The name of the secret in the pod's namespace to select from.
+ optional LocalObjectReference localObjectReference = 1;
+
+ // The key of the secret to select from. Must be a valid secret key.
+ optional string key = 2;
+}
+
+// SecretList is a list of Secret.
+message SecretList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of secret objects.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md
+ repeated Secret items = 2;
+}
+
+// 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.
+message SecretVolumeSource {
+ // Name of the secret in the pod's namespace to use.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets
+ optional string secretName = 1;
+
+ // 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. Paths must be relative and may not contain
+ // the '..' path or start with '..'.
+ repeated KeyToPath items = 2;
+}
+
+// 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.
+message SecurityContext {
+ // The capabilities to add/drop when running containers.
+ // Defaults to the default set of capabilities granted by the container runtime.
+ optional Capabilities capabilities = 1;
+
+ // Run container in privileged mode.
+ // Processes in privileged containers are essentially equivalent to root on the host.
+ // Defaults to false.
+ optional bool privileged = 2;
+
+ // 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.
+ optional SELinuxOptions seLinuxOptions = 3;
+
+ // 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.
+ optional int64 runAsUser = 4;
+
+ // 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.
+ optional bool runAsNonRoot = 5;
+
+ // Whether this container has a read-only root filesystem.
+ // Default is false.
+ optional bool readOnlyRootFilesystem = 6;
+}
+
+// SerializedReference is a reference to serialized object.
+message SerializedReference {
+ // The reference to an object in the system.
+ optional ObjectReference reference = 1;
+}
+
+// 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.
+message Service {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Spec defines the behavior of a service.
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ServiceSpec spec = 2;
+
+ // Most recently observed status of the service.
+ // Populated by the system.
+ // Read-only.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ServiceStatus status = 3;
+}
+
+// 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
+message ServiceAccount {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional ObjectMeta metadata = 1;
+
+ // Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md
+ repeated ObjectReference secrets = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md#manually-specifying-an-imagepullsecret
+ repeated LocalObjectReference imagePullSecrets = 3;
+}
+
+// ServiceAccountList is a list of ServiceAccount objects
+message ServiceAccountList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of ServiceAccounts.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md#service-accounts
+ repeated ServiceAccount items = 2;
+}
+
+// ServiceList holds a list of services.
+message ServiceList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of services
+ repeated Service items = 2;
+}
+
+// ServicePort contains information on service's port.
+message ServicePort {
+ // The name of this port within the service. This must be a DNS_LABEL.
+ // All ports within a ServiceSpec must have unique names. This maps to
+ // the 'Name' field in EndpointPort objects.
+ // Optional if only one ServicePort is defined on this service.
+ optional string name = 1;
+
+ // The IP protocol for this port. Supports "TCP" and "UDP".
+ // Default is TCP.
+ optional string protocol = 2;
+
+ // The port that will be exposed by this service.
+ optional int32 port = 3;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#defining-a-service
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString targetPort = 4;
+
+ // The port on each node on which this service is exposed when type=NodePort or LoadBalancer.
+ // Usually assigned by the system. If specified, it will be allocated to the service
+ // if unused or else creation of the service will fail.
+ // Default is to auto-allocate a port if the ServiceType of this Service requires one.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#type--nodeport
+ optional int32 nodePort = 5;
+}
+
+// ServiceProxyOptions is the query options to a Service's proxy call.
+message ServiceProxyOptions {
+ // Path 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.
+ optional string path = 1;
+}
+
+// ServiceSpec describes the attributes that a user creates on a service.
+message ServiceSpec {
+ // The list of ports that are exposed by this service.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ repeated ServicePort ports = 1;
+
+ // This service will route traffic to pods having labels matching this selector.
+ // Label keys and values that must match in order to receive traffic for this service.
+ // If empty, all pods are selected, if not specified, endpoints must be manually specified.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#overview
+ map<string, string> selector = 2;
+
+ // ClusterIP is usually assigned by the master and is the IP address of the service.
+ // If specified, it will be allocated to the service if it is unused
+ // or else creation of the service will fail.
+ // Valid values are None, empty string (""), or a valid IP address.
+ // 'None' can be specified for a headless service when proxying is not required.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ optional string clusterIP = 3;
+
+ // Type of exposed service. Must be ClusterIP, NodePort, or LoadBalancer.
+ // Defaults to ClusterIP.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#external-services
+ optional string type = 4;
+
+ // 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. A previous form of this
+ // functionality exists as the deprecatedPublicIPs field. When using this
+ // field, callers should also clear the deprecatedPublicIPs field.
+ repeated string externalIPs = 5;
+
+ // deprecatedPublicIPs is deprecated and replaced by the externalIPs field
+ // with almost the exact same semantics. This field is retained in the v1
+ // API for compatibility until at least 8/20/2016. It will be removed from
+ // any new API revisions. If both deprecatedPublicIPs *and* externalIPs are
+ // set, deprecatedPublicIPs is used.
+ // +genconversion=false
+ repeated string deprecatedPublicIPs = 6;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ optional string sessionAffinity = 7;
+
+ // Only applies to Service Type: LoadBalancer
+ // LoadBalancer will get created with the IP specified in this field.
+ // 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.
+ optional string loadBalancerIP = 8;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/services-firewalls.md
+ repeated string loadBalancerSourceRanges = 9;
+}
+
+// ServiceStatus represents the current status of a service.
+message ServiceStatus {
+ // LoadBalancer contains the current status of the load-balancer,
+ // if one is present.
+ optional LoadBalancerStatus loadBalancer = 1;
+}
+
+// TCPSocketAction describes an action based on opening a socket
+message TCPSocketAction {
+ // 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.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString port = 1;
+}
+
+// The node this Taint is attached to has the effect "effect" on
+// any pod that that does not tolerate the Taint.
+message Taint {
+ // Required. The taint key to be applied to a node.
+ optional string key = 1;
+
+ // Required. The taint value corresponding to the taint key.
+ optional string value = 2;
+
+ // Required. The effect of the taint on pods
+ // that do not tolerate the taint.
+ // Valid effects are NoSchedule and PreferNoSchedule.
+ optional string effect = 3;
+}
+
+// The pod this Toleration is attached to tolerates any taint that matches
+// the triple <key,value,effect> using the matching operator <operator>.
+message Toleration {
+ // Required. Key is the taint key that the toleration applies to.
+ optional string key = 1;
+
+ // 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.
+ optional string operator = 2;
+
+ // Value is the taint value the toleration matches to.
+ // If the operator is Exists, the value should be empty, otherwise just a regular string.
+ optional string value = 3;
+
+ // Effect indicates the taint effect to match. Empty means match all taint effects.
+ // When specified, allowed values are NoSchedule and PreferNoSchedule.
+ optional string effect = 4;
+}
+
+// Volume represents a named volume in a pod that may be accessed by any container in the pod.
+message Volume {
+ // Volume's name.
+ // Must be a DNS_LABEL and unique within the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 1;
+
+ // VolumeSource represents the location and type of the mounted volume.
+ // If not specified, the Volume is implied to be an EmptyDir.
+ // This implied behavior is deprecated and will be removed in a future version.
+ optional VolumeSource volumeSource = 2;
+}
+
+// VolumeMount describes a mounting of a Volume within a container.
+message VolumeMount {
+ // This must match the Name of a Volume.
+ optional string name = 1;
+
+ // Mounted read-only if true, read-write otherwise (false or unspecified).
+ // Defaults to false.
+ optional bool readOnly = 2;
+
+ // Path within the container at which the volume should be mounted. Must
+ // not contain ':'.
+ optional string mountPath = 3;
+
+ // Path within the volume from which the container's volume should be mounted.
+ // Defaults to "" (volume's root).
+ optional string subPath = 4;
+}
+
+// Represents the source of a volume to mount.
+// Only one of its members may be specified.
+message VolumeSource {
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
+ // ---
+ // TODO(jonesdl) We need to restrict who can use host directory mounts and who can/can not
+ // mount host directories as read/write.
+ optional HostPathVolumeSource hostPath = 1;
+
+ // EmptyDir represents a temporary directory that shares a pod's lifetime.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir
+ optional EmptyDirVolumeSource emptyDir = 2;
+
+ // GCEPersistentDisk represents a GCE Disk resource that is attached to a
+ // kubelet's host machine and then exposed to the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ optional GCEPersistentDiskVolumeSource gcePersistentDisk = 3;
+
+ // AWSElasticBlockStore represents an AWS Disk resource that is attached to a
+ // kubelet's host machine and then exposed to the pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ optional AWSElasticBlockStoreVolumeSource awsElasticBlockStore = 4;
+
+ // GitRepo represents a git repository at a particular revision.
+ optional GitRepoVolumeSource gitRepo = 5;
+
+ // Secret represents a secret that should populate this volume.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets
+ optional SecretVolumeSource secret = 6;
+
+ // NFS represents an NFS mount on the host that shares a pod's lifetime
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ optional NFSVolumeSource nfs = 7;
+
+ // ISCSI represents an ISCSI Disk resource that is attached to a
+ // kubelet's host machine and then exposed to the pod.
+ // More info: http://releases.k8s.io/release-1.3/examples/iscsi/README.md
+ optional ISCSIVolumeSource iscsi = 8;
+
+ // Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime.
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md
+ optional GlusterfsVolumeSource glusterfs = 9;
+
+ // PersistentVolumeClaimVolumeSource represents a reference to a
+ // PersistentVolumeClaim in the same namespace.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ optional PersistentVolumeClaimVolumeSource persistentVolumeClaim = 10;
+
+ // RBD represents a Rados Block Device mount on the host that shares a pod's lifetime.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md
+ optional RBDVolumeSource rbd = 11;
+
+ // FlexVolume represents a generic volume resource that is
+ // provisioned/attached using a exec based plugin. This is an
+ // alpha feature and may change in future.
+ optional FlexVolumeSource flexVolume = 12;
+
+ // Cinder represents a cinder volume attached and mounted on kubelets host machine
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ optional CinderVolumeSource cinder = 13;
+
+ // CephFS represents a Ceph FS mount on the host that shares a pod's lifetime
+ optional CephFSVolumeSource cephfs = 14;
+
+ // Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running
+ optional FlockerVolumeSource flocker = 15;
+
+ // DownwardAPI represents downward API about the pod that should populate this volume
+ optional DownwardAPIVolumeSource downwardAPI = 16;
+
+ // FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
+ optional FCVolumeSource fc = 17;
+
+ // AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
+ optional AzureFileVolumeSource azureFile = 18;
+
+ // ConfigMap represents a configMap that should populate this volume
+ optional ConfigMapVolumeSource configMap = 19;
+
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ optional VsphereVirtualDiskVolumeSource vsphereVolume = 20;
+}
+
+// Represents a vSphere volume resource.
+message VsphereVirtualDiskVolumeSource {
+ // Path that identifies vSphere volume vmdk
+ optional string volumePath = 1;
+
+ // 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.
+ optional string fsType = 2;
+}
+
+// The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
+message WeightedPodAffinityTerm {
+ // weight associated with matching the corresponding podAffinityTerm,
+ // in the range 1-100.
+ optional int32 weight = 1;
+
+ // Required. A pod affinity term, associated with the corresponding weight.
+ optional PodAffinityTerm podAffinityTerm = 2;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/meta.go b/vendor/k8s.io/kubernetes/pkg/api/v1/meta.go
new file mode 100644
index 0000000000000000000000000000000000000000..935bd973b702a5b2938a355d45410e74c1b4d20d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/meta.go
@@ -0,0 +1,85 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/meta/metatypes"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/types"
+)
+
+func (obj *ObjectMeta) GetObjectMeta() meta.Object { return obj }
+
+// Namespace implements meta.Object for any object with an ObjectMeta typed field. Allows
+// fast, direct access to metadata fields for API objects.
+func (meta *ObjectMeta) GetNamespace() string { return meta.Namespace }
+func (meta *ObjectMeta) SetNamespace(namespace string) { meta.Namespace = namespace }
+func (meta *ObjectMeta) GetName() string { return meta.Name }
+func (meta *ObjectMeta) SetName(name string) { meta.Name = name }
+func (meta *ObjectMeta) GetGenerateName() string { return meta.GenerateName }
+func (meta *ObjectMeta) SetGenerateName(generateName string) { meta.GenerateName = generateName }
+func (meta *ObjectMeta) GetUID() types.UID { return meta.UID }
+func (meta *ObjectMeta) SetUID(uid types.UID) { meta.UID = uid }
+func (meta *ObjectMeta) GetResourceVersion() string { return meta.ResourceVersion }
+func (meta *ObjectMeta) SetResourceVersion(version string) { meta.ResourceVersion = version }
+func (meta *ObjectMeta) GetSelfLink() string { return meta.SelfLink }
+func (meta *ObjectMeta) SetSelfLink(selfLink string) { meta.SelfLink = selfLink }
+func (meta *ObjectMeta) GetCreationTimestamp() unversioned.Time { return meta.CreationTimestamp }
+func (meta *ObjectMeta) SetCreationTimestamp(creationTimestamp unversioned.Time) {
+ meta.CreationTimestamp = creationTimestamp
+}
+func (meta *ObjectMeta) GetDeletionTimestamp() *unversioned.Time { return meta.DeletionTimestamp }
+func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *unversioned.Time) {
+ meta.DeletionTimestamp = deletionTimestamp
+}
+func (meta *ObjectMeta) GetLabels() map[string]string { return meta.Labels }
+func (meta *ObjectMeta) SetLabels(labels map[string]string) { meta.Labels = labels }
+func (meta *ObjectMeta) GetAnnotations() map[string]string { return meta.Annotations }
+func (meta *ObjectMeta) SetAnnotations(annotations map[string]string) { meta.Annotations = annotations }
+func (meta *ObjectMeta) GetFinalizers() []string { return meta.Finalizers }
+func (meta *ObjectMeta) SetFinalizers(finalizers []string) { meta.Finalizers = finalizers }
+
+func (meta *ObjectMeta) GetOwnerReferences() []metatypes.OwnerReference {
+ ret := make([]metatypes.OwnerReference, len(meta.OwnerReferences))
+ for i := 0; i < len(meta.OwnerReferences); i++ {
+ ret[i].Kind = meta.OwnerReferences[i].Kind
+ ret[i].Name = meta.OwnerReferences[i].Name
+ ret[i].UID = meta.OwnerReferences[i].UID
+ ret[i].APIVersion = meta.OwnerReferences[i].APIVersion
+ if meta.OwnerReferences[i].Controller != nil {
+ value := *meta.OwnerReferences[i].Controller
+ ret[i].Controller = &value
+ }
+ }
+ return ret
+}
+
+func (meta *ObjectMeta) SetOwnerReferences(references []metatypes.OwnerReference) {
+ newReferences := make([]OwnerReference, len(references))
+ for i := 0; i < len(references); i++ {
+ newReferences[i].Kind = references[i].Kind
+ newReferences[i].Name = references[i].Name
+ newReferences[i].UID = references[i].UID
+ newReferences[i].APIVersion = references[i].APIVersion
+ if references[i].Controller != nil {
+ value := *references[i].Controller
+ newReferences[i].Controller = &value
+ }
+ }
+ meta.OwnerReferences = newReferences
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/api/v1/register.go b/vendor/k8s.io/kubernetes/pkg/api/v1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..bf07189ee47d3178cba48637fc546ed077b92df3
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/register.go
@@ -0,0 +1,94 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// GroupName is the group name use in this package
+const GroupName = ""
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ // Add the API to Scheme.
+ addKnownTypes(scheme)
+ addConversionFuncs(scheme)
+ addDefaultingFuncs(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Pod{},
+ &PodList{},
+ &PodStatusResult{},
+ &PodTemplate{},
+ &PodTemplateList{},
+ &ReplicationController{},
+ &ReplicationControllerList{},
+ &Service{},
+ &ServiceProxyOptions{},
+ &ServiceList{},
+ &Endpoints{},
+ &EndpointsList{},
+ &Node{},
+ &NodeList{},
+ &NodeProxyOptions{},
+ &Binding{},
+ &Event{},
+ &EventList{},
+ &List{},
+ &LimitRange{},
+ &LimitRangeList{},
+ &ResourceQuota{},
+ &ResourceQuotaList{},
+ &Namespace{},
+ &NamespaceList{},
+ &Secret{},
+ &SecretList{},
+ &ServiceAccount{},
+ &ServiceAccountList{},
+ &PersistentVolume{},
+ &PersistentVolumeList{},
+ &PersistentVolumeClaim{},
+ &PersistentVolumeClaimList{},
+ &DeleteOptions{},
+ &ExportOptions{},
+ &ListOptions{},
+ &PodAttachOptions{},
+ &PodLogOptions{},
+ &PodExecOptions{},
+ &PodProxyOptions{},
+ &ComponentStatus{},
+ &ComponentStatusList{},
+ &SerializedReference{},
+ &RangeAllocation{},
+ &ConfigMap{},
+ &ConfigMapList{},
+ )
+
+ // Add common types
+ scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.Status{})
+
+ // Add the watch version that applies
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/api/v1/types.generated.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/types.generated.go
index 1dc4938a89277bd912f49bb6a4f55cd6c22decad..1b6c236dbe9a352e33cd95b9c79f8bd9dc77b6ec 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -27,12 +27,11 @@ import (
codec1978 "github.com/ugorji/go/codec"
pkg3_resource "k8s.io/kubernetes/pkg/api/resource"
pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
- pkg6_runtime "k8s.io/kubernetes/pkg/runtime"
+ pkg5_runtime "k8s.io/kubernetes/pkg/runtime"
pkg1_types "k8s.io/kubernetes/pkg/types"
- pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ pkg4_intstr "k8s.io/kubernetes/pkg/util/intstr"
"reflect"
"runtime"
- pkg4_inf "speter.net/go/exp/math/dec/inf"
time "time"
)
@@ -68,12 +67,11 @@ func init() {
if false { // reference the types, but skip this branch at build/run time
var v0 pkg3_resource.Quantity
var v1 pkg2_unversioned.Time
- var v2 pkg6_runtime.RawExtension
+ var v2 pkg5_runtime.RawExtension
var v3 pkg1_types.UID
- var v4 pkg5_intstr.IntOrString
- var v5 pkg4_inf.Dec
- var v6 time.Time
- _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6
+ var v4 pkg4_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
}
}
@@ -91,7 +89,7 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [12]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Name != ""
@@ -106,9 +104,11 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[9] = x.DeletionGracePeriodSeconds != nil
yyq2[10] = len(x.Labels) != 0
yyq2[11] = len(x.Annotations) != 0
+ yyq2[12] = len(x.OwnerReferences) != 0
+ yyq2[13] = len(x.Finalizers) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(12)
+ r.EncodeArrayStart(14)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -477,6 +477,72 @@ func (x *ObjectMeta) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[12] {
+ if x.OwnerReferences == nil {
+ r.EncodeNil()
+ } else {
+ yym44 := z.EncBinary()
+ _ = yym44
+ if false {
+ } else {
+ h.encSliceOwnerReference(([]OwnerReference)(x.OwnerReferences), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[12] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ownerReferences"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.OwnerReferences == nil {
+ r.EncodeNil()
+ } else {
+ yym45 := z.EncBinary()
+ _ = yym45
+ if false {
+ } else {
+ h.encSliceOwnerReference(([]OwnerReference)(x.OwnerReferences), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[13] {
+ if x.Finalizers == nil {
+ r.EncodeNil()
+ } else {
+ yym47 := z.EncBinary()
+ _ = yym47
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Finalizers, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[13] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("finalizers"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Finalizers == nil {
+ r.EncodeNil()
+ } else {
+ yym48 := z.EncBinary()
+ _ = yym48
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Finalizers, false, e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -658,6 +724,30 @@ func (x *ObjectMeta) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.F.DecMapStringStringX(yyv19, false, d)
}
}
+ case "ownerReferences":
+ if r.TryDecodeAsNil() {
+ x.OwnerReferences = nil
+ } else {
+ yyv21 := &x.OwnerReferences
+ yym22 := z.DecBinary()
+ _ = yym22
+ if false {
+ } else {
+ h.decSliceOwnerReference((*[]OwnerReference)(yyv21), d)
+ }
+ }
+ case "finalizers":
+ if r.TryDecodeAsNil() {
+ x.Finalizers = nil
+ } else {
+ yyv23 := &x.Finalizers
+ yym24 := z.DecBinary()
+ _ = yym24
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv23, false, d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -669,16 +759,16 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj21 int
- var yyb21 bool
- var yyhl21 bool = l >= 0
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ var yyj25 int
+ var yyb25 bool
+ var yyhl25 bool = l >= 0
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -688,13 +778,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -704,13 +794,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.GenerateName = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -720,13 +810,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Namespace = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -736,13 +826,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SelfLink = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -752,13 +842,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.UID = pkg1_types.UID(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -768,13 +858,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ResourceVersion = string(r.DecodeString())
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -784,13 +874,13 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Generation = int64(r.DecodeInt(64))
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -798,26 +888,26 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.CreationTimestamp = pkg2_unversioned.Time{}
} else {
- yyv29 := &x.CreationTimestamp
- yym30 := z.DecBinary()
- _ = yym30
+ yyv33 := &x.CreationTimestamp
+ yym34 := z.DecBinary()
+ _ = yym34
if false {
- } else if z.HasExtensions() && z.DecExt(yyv29) {
- } else if yym30 {
- z.DecBinaryUnmarshal(yyv29)
- } else if !yym30 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv29)
+ } else if z.HasExtensions() && z.DecExt(yyv33) {
+ } else if yym34 {
+ z.DecBinaryUnmarshal(yyv33)
+ } else if !yym34 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv33)
} else {
- z.DecFallback(yyv29, false)
+ z.DecFallback(yyv33, false)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -830,25 +920,25 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.DeletionTimestamp == nil {
x.DeletionTimestamp = new(pkg2_unversioned.Time)
}
- yym32 := z.DecBinary()
- _ = yym32
+ yym36 := z.DecBinary()
+ _ = yym36
if false {
} else if z.HasExtensions() && z.DecExt(x.DeletionTimestamp) {
- } else if yym32 {
+ } else if yym36 {
z.DecBinaryUnmarshal(x.DeletionTimestamp)
- } else if !yym32 && z.IsJSONHandle() {
+ } else if !yym36 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.DeletionTimestamp)
} else {
z.DecFallback(x.DeletionTimestamp, false)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -861,20 +951,20 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.DeletionGracePeriodSeconds == nil {
x.DeletionGracePeriodSeconds = new(int64)
}
- yym34 := z.DecBinary()
- _ = yym34
+ yym38 := z.DecBinary()
+ _ = yym38
if false {
} else {
*((*int64)(x.DeletionGracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -882,21 +972,21 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Labels = nil
} else {
- yyv35 := &x.Labels
- yym36 := z.DecBinary()
- _ = yym36
+ yyv39 := &x.Labels
+ yym40 := z.DecBinary()
+ _ = yym40
if false {
} else {
- z.F.DecMapStringStringX(yyv35, false, d)
+ z.F.DecMapStringStringX(yyv39, false, d)
}
}
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -904,26 +994,70 @@ func (x *ObjectMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Annotations = nil
} else {
- yyv37 := &x.Annotations
- yym38 := z.DecBinary()
- _ = yym38
+ yyv41 := &x.Annotations
+ yym42 := z.DecBinary()
+ _ = yym42
+ if false {
+ } else {
+ z.F.DecMapStringStringX(yyv41, false, d)
+ }
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.OwnerReferences = nil
+ } else {
+ yyv43 := &x.OwnerReferences
+ yym44 := z.DecBinary()
+ _ = yym44
+ if false {
+ } else {
+ h.decSliceOwnerReference((*[]OwnerReference)(yyv43), d)
+ }
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Finalizers = nil
+ } else {
+ yyv45 := &x.Finalizers
+ yym46 := z.DecBinary()
+ _ = yym46
if false {
} else {
- z.F.DecMapStringStringX(yyv37, false, d)
+ z.F.DecSliceStringX(yyv45, false, d)
}
}
for {
- yyj21++
- if yyhl21 {
- yyb21 = yyj21 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb21 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb21 {
+ if yyb25 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj21-1, "")
+ z.DecStructFieldNotFound(yyj25-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -942,7 +1076,7 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [20]bool
+ var yyq2 [21]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = x.VolumeSource.HostPath != nil && x.HostPath != nil
@@ -964,9 +1098,10 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[17] = x.VolumeSource.FC != nil && x.FC != nil
yyq2[18] = x.VolumeSource.AzureFile != nil && x.AzureFile != nil
yyq2[19] = x.VolumeSource.ConfigMap != nil && x.ConfigMap != nil
+ yyq2[20] = x.VolumeSource.VsphereVolume != nil && x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(20)
+ r.EncodeArrayStart(21)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -1699,6 +1834,43 @@ func (x *Volume) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ var yyn63 bool
+ if x.VolumeSource.VsphereVolume == nil {
+ yyn63 = true
+ goto LABEL63
+ }
+ LABEL63:
+ if yyr2 || yy2arr2 {
+ if yyn63 {
+ r.EncodeNil()
+ } else {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[20] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ }
+ } else {
+ if yyq2[20] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyn63 {
+ r.EncodeNil()
+ } else {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -2032,6 +2204,20 @@ func (x *Volume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if x.VolumeSource.VsphereVolume == nil {
+ x.VolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -2043,16 +2229,16 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj24 int
- var yyb24 bool
- var yyhl24 bool = l >= 0
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ var yyj25 int
+ var yyb25 bool
+ var yyhl25 bool = l >= 0
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2065,13 +2251,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.HostPath == nil {
x.VolumeSource.HostPath = new(HostPathVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2089,13 +2275,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.EmptyDir == nil {
x.VolumeSource.EmptyDir = new(EmptyDirVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2113,13 +2299,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.GCEPersistentDisk == nil {
x.VolumeSource.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2137,13 +2323,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.AWSElasticBlockStore == nil {
x.VolumeSource.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2161,13 +2347,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.GitRepo == nil {
x.VolumeSource.GitRepo = new(GitRepoVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2185,13 +2371,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Secret == nil {
x.VolumeSource.Secret = new(SecretVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2209,13 +2395,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.NFS == nil {
x.VolumeSource.NFS = new(NFSVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2233,13 +2419,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.ISCSI == nil {
x.VolumeSource.ISCSI = new(ISCSIVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2257,13 +2443,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Glusterfs == nil {
x.VolumeSource.Glusterfs = new(GlusterfsVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2281,13 +2467,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.PersistentVolumeClaim == nil {
x.VolumeSource.PersistentVolumeClaim = new(PersistentVolumeClaimVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2305,13 +2491,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.RBD == nil {
x.VolumeSource.RBD = new(RBDVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2329,13 +2515,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.FlexVolume == nil {
x.VolumeSource.FlexVolume = new(FlexVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2353,13 +2539,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Cinder == nil {
x.VolumeSource.Cinder = new(CinderVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2377,13 +2563,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.CephFS == nil {
x.VolumeSource.CephFS = new(CephFSVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2401,13 +2587,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.Flocker == nil {
x.VolumeSource.Flocker = new(FlockerVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2425,13 +2611,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.DownwardAPI == nil {
x.VolumeSource.DownwardAPI = new(DownwardAPIVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2449,13 +2635,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.FC == nil {
x.VolumeSource.FC = new(FCVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2473,13 +2659,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.AzureFile == nil {
x.VolumeSource.AzureFile = new(AzureFileVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2497,13 +2683,13 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.VolumeSource.ConfigMap == nil {
x.VolumeSource.ConfigMap = new(ConfigMapVolumeSource)
}
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2518,18 +2704,42 @@ func (x *Volume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ if x.VolumeSource.VsphereVolume == nil {
+ x.VolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
+ } else {
+ yyb25 = r.CheckBreak()
+ }
+ if yyb25 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj24++
- if yyhl24 {
- yyb24 = yyj24 > l
+ yyj25++
+ if yyhl25 {
+ yyb25 = yyj25 > l
} else {
- yyb24 = r.CheckBreak()
+ yyb25 = r.CheckBreak()
}
- if yyb24 {
+ if yyb25 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj24-1, "")
+ z.DecStructFieldNotFound(yyj25-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -2548,7 +2758,7 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [19]bool
+ var yyq2 [20]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.HostPath != nil
@@ -2570,9 +2780,10 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[16] = x.FC != nil
yyq2[17] = x.AzureFile != nil
yyq2[18] = x.ConfigMap != nil
+ yyq2[19] = x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(19)
+ r.EncodeArrayStart(20)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -3020,6 +3231,29 @@ func (x *VolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[19] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[19] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -3290,6 +3524,17 @@ func (x *VolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -3301,16 +3546,16 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj23 int
- var yyb23 bool
- var yyhl23 bool = l >= 0
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ var yyj24 int
+ var yyb24 bool
+ var yyhl24 bool = l >= 0
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3325,13 +3570,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.HostPath.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3346,13 +3591,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.EmptyDir.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3367,13 +3612,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.GCEPersistentDisk.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3388,13 +3633,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.AWSElasticBlockStore.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3409,13 +3654,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.GitRepo.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3430,13 +3675,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Secret.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3451,13 +3696,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.NFS.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3472,13 +3717,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ISCSI.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3493,13 +3738,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Glusterfs.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3514,13 +3759,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.PersistentVolumeClaim.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3535,13 +3780,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.RBD.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3556,13 +3801,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FlexVolume.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3577,13 +3822,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Cinder.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3598,13 +3843,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.CephFS.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3619,13 +3864,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Flocker.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3640,13 +3885,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.DownwardAPI.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3661,13 +3906,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FC.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3682,13 +3927,13 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.AzureFile.CodecDecodeSelf(d)
}
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3703,18 +3948,39 @@ func (x *VolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMap.CodecDecodeSelf(d)
}
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
+ } else {
+ yyb24 = r.CheckBreak()
+ }
+ if yyb24 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj23++
- if yyhl23 {
- yyb23 = yyj23 > l
+ yyj24++
+ if yyhl24 {
+ yyb24 = yyj24 > l
} else {
- yyb23 = r.CheckBreak()
+ yyb24 = r.CheckBreak()
}
- if yyb23 {
+ if yyb24 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj23-1, "")
+ z.DecStructFieldNotFound(yyj24-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -3943,7 +4209,7 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [13]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.GCEPersistentDisk != nil
@@ -3959,9 +4225,10 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[10] = x.Flocker != nil
yyq2[11] = x.FlexVolume != nil
yyq2[12] = x.AzureFile != nil
+ yyq2[13] = x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(13)
+ r.EncodeArrayStart(14)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -4271,6 +4538,29 @@ func (x *PersistentVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[13] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[13] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -4475,6 +4765,17 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Deco
}
x.AzureFile.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -4486,16 +4787,16 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj17 int
- var yyb17 bool
- var yyhl17 bool = l >= 0
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ var yyj18 int
+ var yyb18 bool
+ var yyhl18 bool = l >= 0
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4510,13 +4811,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.GCEPersistentDisk.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4531,13 +4832,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.AWSElasticBlockStore.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4552,13 +4853,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.HostPath.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4573,13 +4874,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Glusterfs.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4594,13 +4895,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.NFS.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4615,13 +4916,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.RBD.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4636,13 +4937,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.ISCSI.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4657,13 +4958,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Cinder.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4678,13 +4979,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.CephFS.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4699,13 +5000,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.FC.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4720,13 +5021,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.Flocker.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4741,13 +5042,13 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.FlexVolume.CodecDecodeSelf(d)
}
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4762,18 +5063,39 @@ func (x *PersistentVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.De
}
x.AzureFile.CodecDecodeSelf(d)
}
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj17++
- if yyhl17 {
- yyb17 = yyj17 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb17 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb17 {
+ if yyb18 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj17-1, "")
+ z.DecStructFieldNotFound(yyj18-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -5135,7 +5457,7 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [17]bool
+ var yyq2 [18]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.Capacity) != 0
@@ -5155,9 +5477,10 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[14] = x.PersistentVolumeSource.Flocker != nil && x.Flocker != nil
yyq2[15] = x.PersistentVolumeSource.FlexVolume != nil && x.FlexVolume != nil
yyq2[16] = x.PersistentVolumeSource.AzureFile != nil && x.AzureFile != nil
+ yyq2[17] = x.PersistentVolumeSource.VsphereVolume != nil && x.VsphereVolume != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(17)
+ r.EncodeArrayStart(18)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -5743,6 +6066,43 @@ func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ var yyn54 bool
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ yyn54 = true
+ goto LABEL54
+ }
+ LABEL54:
+ if yyr2 || yy2arr2 {
+ if yyn54 {
+ r.EncodeNil()
+ } else {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[17] {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ }
+ } else {
+ if yyq2[17] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("vsphereVolume"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyn54 {
+ r.EncodeNil()
+ } else {
+ if x.VsphereVolume == nil {
+ r.EncodeNil()
+ } else {
+ x.VsphereVolume.CodecEncodeSelf(e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -6022,6 +6382,20 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decode
}
x.AzureFile.CodecDecodeSelf(d)
}
+ case "vsphereVolume":
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ x.PersistentVolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -6033,16 +6407,16 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj22 int
- var yyb22 bool
- var yyhl22 bool = l >= 0
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ var yyj23 int
+ var yyb23 bool
+ var yyhl23 bool = l >= 0
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6050,16 +6424,16 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv23 := &x.Capacity
- yyv23.CodecDecodeSelf(d)
+ yyv24 := &x.Capacity
+ yyv24.CodecDecodeSelf(d)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6067,21 +6441,21 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.AccessModes = nil
} else {
- yyv24 := &x.AccessModes
- yym25 := z.DecBinary()
- _ = yym25
+ yyv25 := &x.AccessModes
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv24), d)
+ h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv25), d)
}
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6096,13 +6470,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
}
x.ClaimRef.CodecDecodeSelf(d)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6115,13 +6489,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.GCEPersistentDisk == nil {
x.PersistentVolumeSource.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6139,13 +6513,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.AWSElasticBlockStore == nil {
x.PersistentVolumeSource.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6163,13 +6537,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.HostPath == nil {
x.PersistentVolumeSource.HostPath = new(HostPathVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6187,13 +6561,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Glusterfs == nil {
x.PersistentVolumeSource.Glusterfs = new(GlusterfsVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6211,13 +6585,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.NFS == nil {
x.PersistentVolumeSource.NFS = new(NFSVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6235,13 +6609,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.RBD == nil {
x.PersistentVolumeSource.RBD = new(RBDVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6259,13 +6633,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.ISCSI == nil {
x.PersistentVolumeSource.ISCSI = new(ISCSIVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6283,13 +6657,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Cinder == nil {
x.PersistentVolumeSource.Cinder = new(CinderVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6307,13 +6681,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.CephFS == nil {
x.PersistentVolumeSource.CephFS = new(CephFSVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6331,13 +6705,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.FC == nil {
x.PersistentVolumeSource.FC = new(FCVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6355,13 +6729,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.Flocker == nil {
x.PersistentVolumeSource.Flocker = new(FlockerVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6379,13 +6753,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.FlexVolume == nil {
x.PersistentVolumeSource.FlexVolume = new(FlexVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6403,13 +6777,13 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if x.PersistentVolumeSource.AzureFile == nil {
x.PersistentVolumeSource.AzureFile = new(AzureFileVolumeSource)
}
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -6424,18 +6798,42 @@ func (x *PersistentVolumeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Deco
}
x.AzureFile.CodecDecodeSelf(d)
}
+ if x.PersistentVolumeSource.VsphereVolume == nil {
+ x.PersistentVolumeSource.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.VsphereVolume != nil {
+ x.VsphereVolume = nil
+ }
+ } else {
+ if x.VsphereVolume == nil {
+ x.VsphereVolume = new(VsphereVirtualDiskVolumeSource)
+ }
+ x.VsphereVolume.CodecDecodeSelf(d)
+ }
for {
- yyj22++
- if yyhl22 {
- yyb22 = yyj22 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb22 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb22 {
+ if yyb23 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj22-1, "")
+ z.DecStructFieldNotFound(yyj23-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -7766,15 +8164,16 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.AccessModes) != 0
- yyq2[1] = true
- yyq2[2] = x.VolumeName != ""
+ yyq2[1] = x.Selector != nil
+ yyq2[2] = true
+ yyq2[3] = x.VolumeName != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -7821,25 +8220,60 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yy7 := &x.Resources
- yy7.CodecEncodeSelf(e)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
} else {
r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("resources"))
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.Resources
- yy9.CodecEncodeSelf(e)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
+ yy10 := &x.Resources
+ yy10.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resources"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.Resources
+ yy12.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumeName))
@@ -7848,12 +8282,12 @@ func (x *PersistentVolumeClaimSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumeName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
+ yym16 := z.EncBinary()
+ _ = yym16
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumeName))
@@ -7933,12 +8367,29 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv4), d)
}
}
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
case "resources":
if r.TryDecodeAsNil() {
x.Resources = ResourceRequirements{}
} else {
- yyv6 := &x.Resources
- yyv6.CodecDecodeSelf(d)
+ yyv8 := &x.Resources
+ yyv8.CodecDecodeSelf(d)
}
case "volumeName":
if r.TryDecodeAsNil() {
@@ -7957,16 +8408,16 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7974,21 +8425,48 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.AccessModes = nil
} else {
- yyv9 := &x.AccessModes
- yym10 := z.DecBinary()
- _ = yym10
+ yyv11 := &x.AccessModes
+ yym12 := z.DecBinary()
+ _ = yym12
if false {
} else {
- h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv9), d)
+ h.decSlicePersistentVolumeAccessMode((*[]PersistentVolumeAccessMode)(yyv11), d)
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7996,16 +8474,16 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Resources = ResourceRequirements{}
} else {
- yyv11 := &x.Resources
- yyv11.CodecDecodeSelf(d)
+ yyv15 := &x.Resources
+ yyv15.CodecDecodeSelf(d)
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -8016,17 +8494,17 @@ func (x *PersistentVolumeClaimSpec) codecDecodeSelfFromArray(l int, d *codec1978
x.VolumeName = string(r.DecodeString())
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -8974,12 +9452,16 @@ func (x *RBDVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[2] = x.FSType != ""
+ yyq2[3] = x.RBDPool != ""
+ yyq2[4] = x.RadosUser != ""
+ yyq2[5] = x.Keyring != ""
+ yyq2[6] = x.SecretRef != nil
yyq2[7] = x.ReadOnly != false
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(8)
} else {
- yynn2 = 6
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -9061,76 +9543,100 @@ func (x *RBDVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("pool"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("pool"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RBDPool))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
+ if yyq2[4] {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("user"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("user"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RadosUser))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym19 := z.EncBinary()
- _ = yym19
- if false {
+ if yyq2[5] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("keyring"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("keyring"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Keyring))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.SecretRef == nil {
- r.EncodeNil()
+ if yyq2[6] {
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
} else {
- x.SecretRef.CodecEncodeSelf(e)
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.SecretRef == nil {
- r.EncodeNil()
- } else {
- x.SecretRef.CodecEncodeSelf(e)
+ if yyq2[6] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("secretRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.SecretRef == nil {
+ r.EncodeNil()
+ } else {
+ x.SecretRef.CodecEncodeSelf(e)
+ }
}
}
if yyr2 || yy2arr2 {
@@ -11615,13 +12121,14 @@ func (x *SecretVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.SecretName != ""
+ yyq2[1] = len(x.Items) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(2)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -11657,6 +12164,39 @@ func (x *SecretVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceKeyToPath(([]KeyToPath)(x.Items), e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -11724,6 +12264,18 @@ func (x *SecretVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
} else {
x.SecretName = string(r.DecodeString())
}
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv5 := &x.Items
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv5), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -11735,16 +12287,16 @@ func (x *SecretVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -11754,18 +12306,40 @@ func (x *SecretVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.SecretName = string(r.DecodeString())
}
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv9 := &x.Items
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceKeyToPath((*[]KeyToPath)(yyv9), d)
+ }
+ }
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -13009,6 +13583,216 @@ func (x *AzureFileVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x *VsphereVirtualDiskVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.FSType != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.VolumePath))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumePath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.VolumePath))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FSType))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fsType"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FSType))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *VsphereVirtualDiskVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *VsphereVirtualDiskVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "volumePath":
+ if r.TryDecodeAsNil() {
+ x.VolumePath = ""
+ } else {
+ x.VolumePath = string(r.DecodeString())
+ }
+ case "fsType":
+ if r.TryDecodeAsNil() {
+ x.FSType = ""
+ } else {
+ x.FSType = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *VsphereVirtualDiskVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumePath = ""
+ } else {
+ x.VolumePath = string(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.FSType = ""
+ } else {
+ x.FSType = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
func (x *ConfigMapVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -13807,13 +14591,14 @@ func (x *VolumeMount) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = x.ReadOnly != false
+ yyq2[3] = x.SubPath != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 2
for _, b := range yyq2 {
@@ -13887,6 +14672,31 @@ func (x *VolumeMount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, string(x.MountPath))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.SubPath))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subPath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.SubPath))
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -13966,6 +14776,12 @@ func (x *VolumeMount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.MountPath = string(r.DecodeString())
}
+ case "subPath":
+ if r.TryDecodeAsNil() {
+ x.SubPath = ""
+ } else {
+ x.SubPath = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -13977,16 +14793,16 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -13996,13 +14812,13 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14012,13 +14828,13 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ReadOnly = bool(r.DecodeBool())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14028,18 +14844,34 @@ func (x *VolumeMount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.MountPath = string(r.DecodeString())
}
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SubPath = ""
+ } else {
+ x.SubPath = string(r.DecodeString())
+ }
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -14324,15 +15156,16 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.FieldRef != nil
- yyq2[1] = x.ConfigMapKeyRef != nil
- yyq2[2] = x.SecretKeyRef != nil
+ yyq2[1] = x.ResourceFieldRef != nil
+ yyq2[2] = x.ConfigMapKeyRef != nil
+ yyq2[3] = x.SecretKeyRef != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -14369,6 +15202,29 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceFieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
if x.ConfigMapKeyRef == nil {
r.EncodeNil()
} else {
@@ -14378,7 +15234,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("configMapKeyRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -14391,7 +15247,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
+ if yyq2[3] {
if x.SecretKeyRef == nil {
r.EncodeNil()
} else {
@@ -14401,7 +15257,7 @@ func (x *EnvVarSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("secretKeyRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -14484,6 +15340,17 @@ func (x *EnvVarSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.FieldRef.CodecDecodeSelf(d)
}
+ case "resourceFieldRef":
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
+ }
case "configMapKeyRef":
if r.TryDecodeAsNil() {
if x.ConfigMapKeyRef != nil {
@@ -14517,16 +15384,16 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14541,13 +15408,34 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.FieldRef.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14562,13 +15450,13 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.ConfigMapKeyRef.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -14584,17 +15472,17 @@ func (x *EnvVarSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.SecretKeyRef.CodecDecodeSelf(d)
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -14809,7 +15697,7 @@ func (x *ObjectFieldSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ResourceFieldSelector) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -14823,13 +15711,14 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.Name != ""
+ yyq2[0] = x.ContainerName != ""
+ yyq2[2] = true
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -14842,45 +15731,78 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContainerName))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("containerName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContainerName))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("key"))
+ r.EncodeString(codecSelferC_UTF81234, string("resource"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
+ yym8 := z.EncBinary()
+ _ = yym8
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
+ if yyq2[2] {
+ yy10 := &x.Divisor
+ yym11 := z.EncBinary()
+ _ = yym11
if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ z.EncFallback(yy10)
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
+ r.EncodeString(codecSelferC_UTF81234, string("divisor"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
+ yy12 := &x.Divisor
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ z.EncFallback(yy12)
}
}
}
@@ -14893,7 +15815,7 @@ func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14923,7 +15845,7 @@ func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14945,17 +15867,32 @@ func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decode
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "key":
+ case "containerName":
if r.TryDecodeAsNil() {
- x.Key = ""
+ x.ContainerName = ""
} else {
- x.Key = string(r.DecodeString())
+ x.ContainerName = string(r.DecodeString())
}
- case "name":
+ case "resource":
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Resource = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Resource = string(r.DecodeString())
+ }
+ case "divisor":
+ if r.TryDecodeAsNil() {
+ x.Divisor = pkg3_resource.Quantity{}
+ } else {
+ yyv6 := &x.Divisor
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -14964,62 +15901,297 @@ func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ConfigMapKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ResourceFieldSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Key = ""
+ x.ContainerName = ""
} else {
- x.Key = string(r.DecodeString())
+ x.ContainerName = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Resource = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Resource = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Divisor = pkg3_resource.Quantity{}
+ } else {
+ yyv11 := &x.Divisor
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else if !yym12 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv11)
+ } else {
+ z.DecFallback(yyv11, false)
+ }
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *SecretKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ConfigMapKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.Name != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ConfigMapKeySelector) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ConfigMapKeySelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ case "name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ConfigMapKeySelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *SecretKeySelector) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -15660,7 +16832,7 @@ func (x *HTTPGetAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
case "port":
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv5 := &x.Port
yym6 := z.DecBinary()
@@ -15739,7 +16911,7 @@ func (x *HTTPGetAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv13 := &x.Port
yym14 := z.DecBinary()
@@ -15968,7 +17140,7 @@ func (x *TCPSocketAction) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
switch yys3 {
case "port":
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv4 := &x.Port
yym5 := z.DecBinary()
@@ -16007,7 +17179,7 @@ func (x *TCPSocketAction) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Port = pkg5_intstr.IntOrString{}
+ x.Port = pkg4_intstr.IntOrString{}
} else {
yyv7 := &x.Port
yym8 := z.DecBinary()
@@ -21879,13 +23051,15 @@ func (x *Affinity) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.NodeAffinity != nil
+ yyq2[1] = x.PodAffinity != nil
+ yyq2[2] = x.PodAntiAffinity != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -21919,6 +23093,52 @@ func (x *Affinity) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PodAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAffinity.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAffinity"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAffinity.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.PodAntiAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAntiAffinity.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAntiAffinity"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodAntiAffinity == nil {
+ r.EncodeNil()
+ } else {
+ x.PodAntiAffinity.CodecEncodeSelf(e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -21991,6 +23211,28 @@ func (x *Affinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
x.NodeAffinity.CodecDecodeSelf(d)
}
+ case "podAffinity":
+ if r.TryDecodeAsNil() {
+ if x.PodAffinity != nil {
+ x.PodAffinity = nil
+ }
+ } else {
+ if x.PodAffinity == nil {
+ x.PodAffinity = new(PodAffinity)
+ }
+ x.PodAffinity.CodecDecodeSelf(d)
+ }
+ case "podAntiAffinity":
+ if r.TryDecodeAsNil() {
+ if x.PodAntiAffinity != nil {
+ x.PodAntiAffinity = nil
+ }
+ } else {
+ if x.PodAntiAffinity == nil {
+ x.PodAntiAffinity = new(PodAntiAffinity)
+ }
+ x.PodAntiAffinity.CodecDecodeSelf(d)
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -22002,16 +23244,16 @@ func (x *Affinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -22026,23 +23268,65 @@ func (x *Affinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.NodeAffinity.CodecDecodeSelf(d)
}
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.PodAffinity != nil {
+ x.PodAffinity = nil
+ }
+ } else {
+ if x.PodAffinity == nil {
+ x.PodAffinity = new(PodAffinity)
+ }
+ x.PodAffinity.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.PodAntiAffinity != nil {
+ x.PodAntiAffinity = nil
+ }
+ } else {
+ if x.PodAntiAffinity == nil {
+ x.PodAntiAffinity = new(PodAntiAffinity)
+ }
+ x.PodAntiAffinity.CodecDecodeSelf(d)
+ }
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *PodAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -22059,7 +23343,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.RequiredDuringSchedulingIgnoredDuringExecution != nil
+ yyq2[0] = len(x.RequiredDuringSchedulingIgnoredDuringExecution) != 0
yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
var yynn2 int
if yyr2 || yy2arr2 {
@@ -22080,7 +23364,12 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
r.EncodeNil()
} else {
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
}
} else {
r.EncodeNil()
@@ -22093,7 +23382,12 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
r.EncodeNil()
} else {
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
}
}
}
@@ -22107,7 +23401,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym7
if false {
} else {
- h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
}
}
} else {
@@ -22125,7 +23419,7 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym8
if false {
} else {
- h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
}
}
}
@@ -22139,7 +23433,1018 @@ func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *NodeAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *PodAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "requiredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv4 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv4), d)
+ }
+ }
+ case "preferredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv6 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv9 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv11 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodAntiAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.RequiredDuringSchedulingIgnoredDuringExecution) != 0
+ yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSlicePodAffinityTerm(([]PodAffinityTerm)(x.RequiredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preferredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceWeightedPodAffinityTerm(([]WeightedPodAffinityTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodAntiAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAntiAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "requiredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv4 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv4), d)
+ }
+ }
+ case "preferredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv6 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAntiAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv9 := &x.RequiredDuringSchedulingIgnoredDuringExecution
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicePodAffinityTerm((*[]PodAffinityTerm)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv11 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceWeightedPodAffinityTerm((*[]WeightedPodAffinityTerm)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *WeightedPodAffinityTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("weight"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy7 := &x.PodAffinityTerm
+ yy7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podAffinityTerm"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.PodAffinityTerm
+ yy9.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *WeightedPodAffinityTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *WeightedPodAffinityTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "weight":
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ case "podAffinityTerm":
+ if r.TryDecodeAsNil() {
+ x.PodAffinityTerm = PodAffinityTerm{}
+ } else {
+ yyv5 := &x.PodAffinityTerm
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *WeightedPodAffinityTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodAffinityTerm = PodAffinityTerm{}
+ } else {
+ yyv8 := &x.PodAffinityTerm
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodAffinityTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.LabelSelector != nil
+ yyq2[2] = x.TopologyKey != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.LabelSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LabelSelector) {
+ } else {
+ z.EncFallback(x.LabelSelector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LabelSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LabelSelector) {
+ } else {
+ z.EncFallback(x.LabelSelector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Namespaces == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Namespaces, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("namespaces"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Namespaces == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Namespaces, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.TopologyKey))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("topologyKey"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.TopologyKey))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodAffinityTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodAffinityTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "labelSelector":
+ if r.TryDecodeAsNil() {
+ if x.LabelSelector != nil {
+ x.LabelSelector = nil
+ }
+ } else {
+ if x.LabelSelector == nil {
+ x.LabelSelector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LabelSelector) {
+ } else {
+ z.DecFallback(x.LabelSelector, false)
+ }
+ }
+ case "namespaces":
+ if r.TryDecodeAsNil() {
+ x.Namespaces = nil
+ } else {
+ yyv6 := &x.Namespaces
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "topologyKey":
+ if r.TryDecodeAsNil() {
+ x.TopologyKey = ""
+ } else {
+ x.TopologyKey = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodAffinityTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.LabelSelector != nil {
+ x.LabelSelector = nil
+ }
+ } else {
+ if x.LabelSelector == nil {
+ x.LabelSelector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LabelSelector) {
+ } else {
+ z.DecFallback(x.LabelSelector, false)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Namespaces = nil
+ } else {
+ yyv12 := &x.Namespaces
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv12, false, d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.TopologyKey = ""
+ } else {
+ x.TopologyKey = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NodeAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.RequiredDuringSchedulingIgnoredDuringExecution != nil
+ yyq2[1] = len(x.PreferredDuringSchedulingIgnoredDuringExecution) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preferredDuringSchedulingIgnoredDuringExecution"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PreferredDuringSchedulingIgnoredDuringExecution == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSlicePreferredSchedulingTerm(([]PreferredSchedulingTerm)(x.PreferredDuringSchedulingIgnoredDuringExecution), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NodeAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -22191,28 +24496,461 @@ func (x *NodeAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "requiredDuringSchedulingIgnoredDuringExecution":
+ case "requiredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ } else {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = new(NodeSelector)
+ }
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecDecodeSelf(d)
+ }
+ case "preferredDuringSchedulingIgnoredDuringExecution":
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv5 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSlicePreferredSchedulingTerm((*[]PreferredSchedulingTerm)(yyv5), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NodeAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = nil
+ }
+ } else {
+ if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
+ x.RequiredDuringSchedulingIgnoredDuringExecution = new(NodeSelector)
+ }
+ x.RequiredDuringSchedulingIgnoredDuringExecution.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ } else {
+ yyv9 := &x.PreferredDuringSchedulingIgnoredDuringExecution
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicePreferredSchedulingTerm((*[]PreferredSchedulingTerm)(yyv9), d)
+ }
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PreferredSchedulingTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("weight"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Weight))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy7 := &x.Preference
+ yy7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preference"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.Preference
+ yy9.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PreferredSchedulingTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "weight":
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ case "preference":
+ if r.TryDecodeAsNil() {
+ x.Preference = NodeSelectorTerm{}
+ } else {
+ yyv5 := &x.Preference
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PreferredSchedulingTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Weight = 0
+ } else {
+ x.Weight = int32(r.DecodeInt(32))
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Preference = NodeSelectorTerm{}
+ } else {
+ yyv8 := &x.Preference
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Taint) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.Value != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("value"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Effect.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("effect"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Effect.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Taint) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Taint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
if r.TryDecodeAsNil() {
- if x.RequiredDuringSchedulingIgnoredDuringExecution != nil {
- x.RequiredDuringSchedulingIgnoredDuringExecution = nil
- }
+ x.Key = ""
} else {
- if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
- x.RequiredDuringSchedulingIgnoredDuringExecution = new(NodeSelector)
- }
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecDecodeSelf(d)
+ x.Key = string(r.DecodeString())
}
- case "preferredDuringSchedulingIgnoredDuringExecution":
+ case "value":
if r.TryDecodeAsNil() {
- x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ x.Value = ""
} else {
- yyv5 := &x.PreferredDuringSchedulingIgnoredDuringExecution
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else {
- h.decSlicePreferredSchedulingTerm((*[]PreferredSchedulingTerm)(yyv5), d)
- }
+ x.Value = string(r.DecodeString())
+ }
+ case "effect":
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -22221,7 +24959,7 @@ func (x *NodeAffinity) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *NodeAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *Taint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -22240,14 +24978,9 @@ func (x *NodeAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.RequiredDuringSchedulingIgnoredDuringExecution != nil {
- x.RequiredDuringSchedulingIgnoredDuringExecution = nil
- }
+ x.Key = ""
} else {
- if x.RequiredDuringSchedulingIgnoredDuringExecution == nil {
- x.RequiredDuringSchedulingIgnoredDuringExecution = new(NodeSelector)
- }
- x.RequiredDuringSchedulingIgnoredDuringExecution.CodecDecodeSelf(d)
+ x.Key = string(r.DecodeString())
}
yyj7++
if yyhl7 {
@@ -22261,15 +24994,25 @@ func (x *NodeAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.PreferredDuringSchedulingIgnoredDuringExecution = nil
+ x.Value = ""
} else {
- yyv9 := &x.PreferredDuringSchedulingIgnoredDuringExecution
- yym10 := z.DecBinary()
- _ = yym10
- if false {
- } else {
- h.decSlicePreferredSchedulingTerm((*[]PreferredSchedulingTerm)(yyv9), d)
- }
+ x.Value = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
for {
yyj7++
@@ -22287,7 +25030,33 @@ func (x *NodeAffinity) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *PreferredSchedulingTerm) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x TaintEffect) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *TaintEffect) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *Toleration) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -22301,14 +25070,18 @@ func (x *PreferredSchedulingTerm) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = x.Key != ""
+ yyq2[1] = x.Operator != ""
+ yyq2[2] = x.Value != ""
+ yyq2[3] = x.Effect != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -22319,33 +25092,83 @@ func (x *PreferredSchedulingTerm) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
} else {
- r.EncodeInt(int64(x.Weight))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("weight"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ x.Operator.CodecEncodeSelf(e)
} else {
- r.EncodeInt(int64(x.Weight))
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("operator"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Operator.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.Preference
- yy7.CodecEncodeSelf(e)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("preference"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.Preference
- yy9.CodecEncodeSelf(e)
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("value"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Value))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ x.Effect.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("effect"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Effect.CodecEncodeSelf(e)
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -22356,7 +25179,7 @@ func (x *PreferredSchedulingTerm) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *PreferredSchedulingTerm) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *Toleration) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -22386,7 +25209,7 @@ func (x *PreferredSchedulingTerm) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *Toleration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -22408,18 +25231,29 @@ func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Dec
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "weight":
+ case "key":
if r.TryDecodeAsNil() {
- x.Weight = 0
+ x.Key = ""
} else {
- x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Key = string(r.DecodeString())
}
- case "preference":
+ case "operator":
if r.TryDecodeAsNil() {
- x.Preference = NodeSelectorTerm{}
+ x.Operator = ""
} else {
- yyv5 := &x.Preference
- yyv5.CodecDecodeSelf(d)
+ x.Operator = TolerationOperator(r.DecodeString())
+ }
+ case "value":
+ if r.TryDecodeAsNil() {
+ x.Value = ""
+ } else {
+ x.Value = string(r.DecodeString())
+ }
+ case "effect":
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -22428,62 +25262,119 @@ func (x *PreferredSchedulingTerm) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PreferredSchedulingTerm) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *Toleration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Weight = 0
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- x.Weight = int(r.DecodeInt(codecSelferBitsize1234))
+ yyb8 = r.CheckBreak()
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Operator = ""
} else {
- yyb6 = r.CheckBreak()
+ x.Operator = TolerationOperator(r.DecodeString())
}
- if yyb6 {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Preference = NodeSelectorTerm{}
+ x.Value = ""
} else {
- yyv8 := &x.Preference
- yyv8.CodecDecodeSelf(d)
+ x.Value = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Effect = ""
+ } else {
+ x.Effect = TaintEffect(r.DecodeString())
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x TolerationOperator) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *TolerationOperator) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -22498,7 +25389,7 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [15]bool
+ var yyq2 [17]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.Volumes) != 0
@@ -22515,9 +25406,11 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[12] = x.HostIPC != false
yyq2[13] = x.SecurityContext != nil
yyq2[14] = len(x.ImagePullSecrets) != 0
+ yyq2[15] = x.Hostname != ""
+ yyq2[16] = x.Subdomain != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(15)
+ r.EncodeArrayStart(17)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -22927,6 +25820,56 @@ func (x *PodSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[15] {
+ yym53 := z.EncBinary()
+ _ = yym53
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[15] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostname"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym54 := z.EncBinary()
+ _ = yym54
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[16] {
+ yym56 := z.EncBinary()
+ _ = yym56
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Subdomain))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[16] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subdomain"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym57 := z.EncBinary()
+ _ = yym57
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Subdomain))
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -23127,6 +26070,18 @@ func (x *PodSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv23), d)
}
}
+ case "hostname":
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ case "subdomain":
+ if r.TryDecodeAsNil() {
+ x.Subdomain = ""
+ } else {
+ x.Subdomain = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -23138,16 +26093,16 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj25 int
- var yyb25 bool
- var yyhl25 bool = l >= 0
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ var yyj27 int
+ var yyb27 bool
+ var yyhl27 bool = l >= 0
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23155,21 +26110,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Volumes = nil
} else {
- yyv26 := &x.Volumes
- yym27 := z.DecBinary()
- _ = yym27
+ yyv28 := &x.Volumes
+ yym29 := z.DecBinary()
+ _ = yym29
if false {
} else {
- h.decSliceVolume((*[]Volume)(yyv26), d)
+ h.decSliceVolume((*[]Volume)(yyv28), d)
}
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23177,21 +26132,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Containers = nil
} else {
- yyv28 := &x.Containers
- yym29 := z.DecBinary()
- _ = yym29
+ yyv30 := &x.Containers
+ yym31 := z.DecBinary()
+ _ = yym31
if false {
} else {
- h.decSliceContainer((*[]Container)(yyv28), d)
+ h.decSliceContainer((*[]Container)(yyv30), d)
}
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23201,13 +26156,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.RestartPolicy = RestartPolicy(r.DecodeString())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23220,20 +26175,20 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.TerminationGracePeriodSeconds == nil {
x.TerminationGracePeriodSeconds = new(int64)
}
- yym32 := z.DecBinary()
- _ = yym32
+ yym34 := z.DecBinary()
+ _ = yym34
if false {
} else {
*((*int64)(x.TerminationGracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23246,20 +26201,20 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.ActiveDeadlineSeconds == nil {
x.ActiveDeadlineSeconds = new(int64)
}
- yym34 := z.DecBinary()
- _ = yym34
+ yym36 := z.DecBinary()
+ _ = yym36
if false {
} else {
*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23269,13 +26224,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.DNSPolicy = DNSPolicy(r.DecodeString())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23283,21 +26238,21 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodeSelector = nil
} else {
- yyv36 := &x.NodeSelector
- yym37 := z.DecBinary()
- _ = yym37
+ yyv38 := &x.NodeSelector
+ yym39 := z.DecBinary()
+ _ = yym39
if false {
} else {
- z.F.DecMapStringStringX(yyv36, false, d)
+ z.F.DecMapStringStringX(yyv38, false, d)
}
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23307,13 +26262,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ServiceAccountName = string(r.DecodeString())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23323,13 +26278,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.DeprecatedServiceAccount = string(r.DecodeString())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23339,13 +26294,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.NodeName = string(r.DecodeString())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23355,13 +26310,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.HostNetwork = bool(r.DecodeBool())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23371,13 +26326,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.HostPID = bool(r.DecodeBool())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23387,13 +26342,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.HostIPC = bool(r.DecodeBool())
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23408,13 +26363,13 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.SecurityContext.CodecDecodeSelf(d)
}
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -23422,26 +26377,58 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ImagePullSecrets = nil
} else {
- yyv45 := &x.ImagePullSecrets
- yym46 := z.DecBinary()
- _ = yym46
+ yyv47 := &x.ImagePullSecrets
+ yym48 := z.DecBinary()
+ _ = yym48
if false {
} else {
- h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv45), d)
+ h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv47), d)
}
}
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
+ } else {
+ yyb27 = r.CheckBreak()
+ }
+ if yyb27 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
+ } else {
+ yyb27 = r.CheckBreak()
+ }
+ if yyb27 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Subdomain = ""
+ } else {
+ x.Subdomain = string(r.DecodeString())
+ }
for {
- yyj25++
- if yyhl25 {
- yyb25 = yyj25 > l
+ yyj27++
+ if yyhl27 {
+ yyb27 = yyj27 > l
} else {
- yyb25 = r.CheckBreak()
+ yyb27 = r.CheckBreak()
}
- if yyb25 {
+ if yyb27 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj25-1, "")
+ z.DecStructFieldNotFound(yyj27-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -28249,7 +31236,7 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [9]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[1] = len(x.Selector) != 0
@@ -28259,9 +31246,10 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[5] = len(x.DeprecatedPublicIPs) != 0
yyq2[6] = x.SessionAffinity != ""
yyq2[7] = x.LoadBalancerIP != ""
+ yyq2[8] = len(x.LoadBalancerSourceRanges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(9)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -28478,6 +31466,39 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[8] {
+ if x.LoadBalancerSourceRanges == nil {
+ r.EncodeNil()
+ } else {
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("loadBalancerSourceRanges"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LoadBalancerSourceRanges == nil {
+ r.EncodeNil()
+ } else {
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -28611,6 +31632,18 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.LoadBalancerIP = string(r.DecodeString())
}
+ case "loadBalancerSourceRanges":
+ if r.TryDecodeAsNil() {
+ x.LoadBalancerSourceRanges = nil
+ } else {
+ yyv16 := &x.LoadBalancerSourceRanges
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv16, false, d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -28622,16 +31655,16 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj16 int
- var yyb16 bool
- var yyhl16 bool = l >= 0
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ var yyj18 int
+ var yyb18 bool
+ var yyhl18 bool = l >= 0
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28639,21 +31672,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv17 := &x.Ports
- yym18 := z.DecBinary()
- _ = yym18
+ yyv19 := &x.Ports
+ yym20 := z.DecBinary()
+ _ = yym20
if false {
} else {
- h.decSliceServicePort((*[]ServicePort)(yyv17), d)
+ h.decSliceServicePort((*[]ServicePort)(yyv19), d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28661,21 +31694,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv19 := &x.Selector
- yym20 := z.DecBinary()
- _ = yym20
+ yyv21 := &x.Selector
+ yym22 := z.DecBinary()
+ _ = yym22
if false {
} else {
- z.F.DecMapStringStringX(yyv19, false, d)
+ z.F.DecMapStringStringX(yyv21, false, d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28685,13 +31718,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ClusterIP = string(r.DecodeString())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28701,13 +31734,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = ServiceType(r.DecodeString())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28715,21 +31748,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ExternalIPs = nil
} else {
- yyv23 := &x.ExternalIPs
- yym24 := z.DecBinary()
- _ = yym24
+ yyv25 := &x.ExternalIPs
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- z.F.DecSliceStringX(yyv23, false, d)
+ z.F.DecSliceStringX(yyv25, false, d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28737,21 +31770,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DeprecatedPublicIPs = nil
} else {
- yyv25 := &x.DeprecatedPublicIPs
- yym26 := z.DecBinary()
- _ = yym26
+ yyv27 := &x.DeprecatedPublicIPs
+ yym28 := z.DecBinary()
+ _ = yym28
if false {
} else {
- z.F.DecSliceStringX(yyv25, false, d)
+ z.F.DecSliceStringX(yyv27, false, d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28761,13 +31794,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SessionAffinity = ServiceAffinity(r.DecodeString())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -28777,18 +31810,40 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.LoadBalancerIP = string(r.DecodeString())
}
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LoadBalancerSourceRanges = nil
+ } else {
+ yyv31 := &x.LoadBalancerSourceRanges
+ yym32 := z.DecBinary()
+ _ = yym32
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv31, false, d)
+ }
+ }
for {
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb16 {
+ if yyb18 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj16-1, "")
+ z.DecStructFieldNotFound(yyj18-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -29025,7 +32080,7 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
case "targetPort":
if r.TryDecodeAsNil() {
- x.TargetPort = pkg5_intstr.IntOrString{}
+ x.TargetPort = pkg4_intstr.IntOrString{}
} else {
yyv7 := &x.TargetPort
yym8 := z.DecBinary()
@@ -29118,7 +32173,7 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.TargetPort = pkg5_intstr.IntOrString{}
+ x.TargetPort = pkg4_intstr.IntOrString{}
} else {
yyv14 := &x.TargetPort
yym15 := z.DecBinary()
@@ -31248,13 +34303,14 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.TargetRef != nil
+ yyq2[1] = x.Hostname != ""
+ yyq2[2] = x.TargetRef != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -31287,6 +34343,31 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostname"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
if x.TargetRef == nil {
r.EncodeNil()
} else {
@@ -31296,7 +34377,7 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("targetRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -31374,6 +34455,12 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.IP = string(r.DecodeString())
}
+ case "hostname":
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
case "targetRef":
if r.TryDecodeAsNil() {
if x.TargetRef != nil {
@@ -31396,16 +34483,16 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31415,13 +34502,29 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.IP = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Hostname = ""
+ } else {
+ x.Hostname = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31437,17 +34540,17 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.TargetRef.CodecDecodeSelf(d)
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -32696,14 +35799,14 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [10]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(10)
} else {
- yynn2 = 8
+ yynn2 = 10
for _, b := range yyq2 {
if b {
yynn2++
@@ -32864,6 +35967,44 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("operatingSystem"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym31 := z.EncBinary()
+ _ = yym31
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("architecture"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym32 := z.EncBinary()
+ _ = yym32
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -32973,6 +36114,18 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.KubeProxyVersion = string(r.DecodeString())
}
+ case "operatingSystem":
+ if r.TryDecodeAsNil() {
+ x.OperatingSystem = ""
+ } else {
+ x.OperatingSystem = string(r.DecodeString())
+ }
+ case "architecture":
+ if r.TryDecodeAsNil() {
+ x.Architecture = ""
+ } else {
+ x.Architecture = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -32982,18 +36135,18 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj12 int
- var yyb12 bool
- var yyhl12 bool = l >= 0
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj14 int
+ var yyb14 bool
+ var yyhl14 bool = l >= 0
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33003,13 +36156,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.MachineID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33019,13 +36172,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SystemUUID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33035,13 +36188,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.BootID = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33051,13 +36204,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KernelVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33067,13 +36220,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.OSImage = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33083,13 +36236,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ContainerRuntimeVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33099,13 +36252,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeletVersion = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33115,18 +36268,50 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeProxyVersion = string(r.DecodeString())
}
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.OperatingSystem = ""
+ } else {
+ x.OperatingSystem = string(r.DecodeString())
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Architecture = ""
+ } else {
+ x.Architecture = string(r.DecodeString())
+ }
for {
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb12 {
+ if yyb14 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj12-1, "")
+ z.DecStructFieldNotFound(yyj14-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33145,7 +36330,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [10]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = len(x.Capacity) != 0
@@ -33155,11 +36340,14 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
yyq2[4] = len(x.Addresses) != 0
yyq2[5] = true
yyq2[6] = true
+ yyq2[7] = len(x.Images) != 0
+ yyq2[8] = len(x.VolumesInUse) != 0
+ yyq2[9] = len(x.VolumesAttached) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(10)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -33331,28 +36519,100 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Images == nil {
- r.EncodeNil()
- } else {
- yym29 := z.EncBinary()
- _ = yym29
- if false {
+ if yyq2[7] {
+ if x.Images == nil {
+ r.EncodeNil()
} else {
- h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ }
}
+ } else {
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("images"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Images == nil {
+ if yyq2[7] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("images"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Images == nil {
+ r.EncodeNil()
+ } else {
+ yym30 := z.EncBinary()
+ _ = yym30
+ if false {
+ } else {
+ h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[8] {
+ if x.VolumesInUse == nil {
+ r.EncodeNil()
+ } else {
+ yym32 := z.EncBinary()
+ _ = yym32
+ if false {
+ } else {
+ h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
+ }
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumesInUse"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumesInUse == nil {
+ r.EncodeNil()
+ } else {
+ yym33 := z.EncBinary()
+ _ = yym33
+ if false {
+ } else {
+ h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[9] {
+ if x.VolumesAttached == nil {
+ r.EncodeNil()
+ } else {
+ yym35 := z.EncBinary()
+ _ = yym35
+ if false {
+ } else {
+ h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
+ }
+ }
} else {
- yym30 := z.EncBinary()
- _ = yym30
- if false {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[9] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumesAttached"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumesAttached == nil {
+ r.EncodeNil()
} else {
- h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
+ yym36 := z.EncBinary()
+ _ = yym36
+ if false {
+ } else {
+ h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
+ }
}
}
}
@@ -33487,6 +36747,30 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
h.decSliceContainerImage((*[]ContainerImage)(yyv13), d)
}
}
+ case "volumesInUse":
+ if r.TryDecodeAsNil() {
+ x.VolumesInUse = nil
+ } else {
+ yyv15 := &x.VolumesInUse
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv15), d)
+ }
+ }
+ case "volumesAttached":
+ if r.TryDecodeAsNil() {
+ x.VolumesAttached = nil
+ } else {
+ yyv17 := &x.VolumesAttached
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv17), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -33498,16 +36782,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj15 int
- var yyb15 bool
- var yyhl15 bool = l >= 0
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ var yyj19 int
+ var yyb19 bool
+ var yyhl19 bool = l >= 0
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33515,16 +36799,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv16 := &x.Capacity
- yyv16.CodecDecodeSelf(d)
+ yyv20 := &x.Capacity
+ yyv20.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33532,16 +36816,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Allocatable = nil
} else {
- yyv17 := &x.Allocatable
- yyv17.CodecDecodeSelf(d)
+ yyv21 := &x.Allocatable
+ yyv21.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33551,13 +36835,13 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Phase = NodePhase(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33565,21 +36849,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv19 := &x.Conditions
- yym20 := z.DecBinary()
- _ = yym20
+ yyv23 := &x.Conditions
+ yym24 := z.DecBinary()
+ _ = yym24
if false {
} else {
- h.decSliceNodeCondition((*[]NodeCondition)(yyv19), d)
+ h.decSliceNodeCondition((*[]NodeCondition)(yyv23), d)
}
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33587,21 +36871,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv21 := &x.Addresses
- yym22 := z.DecBinary()
- _ = yym22
+ yyv25 := &x.Addresses
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- h.decSliceNodeAddress((*[]NodeAddress)(yyv21), d)
+ h.decSliceNodeAddress((*[]NodeAddress)(yyv25), d)
}
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33609,16 +36893,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DaemonEndpoints = NodeDaemonEndpoints{}
} else {
- yyv23 := &x.DaemonEndpoints
- yyv23.CodecDecodeSelf(d)
+ yyv27 := &x.DaemonEndpoints
+ yyv27.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33626,16 +36910,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodeInfo = NodeSystemInfo{}
} else {
- yyv24 := &x.NodeInfo
- yyv24.CodecDecodeSelf(d)
+ yyv28 := &x.NodeInfo
+ yyv28.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33643,26 +36927,289 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Images = nil
} else {
- yyv25 := &x.Images
- yym26 := z.DecBinary()
- _ = yym26
+ yyv29 := &x.Images
+ yym30 := z.DecBinary()
+ _ = yym30
+ if false {
+ } else {
+ h.decSliceContainerImage((*[]ContainerImage)(yyv29), d)
+ }
+ }
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
+ } else {
+ yyb19 = r.CheckBreak()
+ }
+ if yyb19 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumesInUse = nil
+ } else {
+ yyv31 := &x.VolumesInUse
+ yym32 := z.DecBinary()
+ _ = yym32
+ if false {
+ } else {
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv31), d)
+ }
+ }
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
+ } else {
+ yyb19 = r.CheckBreak()
+ }
+ if yyb19 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumesAttached = nil
+ } else {
+ yyv33 := &x.VolumesAttached
+ yym34 := z.DecBinary()
+ _ = yym34
if false {
} else {
- h.decSliceContainerImage((*[]ContainerImage)(yyv25), d)
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv33), d)
}
}
for {
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj19++
+ if yyhl19 {
+ yyb19 = yyj19 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb19 = r.CheckBreak()
}
- if yyb15 {
+ if yyb19 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj15-1, "")
+ z.DecStructFieldNotFound(yyj19-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x UniqueVolumeName) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *UniqueVolumeName) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Name.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Name.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("devicePath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *AttachedVolume) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = UniqueVolumeName(r.DecodeString())
+ }
+ case "devicePath":
+ if r.TryDecodeAsNil() {
+ x.DevicePath = ""
+ } else {
+ x.DevicePath = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = UniqueVolumeName(r.DecodeString())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DevicePath = ""
+ } else {
+ x.DevicePath = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -36735,7 +40282,7 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *Preconditions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -36749,16 +40296,15 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.Kind != ""
- yyq2[2] = x.APIVersion != ""
+ yyq2[0] = x.UID != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(1)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -36769,38 +40315,309 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.GracePeriodSeconds == nil {
+ if yyq2[0] {
+ if x.UID == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.UID
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yy4))
+ }
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.UID == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.UID
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Preconditions) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "uid":
+ if r.TryDecodeAsNil() {
+ if x.UID != nil {
+ x.UID = nil
+ }
+ } else {
+ if x.UID == nil {
+ x.UID = new(pkg1_types.UID)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.UID) {
} else {
- yy4 := *x.GracePeriodSeconds
- yym5 := z.EncBinary()
- _ = yym5
- if false {
+ *((*string)(x.UID)) = r.DecodeString()
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.UID != nil {
+ x.UID = nil
+ }
+ } else {
+ if x.UID == nil {
+ x.UID = new(pkg1_types.UID)
+ }
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.UID) {
+ } else {
+ *((*string)(x.UID)) = r.DecodeString()
+ }
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.GracePeriodSeconds != nil
+ yyq2[1] = x.Preconditions != nil
+ yyq2[2] = x.OrphanDependents != nil
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.GracePeriodSeconds == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(yy4))
+ yy4 := *x.GracePeriodSeconds
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
}
+ } else {
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.GracePeriodSeconds == nil {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.GracePeriodSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.GracePeriodSeconds
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Preconditions == nil {
+ r.EncodeNil()
+ } else {
+ x.Preconditions.CodecEncodeSelf(e)
+ }
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("preconditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Preconditions == nil {
+ r.EncodeNil()
+ } else {
+ x.Preconditions.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.OrphanDependents == nil {
+ r.EncodeNil()
+ } else {
+ yy12 := *x.OrphanDependents
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeBool(bool(yy12))
+ }
+ }
} else {
- yy6 := *x.GracePeriodSeconds
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("orphanDependents"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.OrphanDependents == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(yy6))
+ yy14 := *x.OrphanDependents
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeBool(bool(yy14))
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym9 := z.EncBinary()
- _ = yym9
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -36809,12 +40626,12 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[1] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym10 := z.EncBinary()
- _ = yym10
+ yym18 := z.EncBinary()
+ _ = yym18
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -36823,9 +40640,9 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -36834,12 +40651,12 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
+ yym21 := z.EncBinary()
+ _ = yym21
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -36923,6 +40740,33 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
+ case "preconditions":
+ if r.TryDecodeAsNil() {
+ if x.Preconditions != nil {
+ x.Preconditions = nil
+ }
+ } else {
+ if x.Preconditions == nil {
+ x.Preconditions = new(Preconditions)
+ }
+ x.Preconditions.CodecDecodeSelf(d)
+ }
+ case "orphanDependents":
+ if r.TryDecodeAsNil() {
+ if x.OrphanDependents != nil {
+ x.OrphanDependents = nil
+ }
+ } else {
+ if x.OrphanDependents == nil {
+ x.OrphanDependents = new(bool)
+ }
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else {
+ *((*bool)(x.OrphanDependents)) = r.DecodeBool()
+ }
+ }
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -36946,16 +40790,16 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36968,20 +40812,67 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.GracePeriodSeconds == nil {
x.GracePeriodSeconds = new(int64)
}
- yym10 := z.DecBinary()
- _ = yym10
+ yym13 := z.DecBinary()
+ _ = yym13
if false {
} else {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Preconditions != nil {
+ x.Preconditions = nil
+ }
+ } else {
+ if x.Preconditions == nil {
+ x.Preconditions = new(Preconditions)
+ }
+ x.Preconditions.CodecDecodeSelf(d)
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.OrphanDependents != nil {
+ x.OrphanDependents = nil
+ }
+ } else {
+ if x.OrphanDependents == nil {
+ x.OrphanDependents = new(bool)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*bool)(x.OrphanDependents)) = r.DecodeBool()
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36991,13 +40882,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37008,17 +40899,17 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.APIVersion = string(r.DecodeString())
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb8 {
+ if yyb11 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj11-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -39905,7 +43796,272 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *NodeProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NodeProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "path":
+ if r.TryDecodeAsNil() {
+ x.Path = ""
+ } else {
+ x.Path = string(r.DecodeString())
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Path = ""
+ } else {
+ x.Path = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Path != ""
+ yyq2[1] = x.Kind != ""
+ yyq2[2] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("path"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ServiceProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -39935,7 +44091,7 @@ func (x *NodeProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -39982,7 +44138,7 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -40053,7 +44209,7 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -40067,17 +44223,15 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Path != ""
- yyq2[1] = x.Kind != ""
- yyq2[2] = x.APIVersion != ""
+ yyq2[4] = x.Controller != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(5)
} else {
- yynn2 = 0
+ yynn2 = 4
for _, b := range yyq2 {
if b {
yynn2++
@@ -40088,76 +44242,114 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("path"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.Controller == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yy16 := *x.Controller
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeBool(bool(yy16))
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("controller"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym11 := z.EncBinary()
- _ = yym11
- if false {
+ if x.Controller == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yy18 := *x.Controller
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeBool(bool(yy18))
+ }
}
}
}
@@ -40170,7 +44362,7 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ServiceProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *OwnerReference) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -40200,7 +44392,7 @@ func (x *ServiceProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *OwnerReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -40222,11 +44414,11 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "path":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.APIVersion = ""
} else {
- x.Path = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
case "kind":
if r.TryDecodeAsNil() {
@@ -40234,11 +44426,33 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
} else {
x.Kind = string(r.DecodeString())
}
- case "apiVersion":
+ case "name":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Name = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Name = string(r.DecodeString())
+ }
+ case "uid":
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = pkg1_types.UID(r.DecodeString())
+ }
+ case "controller":
+ if r.TryDecodeAsNil() {
+ if x.Controller != nil {
+ x.Controller = nil
+ }
+ } else {
+ if x.Controller == nil {
+ x.Controller = new(bool)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*bool)(x.Controller)) = r.DecodeBool()
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -40247,36 +44461,36 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.APIVersion = ""
} else {
- x.Path = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40286,34 +44500,76 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.Kind = string(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Name = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Name = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = pkg1_types.UID(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Controller != nil {
+ x.Controller = nil
+ }
+ } else {
+ if x.Controller == nil {
+ x.Controller = new(bool)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*bool)(x.Controller)) = r.DecodeBool()
+ }
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42522,7 +46778,7 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym9
if false {
} else {
- h.encSliceruntime_RawExtension(([]pkg6_runtime.RawExtension)(x.Items), e)
+ h.encSliceruntime_RawExtension(([]pkg5_runtime.RawExtension)(x.Items), e)
}
}
} else {
@@ -42536,7 +46792,7 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym10
if false {
} else {
- h.encSliceruntime_RawExtension(([]pkg6_runtime.RawExtension)(x.Items), e)
+ h.encSliceruntime_RawExtension(([]pkg5_runtime.RawExtension)(x.Items), e)
}
}
}
@@ -42673,7 +46929,7 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
_ = yym7
if false {
} else {
- h.decSliceruntime_RawExtension((*[]pkg6_runtime.RawExtension)(yyv6), d)
+ h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv6), d)
}
}
case "kind":
@@ -42744,7 +47000,7 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
_ = yym14
if false {
} else {
- h.decSliceruntime_RawExtension((*[]pkg6_runtime.RawExtension)(yyv13), d)
+ h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv13), d)
}
}
yyj10++
@@ -46294,14 +50550,13 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = len(x.Items) != 0
yyq2[2] = x.Kind != ""
yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -46341,34 +50596,28 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.Items == nil {
- r.EncodeNil()
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
- }
+ h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
}
- } else {
- r.EncodeNil()
}
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
- }
+ h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
}
}
}
@@ -47806,14 +52055,16 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[1] = x.FieldRef != nil
+ yyq2[2] = x.ResourceFieldRef != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(3)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -47843,14 +52094,49 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.FieldRef
- yy7.CodecEncodeSelf(e)
+ if yyq2[1] {
+ if x.FieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.FieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("fieldRef"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.FieldRef
- yy9.CodecEncodeSelf(e)
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.FieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.FieldRef.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceFieldRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ResourceFieldRef == nil {
+ r.EncodeNil()
+ } else {
+ x.ResourceFieldRef.CodecEncodeSelf(e)
+ }
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -47921,10 +52207,25 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromMap(l int, d *codec1978.Decod
}
case "fieldRef":
if r.TryDecodeAsNil() {
- x.FieldRef = ObjectFieldSelector{}
+ if x.FieldRef != nil {
+ x.FieldRef = nil
+ }
+ } else {
+ if x.FieldRef == nil {
+ x.FieldRef = new(ObjectFieldSelector)
+ }
+ x.FieldRef.CodecDecodeSelf(d)
+ }
+ case "resourceFieldRef":
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
} else {
- yyv5 := &x.FieldRef
- yyv5.CodecDecodeSelf(d)
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -47937,16 +52238,16 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47956,35 +52257,60 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.Path = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.FieldRef = ObjectFieldSelector{}
+ if x.FieldRef != nil {
+ x.FieldRef = nil
+ }
} else {
- yyv8 := &x.FieldRef
- yyv8.CodecDecodeSelf(d)
+ if x.FieldRef == nil {
+ x.FieldRef = new(ObjectFieldSelector)
+ }
+ x.FieldRef.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ResourceFieldRef != nil {
+ x.ResourceFieldRef = nil
+ }
+ } else {
+ if x.ResourceFieldRef == nil {
+ x.ResourceFieldRef = new(ResourceFieldSelector)
+ }
+ x.ResourceFieldRef.CodecDecodeSelf(d)
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb6 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -49208,6 +53534,125 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x codecSelfer1234) encSliceOwnerReference(v []OwnerReference, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceOwnerReference(v *[]OwnerReference, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []OwnerReference{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]OwnerReference, yyrl1)
+ }
+ } else {
+ yyv1 = make([]OwnerReference, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, OwnerReference{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, OwnerReference{}) // var yyz1 OwnerReference
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = OwnerReference{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []OwnerReference{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encSlicePersistentVolumeAccessMode(v []PersistentVolumeAccessMode, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -49357,7 +53802,7 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 400)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 456)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -49476,7 +53921,7 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -50181,7 +54626,7 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -50499,6 +54944,244 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir
}
}
+func (x codecSelfer1234) encSlicePodAffinityTerm(v []PodAffinityTerm, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PodAffinityTerm{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PodAffinityTerm, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PodAffinityTerm, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PodAffinityTerm{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PodAffinityTerm{}) // var yyz1 PodAffinityTerm
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodAffinityTerm{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PodAffinityTerm{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceWeightedPodAffinityTerm(v []WeightedPodAffinityTerm, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinityTerm, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []WeightedPodAffinityTerm{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]WeightedPodAffinityTerm, yyrl1)
+ }
+ } else {
+ yyv1 = make([]WeightedPodAffinityTerm, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, WeightedPodAffinityTerm{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, WeightedPodAffinityTerm{}) // var yyz1 WeightedPodAffinityTerm
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = WeightedPodAffinityTerm{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []WeightedPodAffinityTerm{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encSlicePreferredSchedulingTerm(v []PreferredSchedulingTerm, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -50657,7 +55340,7 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 168)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 176)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51252,7 +55935,7 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 520)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 648)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51371,7 +56054,7 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 544)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 696)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51490,7 +56173,7 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 232)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -51847,7 +56530,7 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 360)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 432)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52085,7 +56768,7 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 240)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 288)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52323,7 +57006,7 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52561,7 +57244,7 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -52998,6 +57681,235 @@ func (x codecSelfer1234) decSliceContainerImage(v *[]ContainerImage, d *codec197
}
}
+func (x codecSelfer1234) encSliceUniqueVolumeName(v []UniqueVolumeName, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yyv1.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []UniqueVolumeName{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]UniqueVolumeName, yyrl1)
+ }
+ } else {
+ yyv1 = make([]UniqueVolumeName, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 UniqueVolumeName
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = UniqueVolumeName(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []UniqueVolumeName{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceAttachedVolume(v []AttachedVolume, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []AttachedVolume{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]AttachedVolume, yyrl1)
+ }
+ } else {
+ yyv1 = make([]AttachedVolume, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, AttachedVolume{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, AttachedVolume{}) // var yyz1 AttachedVolume
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = AttachedVolume{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []AttachedVolume{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
func (x codecSelfer1234) encResourceList(v ResourceList, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -53030,7 +57942,7 @@ func (x codecSelfer1234) decResourceList(v *ResourceList, d *codec1978.Decoder)
yyl1 := r.ReadMapStart()
yybh1 := z.DecBasicHandle()
if yyv1 == nil {
- yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 72)
yyv1 = make(map[ResourceName]pkg3_resource.Quantity, yyrl1)
*v = yyv1
}
@@ -53151,7 +58063,7 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 488)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 616)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53380,7 +58292,7 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 232)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53499,7 +58411,7 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 440)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 488)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -53579,7 +58491,7 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceruntime_RawExtension(v []pkg6_runtime.RawExtension, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceruntime_RawExtension(v []pkg5_runtime.RawExtension, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -53600,7 +58512,7 @@ func (x codecSelfer1234) encSliceruntime_RawExtension(v []pkg6_runtime.RawExtens
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExtension, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg5_runtime.RawExtension, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -53611,7 +58523,7 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []pkg6_runtime.RawExtension{}
+ yyv1 = []pkg5_runtime.RawExtension{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -53631,10 +58543,10 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]pkg6_runtime.RawExtension, yyrl1)
+ yyv1 = make([]pkg5_runtime.RawExtension, yyrl1)
}
} else {
- yyv1 = make([]pkg6_runtime.RawExtension, yyrl1)
+ yyv1 = make([]pkg5_runtime.RawExtension, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -53649,7 +58561,7 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = pkg6_runtime.RawExtension{}
+ yyv1[yyj1] = pkg5_runtime.RawExtension{}
} else {
yyv2 := &yyv1[yyj1]
yym3 := z.DecBinary()
@@ -53666,10 +58578,10 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, pkg6_runtime.RawExtension{})
+ yyv1 = append(yyv1, pkg5_runtime.RawExtension{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = pkg6_runtime.RawExtension{}
+ yyv1[yyj1] = pkg5_runtime.RawExtension{}
} else {
yyv4 := &yyv1[yyj1]
yym5 := z.DecBinary()
@@ -53691,13 +58603,13 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, pkg6_runtime.RawExtension{}) // var yyz1 pkg6_runtime.RawExtension
+ yyv1 = append(yyv1, pkg5_runtime.RawExtension{}) // var yyz1 pkg5_runtime.RawExtension
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = pkg6_runtime.RawExtension{}
+ yyv1[yyj1] = pkg5_runtime.RawExtension{}
} else {
yyv6 := &yyv1[yyj1]
yym7 := z.DecBinary()
@@ -53720,7 +58632,7 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg6_runtime.RawExten
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []pkg6_runtime.RawExtension{}
+ yyv1 = []pkg5_runtime.RawExtension{}
yyc1 = true
}
}
@@ -53888,7 +58800,7 @@ func (x codecSelfer1234) decSliceLimitRange(v *[]LimitRange, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54117,7 +59029,7 @@ func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 240)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 288)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54464,7 +59376,7 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54583,7 +59495,7 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 200)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 248)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54821,7 +59733,7 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
@@ -54940,7 +59852,7 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.go b/vendor/k8s.io/kubernetes/pkg/api/v1/types.go
similarity index 59%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/types.go
index c64a208c3eff9b5a118d83d327e27f41fdccac04..34b9ac471ab57a56af2ec877d2573b92a38f76ee 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/types.go
@@ -71,8 +71,8 @@ type ObjectMeta struct {
// automatically. Name is primarily intended for creation idempotence and configuration
// definition.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
// GenerateName is an optional prefix, used by the server, to generate a unique
// name ONLY IF the Name field has not been provided.
@@ -88,8 +88,8 @@ type ObjectMeta struct {
// should retry (optionally after the time indicated in the Retry-After header).
//
// Applied only if Name is not specified.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#idempotency
- GenerateName string `json:"generateName,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#idempotency
+ GenerateName string `json:"generateName,omitempty" protobuf:"bytes,2,opt,name=generateName"`
// Namespace defines the space within each name must be unique. An empty namespace is
// equivalent to the "default" namespace, but "default" is the canonical representation.
@@ -98,13 +98,13 @@ type ObjectMeta struct {
//
// Must be a DNS_LABEL.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md
- Namespace string `json:"namespace,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ Namespace string `json:"namespace,omitempty" protobuf:"bytes,3,opt,name=namespace"`
// SelfLink is a URL representing this object.
// Populated by the system.
// Read-only.
- SelfLink string `json:"selfLink,omitempty"`
+ SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,4,opt,name=selfLink"`
// 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
@@ -112,8 +112,8 @@ type ObjectMeta struct {
//
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#uids
- UID types.UID `json:"uid,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ UID types.UID `json:"uid,omitempty" protobuf:"bytes,5,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
// 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
@@ -124,12 +124,12 @@ type ObjectMeta struct {
// Populated by the system.
// Read-only.
// Value must be treated as opaque by clients and .
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency
- ResourceVersion string `json:"resourceVersion,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,6,opt,name=resourceVersion"`
// A sequence number representing a specific generation of the desired state.
// Populated by the system. Read-only.
- Generation int64 `json:"generation,omitempty"`
+ Generation int64 `json:"generation,omitempty" protobuf:"varint,7,opt,name=generation"`
// 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.
@@ -138,8 +138,8 @@ type ObjectMeta struct {
// Populated by the system.
// Read-only.
// Null for lists.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- CreationTimestamp unversioned.Time `json:"creationTimestamp,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ CreationTimestamp unversioned.Time `json:"creationTimestamp,omitempty" protobuf:"bytes,8,opt,name=creationTimestamp"`
// 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
@@ -154,27 +154,39 @@ type ObjectMeta struct {
//
// Populated by the system when a graceful deletion is requested.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- DeletionTimestamp *unversioned.Time `json:"deletionTimestamp,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ DeletionTimestamp *unversioned.Time `json:"deletionTimestamp,omitempty" protobuf:"bytes,9,opt,name=deletionTimestamp"`
// 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.
- DeletionGracePeriodSeconds *int64 `json:"deletionGracePeriodSeconds,omitempty"`
+ DeletionGracePeriodSeconds *int64 `json:"deletionGracePeriodSeconds,omitempty" protobuf:"varint,10,opt,name=deletionGracePeriodSeconds"`
// 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://releases.k8s.io/release-1.2/docs/user-guide/labels.md
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md
// TODO: replace map[string]string with labels.LabelSet type
- Labels map[string]string `json:"labels,omitempty"`
+ Labels map[string]string `json:"labels,omitempty" protobuf:"bytes,11,rep,name=labels"`
// 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://releases.k8s.io/release-1.2/docs/user-guide/annotations.md
- Annotations map[string]string `json:"annotations,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/annotations.md
+ Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,12,rep,name=annotations"`
+
+ // 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.
+ OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" patchStrategy:"merge" patchMergeKey:"uid" protobuf:"bytes,13,rep,name=ownerReferences"`
+
+ // 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 []string `json:"finalizers,omitempty" patchStrategy:"merge" protobuf:"bytes,14,rep,name=finalizers"`
}
const (
@@ -188,12 +200,12 @@ const (
type Volume struct {
// Volume's name.
// Must be a DNS_LABEL and unique within the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// VolumeSource represents the location and type of the mounted volume.
// If not specified, the Volume is implied to be an EmptyDir.
// This implied behavior is deprecated and will be removed in a future version.
- VolumeSource `json:",inline"`
+ VolumeSource `json:",inline" protobuf:"bytes,2,opt,name=volumeSource"`
}
// Represents the source of a volume to mount.
@@ -203,66 +215,68 @@ type VolumeSource struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
// ---
// TODO(jonesdl) We need to restrict who can use host directory mounts and who can/can not
// mount host directories as read/write.
- HostPath *HostPathVolumeSource `json:"hostPath,omitempty"`
+ HostPath *HostPathVolumeSource `json:"hostPath,omitempty" protobuf:"bytes,1,opt,name=hostPath"`
// EmptyDir represents a temporary directory that shares a pod's lifetime.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#emptydir
- EmptyDir *EmptyDirVolumeSource `json:"emptyDir,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir
+ EmptyDir *EmptyDirVolumeSource `json:"emptyDir,omitempty" protobuf:"bytes,2,opt,name=emptyDir"`
// GCEPersistentDisk represents a GCE Disk resource that is attached to a
// kubelet's host machine and then exposed to the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
- GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk,omitempty" protobuf:"bytes,3,opt,name=gcePersistentDisk"`
// AWSElasticBlockStore represents an AWS Disk resource that is attached to a
// kubelet's host machine and then exposed to the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore
- AWSElasticBlockStore *AWSElasticBlockStoreVolumeSource `json:"awsElasticBlockStore,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ AWSElasticBlockStore *AWSElasticBlockStoreVolumeSource `json:"awsElasticBlockStore,omitempty" protobuf:"bytes,4,opt,name=awsElasticBlockStore"`
// GitRepo represents a git repository at a particular revision.
- GitRepo *GitRepoVolumeSource `json:"gitRepo,omitempty"`
+ GitRepo *GitRepoVolumeSource `json:"gitRepo,omitempty" protobuf:"bytes,5,opt,name=gitRepo"`
// Secret represents a secret that should populate this volume.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#secrets
- Secret *SecretVolumeSource `json:"secret,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets
+ Secret *SecretVolumeSource `json:"secret,omitempty" protobuf:"bytes,6,opt,name=secret"`
// NFS represents an NFS mount on the host that shares a pod's lifetime
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs
- NFS *NFSVolumeSource `json:"nfs,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ NFS *NFSVolumeSource `json:"nfs,omitempty" protobuf:"bytes,7,opt,name=nfs"`
// ISCSI represents an ISCSI Disk resource that is attached to a
// kubelet's host machine and then exposed to the pod.
- // More info: http://releases.k8s.io/release-1.2/examples/iscsi/README.md
- ISCSI *ISCSIVolumeSource `json:"iscsi,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/iscsi/README.md
+ ISCSI *ISCSIVolumeSource `json:"iscsi,omitempty" protobuf:"bytes,8,opt,name=iscsi"`
// Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime.
- // More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md
- Glusterfs *GlusterfsVolumeSource `json:"glusterfs,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md
+ Glusterfs *GlusterfsVolumeSource `json:"glusterfs,omitempty" protobuf:"bytes,9,opt,name=glusterfs"`
// PersistentVolumeClaimVolumeSource represents a reference to a
// PersistentVolumeClaim in the same namespace.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
- PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty" protobuf:"bytes,10,opt,name=persistentVolumeClaim"`
// RBD represents a Rados Block Device mount on the host that shares a pod's lifetime.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md
- RBD *RBDVolumeSource `json:"rbd,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md
+ RBD *RBDVolumeSource `json:"rbd,omitempty" protobuf:"bytes,11,opt,name=rbd"`
// FlexVolume represents a generic volume resource that is
// provisioned/attached using a exec based plugin. This is an
// alpha feature and may change in future.
- FlexVolume *FlexVolumeSource `json:"flexVolume,omitempty"`
+ FlexVolume *FlexVolumeSource `json:"flexVolume,omitempty" protobuf:"bytes,12,opt,name=flexVolume"`
// Cinder represents a cinder volume attached and mounted on kubelets host machine
- // More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md
- Cinder *CinderVolumeSource `json:"cinder,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ Cinder *CinderVolumeSource `json:"cinder,omitempty" protobuf:"bytes,13,opt,name=cinder"`
// CephFS represents a Ceph FS mount on the host that shares a pod's lifetime
- CephFS *CephFSVolumeSource `json:"cephfs,omitempty"`
+ CephFS *CephFSVolumeSource `json:"cephfs,omitempty" protobuf:"bytes,14,opt,name=cephfs"`
// Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running
- Flocker *FlockerVolumeSource `json:"flocker,omitempty"`
+ Flocker *FlockerVolumeSource `json:"flocker,omitempty" protobuf:"bytes,15,opt,name=flocker"`
// DownwardAPI represents downward API about the pod that should populate this volume
- DownwardAPI *DownwardAPIVolumeSource `json:"downwardAPI,omitempty"`
+ DownwardAPI *DownwardAPIVolumeSource `json:"downwardAPI,omitempty" protobuf:"bytes,16,opt,name=downwardAPI"`
// FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
- FC *FCVolumeSource `json:"fc,omitempty"`
+ FC *FCVolumeSource `json:"fc,omitempty" protobuf:"bytes,17,opt,name=fc"`
// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
- AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty"`
+ AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty" protobuf:"bytes,18,opt,name=azureFile"`
// ConfigMap represents a configMap that should populate this volume
- ConfigMap *ConfigMapVolumeSource `json:"configMap,omitempty"`
+ ConfigMap *ConfigMapVolumeSource `json:"configMap,omitempty" protobuf:"bytes,19,opt,name=configMap"`
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ VsphereVolume *VsphereVirtualDiskVolumeSource `json:"vsphereVolume,omitempty" protobuf:"bytes,20,opt,name=vsphereVolume"`
}
// PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace.
@@ -271,11 +285,11 @@ type VolumeSource struct {
// type of volume that is owned by someone else (the system).
type PersistentVolumeClaimVolumeSource struct {
// ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
- ClaimName string `json:"claimName"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ ClaimName string `json:"claimName" protobuf:"bytes,1,opt,name=claimName"`
// Will force the ReadOnly setting in VolumeMounts.
// Default false.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,2,opt,name=readOnly"`
}
// PersistentVolumeSource is similar to VolumeSource but meant for the
@@ -283,91 +297,93 @@ type PersistentVolumeClaimVolumeSource struct {
type PersistentVolumeSource struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
- GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk,omitempty" protobuf:"bytes,1,opt,name=gcePersistentDisk"`
// AWSElasticBlockStore represents an AWS Disk resource that is attached to a
// kubelet's host machine and then exposed to the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore
- AWSElasticBlockStore *AWSElasticBlockStoreVolumeSource `json:"awsElasticBlockStore,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ AWSElasticBlockStore *AWSElasticBlockStoreVolumeSource `json:"awsElasticBlockStore,omitempty" protobuf:"bytes,2,opt,name=awsElasticBlockStore"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath
- HostPath *HostPathVolumeSource `json:"hostPath,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
+ HostPath *HostPathVolumeSource `json:"hostPath,omitempty" protobuf:"bytes,3,opt,name=hostPath"`
// Glusterfs represents a Glusterfs volume that is attached to a host and
// exposed to the pod. Provisioned by an admin.
- // More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md
- Glusterfs *GlusterfsVolumeSource `json:"glusterfs,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md
+ Glusterfs *GlusterfsVolumeSource `json:"glusterfs,omitempty" protobuf:"bytes,4,opt,name=glusterfs"`
// NFS represents an NFS mount on the host. Provisioned by an admin.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs
- NFS *NFSVolumeSource `json:"nfs,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ NFS *NFSVolumeSource `json:"nfs,omitempty" protobuf:"bytes,5,opt,name=nfs"`
// RBD represents a Rados Block Device mount on the host that shares a pod's lifetime.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md
- RBD *RBDVolumeSource `json:"rbd,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md
+ RBD *RBDVolumeSource `json:"rbd,omitempty" protobuf:"bytes,6,opt,name=rbd"`
// 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.
- ISCSI *ISCSIVolumeSource `json:"iscsi,omitempty"`
+ ISCSI *ISCSIVolumeSource `json:"iscsi,omitempty" protobuf:"bytes,7,opt,name=iscsi"`
// Cinder represents a cinder volume attached and mounted on kubelets host machine
- // More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md
- Cinder *CinderVolumeSource `json:"cinder,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ Cinder *CinderVolumeSource `json:"cinder,omitempty" protobuf:"bytes,8,opt,name=cinder"`
// CephFS represents a Ceph FS mount on the host that shares a pod's lifetime
- CephFS *CephFSVolumeSource `json:"cephfs,omitempty"`
+ CephFS *CephFSVolumeSource `json:"cephfs,omitempty" protobuf:"bytes,9,opt,name=cephfs"`
// FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
- FC *FCVolumeSource `json:"fc,omitempty"`
+ FC *FCVolumeSource `json:"fc,omitempty" protobuf:"bytes,10,opt,name=fc"`
// 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
- Flocker *FlockerVolumeSource `json:"flocker,omitempty"`
+ Flocker *FlockerVolumeSource `json:"flocker,omitempty" protobuf:"bytes,11,opt,name=flocker"`
// FlexVolume represents a generic volume resource that is
// provisioned/attached using a exec based plugin. This is an
// alpha feature and may change in future.
- FlexVolume *FlexVolumeSource `json:"flexVolume,omitempty"`
+ FlexVolume *FlexVolumeSource `json:"flexVolume,omitempty" protobuf:"bytes,12,opt,name=flexVolume"`
// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
- AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty"`
+ AzureFile *AzureFileVolumeSource `json:"azureFile,omitempty" protobuf:"bytes,13,opt,name=azureFile"`
+ // VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
+ VsphereVolume *VsphereVirtualDiskVolumeSource `json:"vsphereVolume,omitempty" protobuf:"bytes,14,opt,name=vsphereVolume"`
}
// +genclient=true,nonNamespaced=true
// PersistentVolume (PV) is a storage resource provisioned by an administrator.
// It is analogous to a node.
-// More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md
+// More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md
type PersistentVolume struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines a specification of a persistent volume owned by the cluster.
// Provisioned by an administrator.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistent-volumes
- Spec PersistentVolumeSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes
+ Spec PersistentVolumeSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status represents the current information/status for the persistent volume.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistent-volumes
- Status PersistentVolumeStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes
+ Status PersistentVolumeStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// PersistentVolumeSpec is the specification of a persistent volume.
type PersistentVolumeSpec struct {
// A description of the persistent volume's resources and capacity.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#capacity
- Capacity ResourceList `json:"capacity,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity
+ Capacity ResourceList `json:"capacity,omitempty" protobuf:"bytes,1,rep,name=capacity,casttype=ResourceList,castkey=ResourceName"`
// The actual volume backing the persistent volume.
- PersistentVolumeSource `json:",inline"`
+ PersistentVolumeSource `json:",inline" protobuf:"bytes,2,opt,name=persistentVolumeSource"`
// AccessModes contains all ways the volume can be mounted.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes
- AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes
+ AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty" protobuf:"bytes,3,rep,name=accessModes,casttype=PersistentVolumeAccessMode"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#binding
- ClaimRef *ObjectReference `json:"claimRef,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#binding
+ ClaimRef *ObjectReference `json:"claimRef,omitempty" protobuf:"bytes,4,opt,name=claimRef"`
// What happens to a persistent volume when released from its claim.
// Valid options are Retain (default) and Recycle.
// Recyling must be supported by the volume plugin underlying this persistent volume.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#recycling-policy
- PersistentVolumeReclaimPolicy PersistentVolumeReclaimPolicy `json:"persistentVolumeReclaimPolicy,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#recycling-policy
+ PersistentVolumeReclaimPolicy PersistentVolumeReclaimPolicy `json:"persistentVolumeReclaimPolicy,omitempty" protobuf:"bytes,5,opt,name=persistentVolumeReclaimPolicy,casttype=PersistentVolumeReclaimPolicy"`
}
// PersistentVolumeReclaimPolicy describes a policy for end-of-life maintenance of persistent volumes.
@@ -380,7 +396,7 @@ const (
// PersistentVolumeReclaimDelete means the volume will be deleted from Kubernetes on release from its claim.
// The volume plugin must support Deletion.
PersistentVolumeReclaimDelete PersistentVolumeReclaimPolicy = "Delete"
- // PersistentVolumeReclaimRetain means the volume will left in its current phase (Released) for manual reclamation by the administrator.
+ // PersistentVolumeReclaimRetain means the volume will be left in its current phase (Released) for manual reclamation by the administrator.
// The default policy is Retain.
PersistentVolumeReclaimRetain PersistentVolumeReclaimPolicy = "Retain"
)
@@ -388,76 +404,78 @@ const (
// PersistentVolumeStatus is the current status of a persistent volume.
type PersistentVolumeStatus struct {
// Phase indicates if a volume is available, bound to a claim, or released by a claim.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#phase
- Phase PersistentVolumePhase `json:"phase,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#phase
+ Phase PersistentVolumePhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=PersistentVolumePhase"`
// A human-readable message indicating details about why the volume is in this state.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"`
// Reason is a brief CamelCase string that describes any failure and is meant
// for machine parsing and tidy display in the CLI.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,3,opt,name=reason"`
}
// PersistentVolumeList is a list of PersistentVolume items.
type PersistentVolumeList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of persistent volumes.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md
- Items []PersistentVolume `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md
+ Items []PersistentVolume `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// PersistentVolumeClaim is a user's request for and claim to a persistent volume
type PersistentVolumeClaim struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the desired characteristics of a volume requested by a pod author.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
- Spec PersistentVolumeClaimSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ Spec PersistentVolumeClaimSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status represents the current information/status of a persistent volume claim.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
- Status PersistentVolumeClaimStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ Status PersistentVolumeClaimStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// PersistentVolumeClaimList is a list of PersistentVolumeClaim items.
type PersistentVolumeClaimList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// A list of persistent volume claims.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
- Items []PersistentVolumeClaim `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims
+ Items []PersistentVolumeClaim `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// PersistentVolumeClaimSpec describes the common attributes of storage devices
// and allows a Source for provider-specific attributes
type PersistentVolumeClaimSpec struct {
// AccessModes contains the desired access modes the volume should have.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes-1
- AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1
+ AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty" protobuf:"bytes,1,rep,name=accessModes,casttype=PersistentVolumeAccessMode"`
+ // A label query over volumes to consider for binding.
+ Selector *unversioned.LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"`
// Resources represents the minimum resources the volume should have.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#resources
- Resources ResourceRequirements `json:"resources,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources
+ Resources ResourceRequirements `json:"resources,omitempty" protobuf:"bytes,2,opt,name=resources"`
// VolumeName is the binding reference to the PersistentVolume backing this claim.
- VolumeName string `json:"volumeName,omitempty"`
+ VolumeName string `json:"volumeName,omitempty" protobuf:"bytes,3,opt,name=volumeName"`
}
// PersistentVolumeClaimStatus is the current status of a persistent volume claim.
type PersistentVolumeClaimStatus struct {
// Phase represents the current phase of PersistentVolumeClaim.
- Phase PersistentVolumeClaimPhase `json:"phase,omitempty"`
+ Phase PersistentVolumeClaimPhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=PersistentVolumeClaimPhase"`
// AccessModes contains the actual access modes the volume backing the PVC has.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes-1
- AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1
+ AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty" protobuf:"bytes,2,rep,name=accessModes,casttype=PersistentVolumeAccessMode"`
// Represents the actual resources of the underlying volume.
- Capacity ResourceList `json:"capacity,omitempty"`
+ Capacity ResourceList `json:"capacity,omitempty" protobuf:"bytes,3,rep,name=capacity,casttype=ResourceList,castkey=ResourceName"`
}
type PersistentVolumeAccessMode string
@@ -496,14 +514,18 @@ const (
ClaimPending PersistentVolumeClaimPhase = "Pending"
// used for PersistentVolumeClaims that are bound
ClaimBound PersistentVolumeClaimPhase = "Bound"
+ // 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.
+ ClaimLost PersistentVolumeClaimPhase = "Lost"
)
// Represents a host path mapped into a pod.
// Host path volumes do not support ownership management or SELinux relabeling.
type HostPathVolumeSource struct {
// Path of the directory on the host.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath
- Path string `json:"path"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath
+ Path string `json:"path" protobuf:"bytes,1,opt,name=path"`
}
// Represents an empty directory for a pod.
@@ -512,63 +534,63 @@ type EmptyDirVolumeSource struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#emptydir
- Medium StorageMedium `json:"medium,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir
+ Medium StorageMedium `json:"medium,omitempty" protobuf:"bytes,1,opt,name=medium,casttype=StorageMedium"`
}
// Represents a Glusterfs mount that lasts the lifetime of a pod.
// Glusterfs volumes do not support ownership management or SELinux relabeling.
type GlusterfsVolumeSource struct {
// EndpointsName is the endpoint name that details Glusterfs topology.
- // More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod
- EndpointsName string `json:"endpoints"`
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ EndpointsName string `json:"endpoints" protobuf:"bytes,1,opt,name=endpoints"`
// Path is the Glusterfs volume path.
- // More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod
- Path string `json:"path"`
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ Path string `json:"path" protobuf:"bytes,2,opt,name=path"`
// ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions.
// Defaults to false.
- // More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,3,opt,name=readOnly"`
}
// Represents a Rados Block Device mount that lasts the lifetime of a pod.
// RBD volumes support ownership management and SELinux relabeling.
type RBDVolumeSource struct {
// A collection of Ceph monitors.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- CephMonitors []string `json:"monitors"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ CephMonitors []string `json:"monitors" protobuf:"bytes,1,rep,name=monitors"`
// The rados image name.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- RBDImage string `json:"image"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ RBDImage string `json:"image" protobuf:"bytes,2,opt,name=image"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#rbd
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#rbd
// TODO: how do we prevent errors in the filesystem from compromising the machine
- FSType string `json:"fsType,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,3,opt,name=fsType"`
// The rados pool name.
// Default is rbd.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it.
- RBDPool string `json:"pool"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it.
+ RBDPool string `json:"pool,omitempty" protobuf:"bytes,4,opt,name=pool"`
// The rados user name.
// Default is admin.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- RadosUser string `json:"user"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ RadosUser string `json:"user,omitempty" protobuf:"bytes,5,opt,name=user"`
// Keyring is the path to key ring for RBDUser.
// Default is /etc/ceph/keyring.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- Keyring string `json:"keyring"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ Keyring string `json:"keyring,omitempty" protobuf:"bytes,6,opt,name=keyring"`
// SecretRef is name of the authentication secret for RBDUser. If provided
// overrides keyring.
- // Default is empty.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- SecretRef *LocalObjectReference `json:"secretRef"`
+ // Default is nil.
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ SecretRef *LocalObjectReference `json:"secretRef,omitempty" protobuf:"bytes,7,opt,name=secretRef"`
// ReadOnly here will force the ReadOnly setting in VolumeMounts.
// Defaults to false.
- // More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,8,opt,name=readOnly"`
}
// Represents a cinder volume resource in Openstack.
@@ -577,47 +599,47 @@ type RBDVolumeSource struct {
// Cinder volumes support ownership management and SELinux relabeling.
type CinderVolumeSource struct {
// volume id used to identify the volume in cinder
- // More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md
- VolumeID string `json:"volumeID"`
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ VolumeID string `json:"volumeID" protobuf:"bytes,1,opt,name=volumeID"`
// 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: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md
- FSType string `json:"fsType,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
- // More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,3,opt,name=readOnly"`
}
// Represents a Ceph Filesystem mount that lasts the lifetime of a pod
// Cephfs volumes do not support ownership management or SELinux relabeling.
type CephFSVolumeSource struct {
// Required: Monitors is a collection of Ceph monitors
- // More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it
- Monitors []string `json:"monitors"`
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ Monitors []string `json:"monitors" protobuf:"bytes,1,rep,name=monitors"`
// Optional: Used as the mounted root, rather than the full Ceph tree, default is /
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,2,opt,name=path"`
// Optional: User is the rados user name, default is admin
- // More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it
- User string `json:"user,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ User string `json:"user,omitempty" protobuf:"bytes,3,opt,name=user"`
// Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret
- // More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it
- SecretFile string `json:"secretFile,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ SecretFile string `json:"secretFile,omitempty" protobuf:"bytes,4,opt,name=secretFile"`
// Optional: SecretRef is reference to the authentication secret for User, default is empty.
- // More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it
- SecretRef *LocalObjectReference `json:"secretRef,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ SecretRef *LocalObjectReference `json:"secretRef,omitempty" protobuf:"bytes,5,opt,name=secretRef"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
- // More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,6,opt,name=readOnly"`
}
// Represents a Flocker volume mounted by the Flocker agent.
// Flocker volumes do not support ownership management or SELinux relabeling.
type FlockerVolumeSource struct {
// Required: the volume name. This is going to be store on metadata -> name on the payload for Flocker
- DatasetName string `json:"datasetName"`
+ DatasetName string `json:"datasetName" protobuf:"bytes,1,opt,name=datasetName"`
}
// StorageMedium defines ways that storage can be allocated to a volume.
@@ -646,42 +668,46 @@ const (
// PDs support ownership management and SELinux relabeling.
type GCEPersistentDiskVolumeSource struct {
// Unique name of the PD resource in GCE. Used to identify the disk in GCE.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
- PDName string `json:"pdName"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ PDName string `json:"pdName" protobuf:"bytes,1,opt,name=pdName"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
// TODO: how do we prevent errors in the filesystem from compromising the machine
- FSType string `json:"fsType,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
- Partition int32 `json:"partition,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ Partition int32 `json:"partition,omitempty" protobuf:"varint,3,opt,name=partition"`
// ReadOnly here will force the ReadOnly setting in VolumeMounts.
// Defaults to false.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,4,opt,name=readOnly"`
}
// FlexVolume represents a generic volume resource that is
// provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.
type FlexVolumeSource struct {
// Driver is the name of the driver to use for this volume.
- Driver string `json:"driver"`
+ Driver string `json:"driver" protobuf:"bytes,1,opt,name=driver"`
// 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.
- FSType string `json:"fsType,omitempty"`
- // Optional: SecretRef is reference to the authentication secret for User, default is empty.
- SecretRef *LocalObjectReference `json:"secretRef,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"`
+ // 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.
+ SecretRef *LocalObjectReference `json:"secretRef,omitempty" protobuf:"bytes,3,opt,name=secretRef"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,4,opt,name=readOnly"`
// Optional: Extra command options if any.
- Options map[string]string `json:"options,omitempty"`
+ Options map[string]string `json:"options,omitempty" protobuf:"bytes,5,rep,name=options"`
}
// Represents a Persistent Disk resource in AWS.
@@ -692,23 +718,23 @@ type FlexVolumeSource struct {
// ownership management and SELinux relabeling.
type AWSElasticBlockStoreVolumeSource struct {
// Unique ID of the persistent disk resource in AWS (Amazon EBS volume).
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore
- VolumeID string `json:"volumeID"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ VolumeID string `json:"volumeID" protobuf:"bytes,1,opt,name=volumeID"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
// TODO: how do we prevent errors in the filesystem from compromising the machine
- FSType string `json:"fsType,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"`
// 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).
- Partition int32 `json:"partition,omitempty"`
+ Partition int32 `json:"partition,omitempty" protobuf:"varint,3,opt,name=partition"`
// Specify "true" to force and set the ReadOnly property in VolumeMounts to "true".
// If omitted, the default is "false".
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,4,opt,name=readOnly"`
}
// Represents a volume that is populated with the contents of a git repository.
@@ -716,14 +742,14 @@ type AWSElasticBlockStoreVolumeSource struct {
// Git repo volumes support SELinux relabeling.
type GitRepoVolumeSource struct {
// Repository URL
- Repository string `json:"repository"`
+ Repository string `json:"repository" protobuf:"bytes,1,opt,name=repository"`
// Commit hash for the specified revision.
- Revision string `json:"revision,omitempty"`
+ Revision string `json:"revision,omitempty" protobuf:"bytes,2,opt,name=revision"`
// 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.
- Directory string `json:"directory,omitempty"`
+ Directory string `json:"directory,omitempty" protobuf:"bytes,3,opt,name=directory"`
}
// Adapts a Secret into a volume.
@@ -733,26 +759,34 @@ type GitRepoVolumeSource struct {
// Secret volumes support ownership management and SELinux relabeling.
type SecretVolumeSource struct {
// Name of the secret in the pod's namespace to use.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#secrets
- SecretName string `json:"secretName,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets
+ SecretName string `json:"secretName,omitempty" protobuf:"bytes,1,opt,name=secretName"`
+ // 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. Paths must be relative and may not contain
+ // the '..' path or start with '..'.
+ Items []KeyToPath `json:"items,omitempty" protobuf:"bytes,2,rep,name=items"`
}
// Represents an NFS mount that lasts the lifetime of a pod.
// NFS volumes do not support ownership management or SELinux relabeling.
type NFSVolumeSource struct {
// Server is the hostname or IP address of the NFS server.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs
- Server string `json:"server"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ Server string `json:"server" protobuf:"bytes,1,opt,name=server"`
// Path that is exported by the NFS server.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs
- Path string `json:"path"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ Path string `json:"path" protobuf:"bytes,2,opt,name=path"`
// ReadOnly here will force
// the NFS export to be mounted with read-only permissions.
// Defaults to false.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs
- ReadOnly bool `json:"readOnly,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,3,opt,name=readOnly"`
}
// Represents an ISCSI disk.
@@ -761,22 +795,22 @@ type NFSVolumeSource struct {
type ISCSIVolumeSource struct {
// 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).
- TargetPortal string `json:"targetPortal"`
+ TargetPortal string `json:"targetPortal" protobuf:"bytes,1,opt,name=targetPortal"`
// Target iSCSI Qualified Name.
- IQN string `json:"iqn"`
+ IQN string `json:"iqn" protobuf:"bytes,2,opt,name=iqn"`
// iSCSI target lun number.
- Lun int32 `json:"lun"`
+ Lun int32 `json:"lun" protobuf:"varint,3,opt,name=lun"`
// Optional: Defaults to 'default' (tcp). iSCSI interface name that uses an iSCSI transport.
- ISCSIInterface string `json:"iscsiInterface,omitempty"`
+ ISCSIInterface string `json:"iscsiInterface,omitempty" protobuf:"bytes,4,opt,name=iscsiInterface"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#iscsi
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#iscsi
// TODO: how do we prevent errors in the filesystem from compromising the machine
- FSType string `json:"fsType,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,5,opt,name=fsType"`
// ReadOnly here will force the ReadOnly setting in VolumeMounts.
// Defaults to false.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,6,opt,name=readOnly"`
}
// Represents a Fibre Channel volume.
@@ -784,28 +818,38 @@ type ISCSIVolumeSource struct {
// Fibre Channel volumes support ownership management and SELinux relabeling.
type FCVolumeSource struct {
// Required: FC target world wide names (WWNs)
- TargetWWNs []string `json:"targetWWNs"`
+ TargetWWNs []string `json:"targetWWNs" protobuf:"bytes,1,rep,name=targetWWNs"`
// Required: FC target lun number
- Lun *int32 `json:"lun"`
+ Lun *int32 `json:"lun" protobuf:"varint,2,opt,name=lun"`
// 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
- FSType string `json:"fsType,omitempty"`
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,3,opt,name=fsType"`
// Optional: Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,4,opt,name=readOnly"`
}
// AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
type AzureFileVolumeSource struct {
// the name of secret that contains Azure Storage Account Name and Key
- SecretName string `json:"secretName"`
+ SecretName string `json:"secretName" protobuf:"bytes,1,opt,name=secretName"`
// Share Name
- ShareName string `json:"shareName"`
+ ShareName string `json:"shareName" protobuf:"bytes,2,opt,name=shareName"`
// Defaults to false (read/write). ReadOnly here will force
// the ReadOnly setting in VolumeMounts.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,3,opt,name=readOnly"`
+}
+
+// Represents a vSphere volume resource.
+type VsphereVirtualDiskVolumeSource struct {
+ // Path that identifies vSphere volume vmdk
+ VolumePath string `json:"volumePath" protobuf:"bytes,1,opt,name=volumePath"`
+ // 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.
+ FSType string `json:"fsType,omitempty" protobuf:"bytes,2,opt,name=fsType"`
}
// Adapts a ConfigMap into a volume.
@@ -815,7 +859,7 @@ type AzureFileVolumeSource struct {
// the items element is populated with specific mappings of keys to paths.
// ConfigMap volumes support ownership management and SELinux relabeling.
type ConfigMapVolumeSource struct {
- LocalObjectReference `json:",inline"`
+ LocalObjectReference `json:",inline" protobuf:"bytes,1,opt,name=localObjectReference"`
// 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
@@ -823,19 +867,19 @@ type ConfigMapVolumeSource struct {
// present. If a key is specified which is not present in the ConfigMap,
// the volume setup will error. Paths must be relative and may not contain
// the '..' path or start with '..'.
- Items []KeyToPath `json:"items,omitempty"`
+ Items []KeyToPath `json:"items,omitempty" protobuf:"bytes,2,rep,name=items"`
}
// Maps a string key to a path within a volume.
type KeyToPath struct {
// The key to project.
- Key string `json:"key"`
+ Key string `json:"key" protobuf:"bytes,1,opt,name=key"`
// 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 '..'.
- Path string `json:"path"`
+ Path string `json:"path" protobuf:"bytes,2,opt,name=path"`
}
// ContainerPort represents a network port in a single container.
@@ -843,38 +887,41 @@ type ContainerPort struct {
// 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.
- Name string `json:"name,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
// 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.
- HostPort int32 `json:"hostPort,omitempty"`
+ HostPort int32 `json:"hostPort,omitempty" protobuf:"varint,2,opt,name=hostPort"`
// Number of port to expose on the pod's IP address.
// This must be a valid port number, 0 < x < 65536.
- ContainerPort int32 `json:"containerPort"`
+ ContainerPort int32 `json:"containerPort" protobuf:"varint,3,opt,name=containerPort"`
// Protocol for port. Must be UDP or TCP.
// Defaults to "TCP".
- Protocol Protocol `json:"protocol,omitempty"`
+ Protocol Protocol `json:"protocol,omitempty" protobuf:"bytes,4,opt,name=protocol,casttype=Protocol"`
// What host IP to bind the external port to.
- HostIP string `json:"hostIP,omitempty"`
+ HostIP string `json:"hostIP,omitempty" protobuf:"bytes,5,opt,name=hostIP"`
}
// VolumeMount describes a mounting of a Volume within a container.
type VolumeMount struct {
// This must match the Name of a Volume.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Mounted read-only if true, read-write otherwise (false or unspecified).
// Defaults to false.
- ReadOnly bool `json:"readOnly,omitempty"`
+ ReadOnly bool `json:"readOnly,omitempty" protobuf:"varint,2,opt,name=readOnly"`
// Path within the container at which the volume should be mounted. Must
// not contain ':'.
- MountPath string `json:"mountPath"`
+ MountPath string `json:"mountPath" protobuf:"bytes,3,opt,name=mountPath"`
+ // Path within the volume from which the container's volume should be mounted.
+ // Defaults to "" (volume's root).
+ SubPath string `json:"subPath,omitempty" protobuf:"bytes,4,opt,name=subPath"`
}
// EnvVar represents an environment variable present in a Container.
type EnvVar struct {
// Name of the environment variable. Must be a C_IDENTIFIER.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Optional: no more than one of the following may be specified.
@@ -886,69 +933,82 @@ type EnvVar struct {
// references will never be expanded, regardless of whether the variable
// exists or not.
// Defaults to "".
- Value string `json:"value,omitempty"`
+ Value string `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"`
// Source for the environment variable's value. Cannot be used if value is not empty.
- ValueFrom *EnvVarSource `json:"valueFrom,omitempty"`
+ ValueFrom *EnvVarSource `json:"valueFrom,omitempty" protobuf:"bytes,3,opt,name=valueFrom"`
}
// EnvVarSource represents a source for the value of an EnvVar.
type EnvVarSource struct {
// Selects a field of the pod; only name and namespace are supported.
- FieldRef *ObjectFieldSelector `json:"fieldRef,omitempty"`
+ FieldRef *ObjectFieldSelector `json:"fieldRef,omitempty" protobuf:"bytes,1,opt,name=fieldRef"`
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ ResourceFieldRef *ResourceFieldSelector `json:"resourceFieldRef,omitempty" protobuf:"bytes,2,opt,name=resourceFieldRef"`
// Selects a key of a ConfigMap.
- ConfigMapKeyRef *ConfigMapKeySelector `json:"configMapKeyRef,omitempty"`
+ ConfigMapKeyRef *ConfigMapKeySelector `json:"configMapKeyRef,omitempty" protobuf:"bytes,3,opt,name=configMapKeyRef"`
// Selects a key of a secret in the pod's namespace
- SecretKeyRef *SecretKeySelector `json:"secretKeyRef,omitempty"`
+ SecretKeyRef *SecretKeySelector `json:"secretKeyRef,omitempty" protobuf:"bytes,4,opt,name=secretKeyRef"`
}
// ObjectFieldSelector selects an APIVersioned field of an object.
type ObjectFieldSelector struct {
// Version of the schema the FieldPath is written in terms of, defaults to "v1".
- APIVersion string `json:"apiVersion,omitempty"`
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"`
// Path of the field to select in the specified API version.
- FieldPath string `json:"fieldPath"`
+ FieldPath string `json:"fieldPath" protobuf:"bytes,2,opt,name=fieldPath"`
+}
+
+// ResourceFieldSelector represents container resources (cpu, memory) and their output format
+type ResourceFieldSelector struct {
+ // Container name: required for volumes, optional for env vars
+ ContainerName string `json:"containerName,omitempty" protobuf:"bytes,1,opt,name=containerName"`
+ // Required: resource to select
+ Resource string `json:"resource" protobuf:"bytes,2,opt,name=resource"`
+ // Specifies the output format of the exposed resources, defaults to "1"
+ Divisor resource.Quantity `json:"divisor,omitempty" protobuf:"bytes,3,opt,name=divisor"`
}
// Selects a key from a ConfigMap.
type ConfigMapKeySelector struct {
// The ConfigMap to select from.
- LocalObjectReference `json:",inline"`
+ LocalObjectReference `json:",inline" protobuf:"bytes,1,opt,name=localObjectReference"`
// The key to select.
- Key string `json:"key"`
+ Key string `json:"key" protobuf:"bytes,2,opt,name=key"`
}
// SecretKeySelector selects a key of a Secret.
type SecretKeySelector struct {
// The name of the secret in the pod's namespace to select from.
- LocalObjectReference `json:",inline"`
+ LocalObjectReference `json:",inline" protobuf:"bytes,1,opt,name=localObjectReference"`
// The key of the secret to select from. Must be a valid secret key.
- Key string `json:"key"`
+ Key string `json:"key" protobuf:"bytes,2,opt,name=key"`
}
// HTTPHeader describes a custom header to be used in HTTP probes
type HTTPHeader struct {
// The header field name
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// The header field value
- Value string `json:"value"`
+ Value string `json:"value" protobuf:"bytes,2,opt,name=value"`
}
// HTTPGetAction describes an action based on HTTP Get requests.
type HTTPGetAction struct {
// Path to access on the HTTP server.
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,1,opt,name=path"`
// 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.
- Port intstr.IntOrString `json:"port"`
+ Port intstr.IntOrString `json:"port" protobuf:"bytes,2,opt,name=port"`
// Host name to connect to, defaults to the pod IP. You probably want to set
// "Host" in httpHeaders instead.
- Host string `json:"host,omitempty"`
+ Host string `json:"host,omitempty" protobuf:"bytes,3,opt,name=host"`
// Scheme to use for connecting to the host.
// Defaults to HTTP.
- Scheme URIScheme `json:"scheme,omitempty"`
+ Scheme URIScheme `json:"scheme,omitempty" protobuf:"bytes,4,opt,name=scheme,casttype=URIScheme"`
// Custom headers to set in the request. HTTP allows repeated headers.
- HTTPHeaders []HTTPHeader `json:"httpHeaders,omitempty"`
+ HTTPHeaders []HTTPHeader `json:"httpHeaders,omitempty" protobuf:"bytes,5,rep,name=httpHeaders"`
}
// URIScheme identifies the scheme used for connection to a host for Get actions
@@ -966,7 +1026,7 @@ type TCPSocketAction struct {
// 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.
- Port intstr.IntOrString `json:"port"`
+ Port intstr.IntOrString `json:"port" protobuf:"bytes,1,opt,name=port"`
}
// ExecAction describes a "run in container" action.
@@ -976,30 +1036,30 @@ type ExecAction struct {
// 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.
- Command []string `json:"command,omitempty"`
+ Command []string `json:"command,omitempty" protobuf:"bytes,1,rep,name=command"`
}
// Probe describes a health check to be performed against a container to determine whether it is
// alive or ready to receive traffic.
type Probe struct {
// The action taken to determine the health of a container
- Handler `json:",inline"`
+ Handler `json:",inline" protobuf:"bytes,1,opt,name=handler"`
// Number of seconds after the container has started before liveness probes are initiated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes
- InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty" protobuf:"varint,2,opt,name=initialDelaySeconds"`
// Number of seconds after which the probe times out.
// Defaults to 1 second. Minimum value is 1.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes
- TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ TimeoutSeconds int32 `json:"timeoutSeconds,omitempty" protobuf:"varint,3,opt,name=timeoutSeconds"`
// How often (in seconds) to perform the probe.
// Default to 10 seconds. Minimum value is 1.
- PeriodSeconds int32 `json:"periodSeconds,omitempty"`
+ PeriodSeconds int32 `json:"periodSeconds,omitempty" protobuf:"varint,4,opt,name=periodSeconds"`
// Minimum consecutive successes for the probe to be considered successful after having failed.
// Defaults to 1. Must be 1 for liveness. Minimum value is 1.
- SuccessThreshold int32 `json:"successThreshold,omitempty"`
+ SuccessThreshold int32 `json:"successThreshold,omitempty" protobuf:"varint,5,opt,name=successThreshold"`
// Minimum consecutive failures for the probe to be considered failed after having succeeded.
// Defaults to 3. Minimum value is 1.
- FailureThreshold int32 `json:"failureThreshold,omitempty"`
+ FailureThreshold int32 `json:"failureThreshold,omitempty" protobuf:"varint,6,opt,name=failureThreshold"`
}
// PullPolicy describes a policy for if/when to pull a container image
@@ -1020,21 +1080,21 @@ type Capability string
// Adds and removes POSIX capabilities from running containers.
type Capabilities struct {
// Added capabilities
- Add []Capability `json:"add,omitempty"`
+ Add []Capability `json:"add,omitempty" protobuf:"bytes,1,rep,name=add,casttype=Capability"`
// Removed capabilities
- Drop []Capability `json:"drop,omitempty"`
+ Drop []Capability `json:"drop,omitempty" protobuf:"bytes,2,rep,name=drop,casttype=Capability"`
}
// ResourceRequirements describes the compute resource requirements.
type ResourceRequirements struct {
// Limits describes the maximum amount of compute resources allowed.
- // More info: http://releases.k8s.io/release-1.2/docs/design/resources.md#resource-specifications
- Limits ResourceList `json:"limits,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications
+ Limits ResourceList `json:"limits,omitempty" protobuf:"bytes,1,rep,name=limits,casttype=ResourceList,castkey=ResourceName"`
// 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: http://releases.k8s.io/release-1.2/docs/design/resources.md#resource-specifications
- Requests ResourceList `json:"requests,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications
+ Requests ResourceList `json:"requests,omitempty" protobuf:"bytes,2,rep,name=requests,casttype=ResourceList,castkey=ResourceName"`
}
const (
@@ -1047,10 +1107,10 @@ type Container struct {
// Name of the container specified as a DNS_LABEL.
// Each container in a pod must have a unique name (DNS_LABEL).
// Cannot be updated.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Docker image name.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md
- Image string `json:"image,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md
+ Image string `json:"image,omitempty" protobuf:"bytes,2,opt,name=image"`
// 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
@@ -1058,8 +1118,8 @@ type Container struct {
// can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded,
// regardless of whether the variable exists or not.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md#containers-and-commands
- Command []string `json:"command,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands
+ Command []string `json:"command,omitempty" protobuf:"bytes,3,rep,name=command"`
// 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
@@ -1067,13 +1127,13 @@ type Container struct {
// can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded,
// regardless of whether the variable exists or not.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md#containers-and-commands
- Args []string `json:"args,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands
+ Args []string `json:"args,omitempty" protobuf:"bytes,4,rep,name=args"`
// 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.
- WorkingDir string `json:"workingDir,omitempty"`
+ WorkingDir string `json:"workingDir,omitempty" protobuf:"bytes,5,opt,name=workingDir"`
// 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
@@ -1081,45 +1141,45 @@ type Container struct {
// listening on the default "0.0.0.0" address inside a container will be
// accessible from the network.
// Cannot be updated.
- Ports []ContainerPort `json:"ports,omitempty" patchStrategy:"merge" patchMergeKey:"containerPort"`
+ Ports []ContainerPort `json:"ports,omitempty" patchStrategy:"merge" patchMergeKey:"containerPort" protobuf:"bytes,6,rep,name=ports"`
// List of environment variables to set in the container.
// Cannot be updated.
- Env []EnvVar `json:"env,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
+ Env []EnvVar `json:"env,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,7,rep,name=env"`
// Compute Resources required by this container.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#resources
- Resources ResourceRequirements `json:"resources,omitempty"`
- // Pod volumes to mount into the container's filesyste.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources
+ Resources ResourceRequirements `json:"resources,omitempty" protobuf:"bytes,8,opt,name=resources"`
+ // Pod volumes to mount into the container's filesystem.
// Cannot be updated.
- VolumeMounts []VolumeMount `json:"volumeMounts,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
+ VolumeMounts []VolumeMount `json:"volumeMounts,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,9,rep,name=volumeMounts"`
// Periodic probe of container liveness.
// Container will be restarted if the probe fails.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes
- LivenessProbe *Probe `json:"livenessProbe,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ LivenessProbe *Probe `json:"livenessProbe,omitempty" protobuf:"bytes,10,opt,name=livenessProbe"`
// Periodic probe of container service readiness.
// Container will be removed from service endpoints if the probe fails.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes
- ReadinessProbe *Probe `json:"readinessProbe,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes
+ ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
// Actions that the management system should take in response to container lifecycle events.
// Cannot be updated.
- Lifecycle *Lifecycle `json:"lifecycle,omitempty"`
+ Lifecycle *Lifecycle `json:"lifecycle,omitempty" protobuf:"bytes,12,opt,name=lifecycle"`
// 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.
// Defaults to /dev/termination-log.
// Cannot be updated.
- TerminationMessagePath string `json:"terminationMessagePath,omitempty"`
+ TerminationMessagePath string `json:"terminationMessagePath,omitempty" protobuf:"bytes,13,opt,name=terminationMessagePath"`
// Image pull policy.
// One of Always, Never, IfNotPresent.
// Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md#updating-images
- ImagePullPolicy PullPolicy `json:"imagePullPolicy,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#updating-images
+ ImagePullPolicy PullPolicy `json:"imagePullPolicy,omitempty" protobuf:"bytes,14,opt,name=imagePullPolicy,casttype=PullPolicy"`
// Security options the pod should run with.
- // More info: http://releases.k8s.io/release-1.2/docs/design/security_context.md
- SecurityContext *SecurityContext `json:"securityContext,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md
+ SecurityContext *SecurityContext `json:"securityContext,omitempty" protobuf:"bytes,15,opt,name=securityContext"`
// Variables for interactive containers, these have very specialized use-cases (e.g. debugging)
// and shouldn't be used for general purpose containers.
@@ -1127,7 +1187,7 @@ type Container struct {
// 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.
- Stdin bool `json:"stdin,omitempty"`
+ Stdin bool `json:"stdin,omitempty" protobuf:"varint,16,opt,name=stdin"`
// 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
@@ -1135,10 +1195,10 @@ type Container struct {
// 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
- StdinOnce bool `json:"stdinOnce,omitempty"`
+ StdinOnce bool `json:"stdinOnce,omitempty" protobuf:"varint,17,opt,name=stdinOnce"`
// Whether this container should allocate a TTY for itself, also requires 'stdin' to be true.
// Default is false.
- TTY bool `json:"tty,omitempty"`
+ TTY bool `json:"tty,omitempty" protobuf:"varint,18,opt,name=tty"`
}
// Handler defines a specific action that should be taken
@@ -1146,13 +1206,13 @@ type Container struct {
type Handler struct {
// One and only one of the following should be specified.
// Exec specifies the action to take.
- Exec *ExecAction `json:"exec,omitempty"`
+ Exec *ExecAction `json:"exec,omitempty" protobuf:"bytes,1,opt,name=exec"`
// HTTPGet specifies the http request to perform.
- HTTPGet *HTTPGetAction `json:"httpGet,omitempty"`
+ HTTPGet *HTTPGetAction `json:"httpGet,omitempty" protobuf:"bytes,2,opt,name=httpGet"`
// TCPSocket specifies an action involving a TCP port.
// TCP hooks not yet supported
// TODO: implement a realistic TCP lifecycle hook
- TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty"`
+ TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty" protobuf:"bytes,3,opt,name=tcpSocket"`
}
// Lifecycle describes actions that the management system should take in response to container lifecycle
@@ -1162,15 +1222,15 @@ type Lifecycle struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#hook-details
- PostStart *Handler `json:"postStart,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details
+ PostStart *Handler `json:"postStart,omitempty" protobuf:"bytes,1,opt,name=postStart"`
// PreStop is called immediately before a container is terminated.
// The container is terminated after the handler completes.
// The reason for termination is passed to the handler.
// Regardless of the outcome of the handler, the container is eventually terminated.
// Other management of the container blocks until the hook completes.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#hook-details
- PreStop *Handler `json:"preStop,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details
+ PreStop *Handler `json:"preStop,omitempty" protobuf:"bytes,2,opt,name=preStop"`
}
type ConditionStatus string
@@ -1188,33 +1248,33 @@ const (
// ContainerStateWaiting is a waiting state of a container.
type ContainerStateWaiting struct {
// (brief) reason the container is not yet running.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,1,opt,name=reason"`
// Message regarding why the container is not yet running.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,2,opt,name=message"`
}
// ContainerStateRunning is a running state of a container.
type ContainerStateRunning struct {
// Time at which the container was last (re-)started
- StartedAt unversioned.Time `json:"startedAt,omitempty"`
+ StartedAt unversioned.Time `json:"startedAt,omitempty" protobuf:"bytes,1,opt,name=startedAt"`
}
// ContainerStateTerminated is a terminated state of a container.
type ContainerStateTerminated struct {
// Exit status from the last termination of the container
- ExitCode int32 `json:"exitCode"`
+ ExitCode int32 `json:"exitCode" protobuf:"varint,1,opt,name=exitCode"`
// Signal from the last termination of the container
- Signal int32 `json:"signal,omitempty"`
+ Signal int32 `json:"signal,omitempty" protobuf:"varint,2,opt,name=signal"`
// (brief) reason from the last termination of the container
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,3,opt,name=reason"`
// Message regarding the last termination of the container
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,4,opt,name=message"`
// Time at which previous execution of the container started
- StartedAt unversioned.Time `json:"startedAt,omitempty"`
+ StartedAt unversioned.Time `json:"startedAt,omitempty" protobuf:"bytes,5,opt,name=startedAt"`
// Time at which the container last terminated
- FinishedAt unversioned.Time `json:"finishedAt,omitempty"`
+ FinishedAt unversioned.Time `json:"finishedAt,omitempty" protobuf:"bytes,6,opt,name=finishedAt"`
// Container's ID in the format 'docker://<container_id>'
- ContainerID string `json:"containerID,omitempty"`
+ ContainerID string `json:"containerID,omitempty" protobuf:"bytes,7,opt,name=containerID"`
}
// ContainerState holds a possible state of container.
@@ -1222,38 +1282,38 @@ type ContainerStateTerminated struct {
// If none of them is specified, the default one is ContainerStateWaiting.
type ContainerState struct {
// Details about a waiting container
- Waiting *ContainerStateWaiting `json:"waiting,omitempty"`
+ Waiting *ContainerStateWaiting `json:"waiting,omitempty" protobuf:"bytes,1,opt,name=waiting"`
// Details about a running container
- Running *ContainerStateRunning `json:"running,omitempty"`
+ Running *ContainerStateRunning `json:"running,omitempty" protobuf:"bytes,2,opt,name=running"`
// Details about a terminated container
- Terminated *ContainerStateTerminated `json:"terminated,omitempty"`
+ Terminated *ContainerStateTerminated `json:"terminated,omitempty" protobuf:"bytes,3,opt,name=terminated"`
}
// ContainerStatus contains details for the current status of this container.
type ContainerStatus struct {
// This must be a DNS_LABEL. Each container in a pod must have a unique name.
// Cannot be updated.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Details about the container's current condition.
- State ContainerState `json:"state,omitempty"`
+ State ContainerState `json:"state,omitempty" protobuf:"bytes,2,opt,name=state"`
// Details about the container's last termination condition.
- LastTerminationState ContainerState `json:"lastState,omitempty"`
+ LastTerminationState ContainerState `json:"lastState,omitempty" protobuf:"bytes,3,opt,name=lastState"`
// Specifies whether the container has passed its readiness probe.
- Ready bool `json:"ready"`
+ Ready bool `json:"ready" protobuf:"varint,4,opt,name=ready"`
// The number of times the container has been restarted, currently based on
// the number of dead containers that have not yet been removed.
// Note that this is calculated from dead containers. But those containers are subject to
// garbage collection. This value will get capped at 5 by GC.
- RestartCount int32 `json:"restartCount"`
+ RestartCount int32 `json:"restartCount" protobuf:"varint,5,opt,name=restartCount"`
// The image the container is running.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md
// TODO(dchen1107): Which image the container is running with?
- Image string `json:"image"`
+ Image string `json:"image" protobuf:"bytes,6,opt,name=image"`
// ImageID of the container's image.
- ImageID string `json:"imageID"`
+ ImageID string `json:"imageID" protobuf:"bytes,7,opt,name=imageID"`
// Container's ID in the format 'docker://<container_id>'.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#container-information
- ContainerID string `json:"containerID,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#container-information
+ ContainerID string `json:"containerID,omitempty" protobuf:"bytes,8,opt,name=containerID"`
}
// PodPhase is a label for the condition of a pod at the current time.
@@ -1284,6 +1344,8 @@ type PodConditionType string
// These are valid conditions of pod.
const (
+ // PodScheduled represents status of the scheduling process for this pod.
+ PodScheduled PodConditionType = "PodScheduled"
// PodReady means the pod is able to service requests and should be added to the
// load balancing pools of all matching services.
PodReady PodConditionType = "Ready"
@@ -1293,20 +1355,20 @@ const (
type PodCondition struct {
// Type is the type of the condition.
// Currently only Ready.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions
- Type PodConditionType `json:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ Type PodConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=PodConditionType"`
// Status is the status of the condition.
// Can be True, False, Unknown.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions
- Status ConditionStatus `json:"status"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ Status ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=ConditionStatus"`
// Last time we probed the condition.
- LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty" protobuf:"bytes,3,opt,name=lastProbeTime"`
// Last time the condition transitioned from one status to another.
- LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
// Unique, one-word, CamelCase reason for the condition's last transition.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
// Human-readable message indicating details about last transition.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
}
// RestartPolicy describes how the container should be restarted.
@@ -1342,29 +1404,29 @@ const (
// by the node selector terms.
type NodeSelector struct {
//Required. A list of node selector terms. The terms are ORed.
- NodeSelectorTerms []NodeSelectorTerm `json:"nodeSelectorTerms"`
+ NodeSelectorTerms []NodeSelectorTerm `json:"nodeSelectorTerms" protobuf:"bytes,1,rep,name=nodeSelectorTerms"`
}
// A null or empty node selector term matches no objects.
type NodeSelectorTerm struct {
//Required. A list of node selector requirements. The requirements are ANDed.
- MatchExpressions []NodeSelectorRequirement `json:"matchExpressions"`
+ MatchExpressions []NodeSelectorRequirement `json:"matchExpressions" protobuf:"bytes,1,rep,name=matchExpressions"`
}
// A node selector requirement is a selector that contains values, a key, and an operator
// that relates the key and values.
type NodeSelectorRequirement struct {
// The label key that the selector applies to.
- Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key"`
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
// Represents a key's relationship to a set of values.
// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
- Operator NodeSelectorOperator `json:"operator"`
+ Operator NodeSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=NodeSelectorOperator"`
// 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.
- Values []string `json:"values,omitempty"`
+ Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
}
// A node selector operator is the set of operators that can be used in
@@ -1380,11 +1442,109 @@ const (
NodeSelectorOpLt NodeSelectorOperator = "Lt"
)
-// Affinity is a group of affinity scheduling rules, currently
-// only node affinity, but in the future also inter-pod affinity.
+// Affinity is a group of affinity scheduling rules.
type Affinity struct {
// Describes node affinity scheduling rules for the pod.
- NodeAffinity *NodeAffinity `json:"nodeAffinity,omitempty"`
+ NodeAffinity *NodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,1,opt,name=nodeAffinity"`
+ // Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
+ PodAffinity *PodAffinity `json:"podAffinity,omitempty" protobuf:"bytes,2,opt,name=podAffinity"`
+ // Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
+ PodAntiAffinity *PodAntiAffinity `json:"podAntiAffinity,omitempty" protobuf:"bytes,3,opt,name=podAntiAffinity"`
+}
+
+// Pod affinity is a group of inter pod affinity scheduling rules.
+type PodAffinity struct {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,1,rep,name=requiredDuringSchedulingIgnoredDuringExecution"`
+ // 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.
+ PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,2,rep,name=preferredDuringSchedulingIgnoredDuringExecution"`
+}
+
+// Pod anti affinity is a group of inter pod anti affinity scheduling rules.
+type PodAntiAffinity struct {
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // 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 will 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.
+ // RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingRequiredDuringExecution,omitempty"`
+ // 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.
+ RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,1,rep,name=requiredDuringSchedulingIgnoredDuringExecution"`
+ // 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.
+ PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,2,rep,name=preferredDuringSchedulingIgnoredDuringExecution"`
+}
+
+// The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
+type WeightedPodAffinityTerm struct {
+ // weight associated with matching the corresponding podAffinityTerm,
+ // in the range 1-100.
+ Weight int32 `json:"weight" protobuf:"varint,1,opt,name=weight"`
+ // Required. A pod affinity term, associated with the corresponding weight.
+ PodAffinityTerm PodAffinityTerm `json:"podAffinityTerm" protobuf:"bytes,2,opt,name=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 <topologyKey> tches that of any node on which
+// a pod of the set of pods is running
+type PodAffinityTerm struct {
+ // A label query over a set of resources, in this case pods.
+ LabelSelector *unversioned.LabelSelector `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
+ // namespaces specifies which namespaces the labelSelector applies to (matches against);
+ // nil list means "this pod's namespace," empty list means "all namespaces"
+ // The json tag here is not "omitempty" since we need to distinguish nil and empty.
+ // See https://golang.org/pkg/encoding/json/#Marshal for more details.
+ Namespaces []string `json:"namespaces" protobuf:"bytes,2,rep,name=namespaces"`
+ // 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.
+ // For PreferredDuringScheduling pod anti-affinity, empty topologyKey is interpreted as "all topologies"
+ // ("all topologies" here means all the topologyKeys indicated by scheduler command-line argument --failure-domains);
+ // for affinity and for RequiredDuringScheduling pod anti-affinity, empty topologyKey is not allowed.
+ TopologyKey string `json:"topologyKey,omitempty" protobuf:"bytes,3,opt,name=topologyKey"`
}
// Node affinity is a group of node affinity scheduling rules.
@@ -1402,7 +1562,7 @@ type NodeAffinity struct {
// 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.
- RequiredDuringSchedulingIgnoredDuringExecution *NodeSelector `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
+ RequiredDuringSchedulingIgnoredDuringExecution *NodeSelector `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,1,opt,name=requiredDuringSchedulingIgnoredDuringExecution"`
// 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
@@ -1412,34 +1572,126 @@ type NodeAffinity struct {
// 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.
- PreferredDuringSchedulingIgnoredDuringExecution []PreferredSchedulingTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
+ PreferredDuringSchedulingIgnoredDuringExecution []PreferredSchedulingTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty" protobuf:"bytes,2,rep,name=preferredDuringSchedulingIgnoredDuringExecution"`
}
// 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).
type PreferredSchedulingTerm struct {
// Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
- Weight int `json:"weight"`
+ Weight int32 `json:"weight" protobuf:"varint,1,opt,name=weight"`
// A node selector term, associated with the corresponding weight.
- Preference NodeSelectorTerm `json:"preference"`
+ Preference NodeSelectorTerm `json:"preference" protobuf:"bytes,2,opt,name=preference"`
+}
+
+// The node this Taint is attached to has the effect "effect" on
+// any pod that that does not tolerate the Taint.
+type Taint struct {
+ // Required. The taint key to be applied to a node.
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
+ // Required. The taint value corresponding to the taint key.
+ Value string `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"`
+ // Required. The effect of the taint on pods
+ // that do not tolerate the taint.
+ // Valid effects are NoSchedule and PreferNoSchedule.
+ Effect TaintEffect `json:"effect" protobuf:"bytes,3,opt,name=effect,casttype=TaintEffect"`
}
+type TaintEffect string
+
+const (
+ // 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.
+ TaintEffectNoSchedule TaintEffect = "NoSchedule"
+ // 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.
+ TaintEffectPreferNoSchedule TaintEffect = "PreferNoSchedule"
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // Do not allow new pods to schedule onto the node unless they tolerate the taint,
+ // do not allow pods to start on Kubelet unless they tolerate the taint,
+ // but allow all already-running pods to continue running.
+ // Enforced by the scheduler and Kubelet.
+ // TaintEffectNoScheduleNoAdmit TaintEffect = "NoScheduleNoAdmit"
+ // NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
+ // Do not allow new pods to schedule onto the node unless they tolerate the taint,
+ // do not allow pods to start on Kubelet unless they tolerate the taint,
+ // and evict any already-running pods that do not tolerate the taint.
+ // Enforced by the scheduler and Kubelet.
+ // TaintEffectNoScheduleNoAdmitNoExecute = "NoScheduleNoAdmitNoExecute"
+)
+
+// The pod this Toleration is attached to tolerates any taint that matches
+// the triple <key,value,effect> using the matching operator <operator>.
+type Toleration struct {
+ // Required. Key is the taint key that the toleration applies to.
+ Key string `json:"key,omitempty" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
+ // 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.
+ Operator TolerationOperator `json:"operator,omitempty" protobuf:"bytes,2,opt,name=operator,casttype=TolerationOperator"`
+ // Value is the taint value the toleration matches to.
+ // If the operator is Exists, the value should be empty, otherwise just a regular string.
+ Value string `json:"value,omitempty" protobuf:"bytes,3,opt,name=value"`
+ // Effect indicates the taint effect to match. Empty means match all taint effects.
+ // When specified, allowed values are NoSchedule and PreferNoSchedule.
+ Effect TaintEffect `json:"effect,omitempty" protobuf:"bytes,4,opt,name=effect,casttype=TaintEffect"`
+ // TODO: For forgiveness (#1574), we'd eventually add at least a grace period
+ // here, and possibly an occurrence threshold and period.
+}
+
+// A toleration operator is the set of operators that can be used in a toleration.
+type TolerationOperator string
+
+const (
+ TolerationOpExists TolerationOperator = "Exists"
+ TolerationOpEqual TolerationOperator = "Equal"
+)
+
+const (
+ // This annotation key will be used to contain an array of v1 JSON encoded Containers
+ // for init containers. The annotation will be placed into the internal type and cleared.
+ PodInitContainersAnnotationKey = "pod.alpha.kubernetes.io/init-containers"
+ // This annotation key will be used to contain an array of v1 JSON encoded
+ // ContainerStatuses for init containers. The annotation will be placed into the internal
+ // type and cleared.
+ PodInitContainerStatusesAnnotationKey = "pod.alpha.kubernetes.io/init-container-statuses"
+)
+
// PodSpec is a description of a pod.
type PodSpec struct {
// List of volumes that can be mounted by containers belonging to the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md
- Volumes []Volume `json:"volumes,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md
+ Volumes []Volume `json:"volumes,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,1,rep,name=volumes"`
+ // 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, or Liveness 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.
+ // Init containers are in alpha state and may change without notice.
+ // Cannot be updated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md
+ InitContainers []Container `json:"-" patchStrategy:"merge" patchMergeKey:"name"`
// 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.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md
- Containers []Container `json:"containers" patchStrategy:"merge" patchMergeKey:"name"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md
+ Containers []Container `json:"containers" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,2,rep,name=containers"`
// Restart policy for all containers within the pod.
// One of Always, OnFailure, Never.
// Default to Always.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#restartpolicy
- RestartPolicy RestartPolicy `json:"restartPolicy,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#restartpolicy
+ RestartPolicy RestartPolicy `json:"restartPolicy,omitempty" protobuf:"bytes,3,opt,name=restartPolicy,casttype=RestartPolicy"`
// 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 delete immediately.
// If this value is nil, the default grace period will be used instead.
@@ -1447,49 +1699,55 @@ type PodSpec struct {
// 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.
- TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"`
+ TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
// 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.
- ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`
+ ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty" protobuf:"varint,5,opt,name=activeDeadlineSeconds"`
// Set DNS policy for containers within the pod.
// One of 'ClusterFirst' or 'Default'.
// Defaults to "ClusterFirst".
- DNSPolicy DNSPolicy `json:"dnsPolicy,omitempty"`
+ DNSPolicy DNSPolicy `json:"dnsPolicy,omitempty" protobuf:"bytes,6,opt,name=dnsPolicy,casttype=DNSPolicy"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/node-selection/README.md
- NodeSelector map[string]string `json:"nodeSelector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/node-selection/README.md
+ NodeSelector map[string]string `json:"nodeSelector,omitempty" protobuf:"bytes,7,rep,name=nodeSelector"`
// ServiceAccountName is the name of the ServiceAccount to use to run this pod.
- // More info: http://releases.k8s.io/release-1.2/docs/design/service_accounts.md
- ServiceAccountName string `json:"serviceAccountName,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md
+ ServiceAccountName string `json:"serviceAccountName,omitempty" protobuf:"bytes,8,opt,name=serviceAccountName"`
// DeprecatedServiceAccount is a depreciated alias for ServiceAccountName.
// Deprecated: Use serviceAccountName instead.
- DeprecatedServiceAccount string `json:"serviceAccount,omitempty"`
+ DeprecatedServiceAccount string `json:"serviceAccount,omitempty" protobuf:"bytes,9,opt,name=serviceAccount"`
// 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.
- NodeName string `json:"nodeName,omitempty"`
+ NodeName string `json:"nodeName,omitempty" protobuf:"bytes,10,opt,name=nodeName"`
// 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.
- HostNetwork bool `json:"hostNetwork,omitempty"`
+ HostNetwork bool `json:"hostNetwork,omitempty" protobuf:"varint,11,opt,name=hostNetwork"`
// Use the host's pid namespace.
// Optional: Default to false.
- HostPID bool `json:"hostPID,omitempty"`
+ HostPID bool `json:"hostPID,omitempty" protobuf:"varint,12,opt,name=hostPID"`
// Use the host's ipc namespace.
// Optional: Default to false.
- HostIPC bool `json:"hostIPC,omitempty"`
+ HostIPC bool `json:"hostIPC,omitempty" protobuf:"varint,13,opt,name=hostIPC"`
// SecurityContext holds pod-level security attributes and common container settings.
// Optional: Defaults to empty. See type description for default values of each field.
- SecurityContext *PodSecurityContext `json:"securityContext,omitempty"`
+ SecurityContext *PodSecurityContext `json:"securityContext,omitempty" protobuf:"bytes,14,opt,name=securityContext"`
// 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. For example,
// in the case of docker, only DockerConfig type secrets are honored.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md#specifying-imagepullsecrets-on-a-pod
- ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#specifying-imagepullsecrets-on-a-pod
+ ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,15,rep,name=imagePullSecrets"`
+ // Specifies the hostname of the Pod
+ // If not specified, the pod's hostname will be set to a system-defined value.
+ Hostname string `json:"hostname,omitempty" protobuf:"bytes,16,opt,name=hostname"`
+ // If specified, the fully qualified Pod hostname will be "<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>".
+ // If not specified, the pod will not have a domainname at all.
+ Subdomain string `json:"subdomain,omitempty" protobuf:"bytes,17,opt,name=subdomain"`
}
// PodSecurityContext holds pod-level security attributes and common container settings.
@@ -1501,24 +1759,24 @@ type PodSecurityContext struct {
// container. May also be set in SecurityContext. If set in
// both SecurityContext and PodSecurityContext, the value specified in SecurityContext
// takes precedence for that container.
- SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty"`
+ SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty" protobuf:"bytes,1,opt,name=seLinuxOptions"`
// 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.
- RunAsUser *int64 `json:"runAsUser,omitempty"`
+ RunAsUser *int64 `json:"runAsUser,omitempty" protobuf:"varint,2,opt,name=runAsUser"`
// 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.
- RunAsNonRoot *bool `json:"runAsNonRoot,omitempty"`
+ RunAsNonRoot *bool `json:"runAsNonRoot,omitempty" protobuf:"varint,3,opt,name=runAsNonRoot"`
// 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.
- SupplementalGroups []int64 `json:"supplementalGroups,omitempty"`
+ SupplementalGroups []int64 `json:"supplementalGroups,omitempty" protobuf:"varint,4,rep,name=supplementalGroups"`
// 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:
@@ -1528,52 +1786,58 @@ type PodSecurityContext struct {
// 3. The permission bits are OR'd with rw-rw----
//
// If unset, the Kubelet will not modify the ownership and permissions of any volume.
- FSGroup *int64 `json:"fsGroup,omitempty"`
+ FSGroup *int64 `json:"fsGroup,omitempty" protobuf:"varint,5,opt,name=fsGroup"`
}
// PodStatus represents information about the status of a pod. Status may trail the actual
// state of a system.
type PodStatus struct {
// Current condition of the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-phase
- Phase PodPhase `json:"phase,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-phase
+ Phase PodPhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=PodPhase"`
// Current service state of pod.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions
- Conditions []PodCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions
+ Conditions []PodCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,2,rep,name=conditions"`
// A human readable message indicating details about why the pod is in this condition.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,3,opt,name=message"`
// A brief CamelCase message indicating details about why the pod is in this state.
// e.g. 'OutOfDisk'
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"`
// IP address of the host to which the pod is assigned. Empty if not yet scheduled.
- HostIP string `json:"hostIP,omitempty"`
+ HostIP string `json:"hostIP,omitempty" protobuf:"bytes,5,opt,name=hostIP"`
// IP address allocated to the pod. Routable at least within the cluster.
// Empty if not yet allocated.
- PodIP string `json:"podIP,omitempty"`
+ PodIP string `json:"podIP,omitempty" protobuf:"bytes,6,opt,name=podIP"`
// 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.
- StartTime *unversioned.Time `json:"startTime,omitempty"`
-
+ StartTime *unversioned.Time `json:"startTime,omitempty" protobuf:"bytes,7,opt,name=startTime"`
+
+ // 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.
+ // Init containers are in alpha state and may change without notice.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-statuses
+ InitContainerStatuses []ContainerStatus `json:"-"`
// The list has one entry per container in the manifest. Each entry is currently the output
// of `docker inspect`.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-statuses
- ContainerStatuses []ContainerStatus `json:"containerStatuses,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-statuses
+ ContainerStatuses []ContainerStatus `json:"containerStatuses,omitempty" protobuf:"bytes,8,rep,name=containerStatuses"`
}
// PodStatusResult is a wrapper for PodStatus returned by kubelet that can be encode/decoded
type PodStatusResult struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Most recently observed status of the pod.
// This data may not be up to date.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status PodStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status PodStatus `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"`
}
// +genclient=true
@@ -1583,42 +1847,42 @@ type PodStatusResult struct {
type Pod struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Specification of the desired behavior of the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec PodSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec PodSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Most recently observed status of the pod.
// This data may not be up to date.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status PodStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status PodStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// PodList is a list of Pods.
type PodList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of pods.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/pods.md
- Items []Pod `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/pods.md
+ Items []Pod `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// PodTemplateSpec describes the data a pod should have when created from a template
type PodTemplateSpec struct {
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Specification of the desired behavior of the pod.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec PodSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec PodSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
}
// +genclient=true
@@ -1627,23 +1891,23 @@ type PodTemplateSpec struct {
type PodTemplate struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Template defines the pods that will be created from this pod template.
- // http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Template PodTemplateSpec `json:"template,omitempty"`
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Template PodTemplateSpec `json:"template,omitempty" protobuf:"bytes,2,opt,name=template"`
}
// PodTemplateList is a list of PodTemplates.
type PodTemplateList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of pod templates
- Items []PodTemplate `json:"items"`
+ Items []PodTemplate `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// ReplicationControllerSpec is the specification of a replication controller.
@@ -1651,15 +1915,15 @@ type ReplicationControllerSpec struct {
// Replicas is the number of desired replicas.
// This is a pointer to distinguish between explicit zero and unspecified.
// Defaults to 1.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller
- Replicas *int32 `json:"replicas,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector map[string]string `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector map[string]string `json:"selector,omitempty" protobuf:"bytes,2,rep,name=selector"`
// TemplateRef is a reference to an object that describes the pod that will be created if
// insufficient replicas are detected.
@@ -1668,22 +1932,22 @@ type ReplicationControllerSpec struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template
- Template *PodTemplateSpec `json:"template,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ Template *PodTemplateSpec `json:"template,omitempty" protobuf:"bytes,3,opt,name=template"`
}
// ReplicationControllerStatus represents the current status of a replication
// controller.
type ReplicationControllerStatus struct {
// Replicas is the most recently oberved number of replicas.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller
- Replicas int32 `json:"replicas"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ Replicas int32 `json:"replicas" protobuf:"varint,1,opt,name=replicas"`
// The number of pods that have labels matching the labels of the pod template of the replication controller.
- FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`
+ FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty" protobuf:"varint,2,opt,name=fullyLabeledReplicas"`
// ObservedGeneration reflects the generation of the most recently observed replication controller.
- ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+ ObservedGeneration int64 `json:"observedGeneration,omitempty" protobuf:"varint,3,opt,name=observedGeneration"`
}
// +genclient=true
@@ -1694,31 +1958,31 @@ type ReplicationController struct {
// If the Labels of a ReplicationController are empty, they are defaulted to
// be the same as the Pod(s) that the replication controller manages.
- // Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the specification of the desired behavior of the replication controller.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec ReplicationControllerSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ReplicationControllerSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status is the most recently observed status of the replication controller.
// This data may be out of date by some window of time.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status ReplicationControllerStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ReplicationControllerStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// ReplicationControllerList is a collection of replication controllers.
type ReplicationControllerList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of replication controllers.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md
- Items []ReplicationController `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md
+ Items []ReplicationController `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// Session Affinity Type string
@@ -1754,14 +2018,14 @@ const (
type ServiceStatus struct {
// LoadBalancer contains the current status of the load-balancer,
// if one is present.
- LoadBalancer LoadBalancerStatus `json:"loadBalancer,omitempty"`
+ LoadBalancer LoadBalancerStatus `json:"loadBalancer,omitempty" protobuf:"bytes,1,opt,name=loadBalancer"`
}
// LoadBalancerStatus represents the status of a load-balancer.
type LoadBalancerStatus struct {
// Ingress is a list containing ingress points for the load-balancer.
// Traffic intended for the service should be sent to these ingress points.
- Ingress []LoadBalancerIngress `json:"ingress,omitempty"`
+ Ingress []LoadBalancerIngress `json:"ingress,omitempty" protobuf:"bytes,1,rep,name=ingress"`
}
// LoadBalancerIngress represents the status of a load-balancer ingress point:
@@ -1769,24 +2033,24 @@ type LoadBalancerStatus struct {
type LoadBalancerIngress struct {
// IP is set for load-balancer ingress points that are IP based
// (typically GCE or OpenStack load-balancers)
- IP string `json:"ip,omitempty"`
+ IP string `json:"ip,omitempty" protobuf:"bytes,1,opt,name=ip"`
// Hostname is set for load-balancer ingress points that are DNS based
// (typically AWS load-balancers)
- Hostname string `json:"hostname,omitempty"`
+ Hostname string `json:"hostname,omitempty" protobuf:"bytes,2,opt,name=hostname"`
}
// ServiceSpec describes the attributes that a user creates on a service.
type ServiceSpec struct {
// The list of ports that are exposed by this service.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies
- Ports []ServicePort `json:"ports" patchStrategy:"merge" patchMergeKey:"port"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ Ports []ServicePort `json:"ports" patchStrategy:"merge" patchMergeKey:"port" protobuf:"bytes,1,rep,name=ports"`
// This service will route traffic to pods having labels matching this selector.
// Label keys and values that must match in order to receive traffic for this service.
// If empty, all pods are selected, if not specified, endpoints must be manually specified.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#overview
- Selector map[string]string `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#overview
+ Selector map[string]string `json:"selector,omitempty" protobuf:"bytes,2,rep,name=selector"`
// ClusterIP is usually assigned by the master and is the IP address of the service.
// If specified, it will be allocated to the service if it is unused
@@ -1794,13 +2058,13 @@ type ServiceSpec struct {
// Valid values are None, empty string (""), or a valid IP address.
// 'None' can be specified for a headless service when proxying is not required.
// Cannot be updated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies
- ClusterIP string `json:"clusterIP,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ ClusterIP string `json:"clusterIP,omitempty" protobuf:"bytes,3,opt,name=clusterIP"`
// Type of exposed service. Must be ClusterIP, NodePort, or LoadBalancer.
// Defaults to ClusterIP.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#external-services
- Type ServiceType `json:"type,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#external-services
+ Type ServiceType `json:"type,omitempty" protobuf:"bytes,4,opt,name=type,casttype=ServiceType"`
// 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
@@ -1809,28 +2073,35 @@ type ServiceSpec struct {
// that are not part of the Kubernetes system. A previous form of this
// functionality exists as the deprecatedPublicIPs field. When using this
// field, callers should also clear the deprecatedPublicIPs field.
- ExternalIPs []string `json:"externalIPs,omitempty"`
+ ExternalIPs []string `json:"externalIPs,omitempty" protobuf:"bytes,5,rep,name=externalIPs"`
// deprecatedPublicIPs is deprecated and replaced by the externalIPs field
// with almost the exact same semantics. This field is retained in the v1
// API for compatibility until at least 8/20/2016. It will be removed from
// any new API revisions. If both deprecatedPublicIPs *and* externalIPs are
// set, deprecatedPublicIPs is used.
- DeprecatedPublicIPs []string `json:"deprecatedPublicIPs,omitempty"`
+ // +genconversion=false
+ DeprecatedPublicIPs []string `json:"deprecatedPublicIPs,omitempty" protobuf:"bytes,6,rep,name=deprecatedPublicIPs"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies
- SessionAffinity ServiceAffinity `json:"sessionAffinity,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies
+ SessionAffinity ServiceAffinity `json:"sessionAffinity,omitempty" protobuf:"bytes,7,opt,name=sessionAffinity,casttype=ServiceAffinity"`
// Only applies to Service Type: LoadBalancer
// LoadBalancer will get created with the IP specified in this field.
// 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.
- LoadBalancerIP string `json:"loadBalancerIP,omitempty"`
+ LoadBalancerIP string `json:"loadBalancerIP,omitempty" protobuf:"bytes,8,opt,name=loadBalancerIP"`
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/services-firewalls.md
+ LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty" protobuf:"bytes,9,opt,name=loadBalancerSourceRanges"`
}
// ServicePort contains information on service's port.
@@ -1839,14 +2110,14 @@ type ServicePort struct {
// All ports within a ServiceSpec must have unique names. This maps to
// the 'Name' field in EndpointPort objects.
// Optional if only one ServicePort is defined on this service.
- Name string `json:"name,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
// The IP protocol for this port. Supports "TCP" and "UDP".
// Default is TCP.
- Protocol Protocol `json:"protocol,omitempty"`
+ Protocol Protocol `json:"protocol,omitempty" protobuf:"bytes,2,opt,name=protocol,casttype=Protocol"`
// The port that will be exposed by this service.
- Port int32 `json:"port"`
+ Port int32 `json:"port" protobuf:"varint,3,opt,name=port"`
// 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.
@@ -1855,15 +2126,15 @@ type ServicePort struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#defining-a-service
- TargetPort intstr.IntOrString `json:"targetPort,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#defining-a-service
+ TargetPort intstr.IntOrString `json:"targetPort,omitempty" protobuf:"bytes,4,opt,name=targetPort"`
// The port on each node on which this service is exposed when type=NodePort or LoadBalancer.
// Usually assigned by the system. If specified, it will be allocated to the service
// if unused or else creation of the service will fail.
// Default is to auto-allocate a port if the ServiceType of this Service requires one.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#type--nodeport
- NodePort int32 `json:"nodePort,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#type--nodeport
+ NodePort int32 `json:"nodePort,omitempty" protobuf:"varint,5,opt,name=nodePort"`
}
// +genclient=true
@@ -1874,18 +2145,18 @@ type ServicePort struct {
type Service struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the behavior of a service.
- // http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec ServiceSpec `json:"spec,omitempty"`
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ServiceSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Most recently observed status of the service.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status ServiceStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ServiceStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
const (
@@ -1898,11 +2169,11 @@ const (
type ServiceList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of services
- Items []Service `json:"items"`
+ Items []Service `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// +genclient=true
@@ -1914,30 +2185,30 @@ type ServiceList struct {
type ServiceAccount struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md
- Secrets []ObjectReference `json:"secrets,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md
+ Secrets []ObjectReference `json:"secrets,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,2,rep,name=secrets"`
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md#manually-specifying-an-imagepullsecret
- ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md#manually-specifying-an-imagepullsecret
+ ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty" protobuf:"bytes,3,rep,name=imagePullSecrets"`
}
// ServiceAccountList is a list of ServiceAccount objects
type ServiceAccountList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of ServiceAccounts.
- // More info: http://releases.k8s.io/release-1.2/docs/design/service_accounts.md#service-accounts
- Items []ServiceAccount `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md#service-accounts
+ Items []ServiceAccount `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// +genclient=true
@@ -1957,8 +2228,8 @@ type ServiceAccountList struct {
type Endpoints struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// The set of all endpoints is the union of all subsets. Addresses are placed into
// subsets according to the IPs they share. A single address with multiple ports,
@@ -1967,7 +2238,7 @@ type Endpoints struct {
// subsets for the different ports. No address will appear in both Addresses and
// NotReadyAddresses in the same subset.
// Sets of addresses and ports that comprise a service.
- Subsets []EndpointSubset `json:"subsets"`
+ Subsets []EndpointSubset `json:"subsets" protobuf:"bytes,2,rep,name=subsets"`
}
// EndpointSubset is a group of addresses with a common set of ports. The
@@ -1983,13 +2254,13 @@ type Endpoints struct {
type EndpointSubset struct {
// IP addresses which offer the related ports that are marked as ready. These endpoints
// should be considered safe for load balancers and clients to utilize.
- Addresses []EndpointAddress `json:"addresses,omitempty"`
+ Addresses []EndpointAddress `json:"addresses,omitempty" protobuf:"bytes,1,rep,name=addresses"`
// IP addresses which offer the related ports but are not currently marked as ready
// because they have not yet finished starting, have recently failed a readiness check,
// or have recently failed a liveness check.
- NotReadyAddresses []EndpointAddress `json:"notReadyAddresses,omitempty"`
+ NotReadyAddresses []EndpointAddress `json:"notReadyAddresses,omitempty" protobuf:"bytes,2,rep,name=notReadyAddresses"`
// Port numbers available on the related IP addresses.
- Ports []EndpointPort `json:"ports,omitempty"`
+ Ports []EndpointPort `json:"ports,omitempty" protobuf:"bytes,3,rep,name=ports"`
}
// EndpointAddress is a tuple that describes single IP address.
@@ -1997,11 +2268,14 @@ type EndpointAddress struct {
// The IP of this endpoint.
// May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16),
// or link-local multicast ((224.0.0.0/24).
+ // IPv6 is also accepted but not fully supported on all platforms. Also, certain
+ // kubernetes components, like kube-proxy, are not IPv6 ready.
// TODO: This should allow hostname or IP, See #4447.
- IP string `json:"ip"`
-
+ IP string `json:"ip" protobuf:"bytes,1,opt,name=ip"`
+ // The Hostname of this endpoint
+ Hostname string `json:"hostname,omitempty" protobuf:"bytes,3,opt,name=hostname"`
// Reference to object providing the endpoint.
- TargetRef *ObjectReference `json:"targetRef,omitempty"`
+ TargetRef *ObjectReference `json:"targetRef,omitempty" protobuf:"bytes,2,opt,name=targetRef"`
}
// EndpointPort is a tuple that describes a single port.
@@ -2009,108 +2283,133 @@ type EndpointPort struct {
// The name of this port (corresponds to ServicePort.Name).
// Must be a DNS_LABEL.
// Optional only if one port is defined.
- Name string `json:"name,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
// The port number of the endpoint.
- Port int32 `json:"port"`
+ Port int32 `json:"port" protobuf:"varint,2,opt,name=port"`
// The IP protocol for this port.
// Must be UDP or TCP.
// Default is TCP.
- Protocol Protocol `json:"protocol,omitempty"`
+ Protocol Protocol `json:"protocol,omitempty" protobuf:"bytes,3,opt,name=protocol,casttype=Protocol"`
}
// EndpointsList is a list of endpoints.
type EndpointsList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of endpoints.
- Items []Endpoints `json:"items"`
+ Items []Endpoints `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// NodeSpec describes the attributes that a node is created with.
type NodeSpec struct {
// PodCIDR represents the pod IP range assigned to the node.
- PodCIDR string `json:"podCIDR,omitempty"`
+ PodCIDR string `json:"podCIDR,omitempty" protobuf:"bytes,1,opt,name=podCIDR"`
// External ID of the node assigned by some machine database (e.g. a cloud provider).
// Deprecated.
- ExternalID string `json:"externalID,omitempty"`
+ ExternalID string `json:"externalID,omitempty" protobuf:"bytes,2,opt,name=externalID"`
// ID of the node assigned by the cloud provider in the format: <ProviderName>://<ProviderSpecificNodeID>
- ProviderID string `json:"providerID,omitempty"`
+ ProviderID string `json:"providerID,omitempty" protobuf:"bytes,3,opt,name=providerID"`
// Unschedulable controls node schedulability of new pods. By default, node is schedulable.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#manual-node-administration"`
- Unschedulable bool `json:"unschedulable,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#manual-node-administration"`
+ Unschedulable bool `json:"unschedulable,omitempty" protobuf:"varint,4,opt,name=unschedulable"`
}
// DaemonEndpoint contains information about a single Daemon endpoint.
type DaemonEndpoint struct {
+ /*
+ The port tag was not properly in quotes in earlier releases, so it must be
+ uppercased for backwards compat (since it was falling back to var name of
+ 'Port').
+ */
+
// Port number of the given endpoint.
- Port int32 `json:port`
+ Port int32 `json:"Port" protobuf:"varint,1,opt,name=Port"`
}
// NodeDaemonEndpoints lists ports opened by daemons running on the Node.
type NodeDaemonEndpoints struct {
// Endpoint on which Kubelet is listening.
- KubeletEndpoint DaemonEndpoint `json:"kubeletEndpoint,omitempty"`
+ KubeletEndpoint DaemonEndpoint `json:"kubeletEndpoint,omitempty" protobuf:"bytes,1,opt,name=kubeletEndpoint"`
}
// NodeSystemInfo is a set of ids/uuids to uniquely identify the node.
type NodeSystemInfo struct {
// Machine ID reported by the node.
- MachineID string `json:"machineID"`
+ MachineID string `json:"machineID" protobuf:"bytes,1,opt,name=machineID"`
// System UUID reported by the node.
- SystemUUID string `json:"systemUUID"`
+ SystemUUID string `json:"systemUUID" protobuf:"bytes,2,opt,name=systemUUID"`
// Boot ID reported by the node.
- BootID string `json:"bootID"`
+ BootID string `json:"bootID" protobuf:"bytes,3,opt,name=bootID"`
// Kernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64).
- KernelVersion string `json:"kernelVersion"`
+ KernelVersion string `json:"kernelVersion" protobuf:"bytes,4,opt,name=kernelVersion"`
// OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).
- OSImage string `json:"osImage"`
+ OSImage string `json:"osImage" protobuf:"bytes,5,opt,name=osImage"`
// ContainerRuntime Version reported by the node through runtime remote API (e.g. docker://1.5.0).
- ContainerRuntimeVersion string `json:"containerRuntimeVersion"`
+ ContainerRuntimeVersion string `json:"containerRuntimeVersion" protobuf:"bytes,6,opt,name=containerRuntimeVersion"`
// Kubelet Version reported by the node.
- KubeletVersion string `json:"kubeletVersion"`
+ KubeletVersion string `json:"kubeletVersion" protobuf:"bytes,7,opt,name=kubeletVersion"`
// KubeProxy Version reported by the node.
- KubeProxyVersion string `json:"kubeProxyVersion"`
+ KubeProxyVersion string `json:"kubeProxyVersion" protobuf:"bytes,8,opt,name=kubeProxyVersion"`
+ // The Operating System reported by the node
+ OperatingSystem string `json:"operatingSystem" protobuf:"bytes,9,opt,name=operatingSystem"`
+ // The Architecture reported by the node
+ Architecture string `json:"architecture" protobuf:"bytes,10,opt,name=architecture"`
}
// NodeStatus is information about the current status of a node.
type NodeStatus struct {
// Capacity represents the total resources of a node.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#capacity for more details.
- Capacity ResourceList `json:"capacity,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity for more details.
+ Capacity ResourceList `json:"capacity,omitempty" protobuf:"bytes,1,rep,name=capacity,casttype=ResourceList,castkey=ResourceName"`
// Allocatable represents the resources of a node that are available for scheduling.
// Defaults to Capacity.
- Allocatable ResourceList `json:"allocatable,omitempty"`
+ Allocatable ResourceList `json:"allocatable,omitempty" protobuf:"bytes,2,rep,name=allocatable,casttype=ResourceList,castkey=ResourceName"`
// NodePhase is the recently observed lifecycle phase of the node.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-phase
- Phase NodePhase `json:"phase,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-phase
+ Phase NodePhase `json:"phase,omitempty" protobuf:"bytes,3,opt,name=phase,casttype=NodePhase"`
// Conditions is an array of current observed node conditions.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-condition
- Conditions []NodeCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-condition
+ Conditions []NodeCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,4,rep,name=conditions"`
// List of addresses reachable to the node.
// Queried from cloud provider, if available.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-addresses
- Addresses []NodeAddress `json:"addresses,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-addresses
+ Addresses []NodeAddress `json:"addresses,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,5,rep,name=addresses"`
// Endpoints of daemons running on the Node.
- DaemonEndpoints NodeDaemonEndpoints `json:"daemonEndpoints,omitempty"`
+ DaemonEndpoints NodeDaemonEndpoints `json:"daemonEndpoints,omitempty" protobuf:"bytes,6,opt,name=daemonEndpoints"`
// Set of ids/uuids to uniquely identify the node.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-info
- NodeInfo NodeSystemInfo `json:"nodeInfo,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-info
+ NodeInfo NodeSystemInfo `json:"nodeInfo,omitempty" protobuf:"bytes,7,opt,name=nodeInfo"`
// List of container images on this node
- Images []ContainerImage `json:"images",omitempty`
+ Images []ContainerImage `json:"images,omitempty" protobuf:"bytes,8,rep,name=images"`
+ // List of attachable volumes in use (mounted) by the node.
+ VolumesInUse []UniqueVolumeName `json:"volumesInUse,omitempty" protobuf:"bytes,9,rep,name=volumesInUse"`
+ // List of volumes that are attached to the node.
+ VolumesAttached []AttachedVolume `json:"volumesAttached,omitempty" protobuf:"bytes,10,rep,name=volumesAttached"`
+}
+
+type UniqueVolumeName string
+
+// AttachedVolume describes a volume attached to a node
+type AttachedVolume struct {
+ // Name of the attached volume
+ Name UniqueVolumeName `json:"name" protobuf:"bytes,1,rep,name=name"`
+
+ // DevicePath represents the device path where the volume should be avilable
+ DevicePath string `json:"devicePath" protobuf:"bytes,2,rep,name=devicePath"`
}
// Describe a container image
type ContainerImage struct {
// Names by which this image is known.
// e.g. ["gcr.io/google_containers/hyperkube:v1.0.7", "dockerhub.io/google_containers/hyperkube:v1.0.7"]
- Names []string `json:"names"`
+ Names []string `json:"names" protobuf:"bytes,1,rep,name=names"`
// The size of the image in bytes.
- SizeBytes int64 `json:"sizeBytes,omitempty"`
+ SizeBytes int64 `json:"sizeBytes,omitempty" protobuf:"varint,2,opt,name=sizeBytes"`
}
type NodePhase string
@@ -2136,22 +2435,26 @@ const (
// NodeOutOfDisk means the kubelet will not accept new pods due to insufficient free disk
// space on the node.
NodeOutOfDisk NodeConditionType = "OutOfDisk"
+ // NodeMemoryPressure means the kubelet is under pressure due to insufficient available memory.
+ NodeMemoryPressure NodeConditionType = "MemoryPressure"
+ // NodeNetworkUnavailable means that network for the node is not correctly configured.
+ NodeNetworkUnavailable NodeConditionType = "NetworkUnavailable"
)
// NodeCondition contains condition infromation for a node.
type NodeCondition struct {
// Type of node condition.
- Type NodeConditionType `json:"type"`
+ Type NodeConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=NodeConditionType"`
// Status of the condition, one of True, False, Unknown.
- Status ConditionStatus `json:"status"`
+ Status ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=ConditionStatus"`
// Last time we got an update on a given condition.
- LastHeartbeatTime unversioned.Time `json:"lastHeartbeatTime,omitempty"`
+ LastHeartbeatTime unversioned.Time `json:"lastHeartbeatTime,omitempty" protobuf:"bytes,3,opt,name=lastHeartbeatTime"`
// Last time the condition transit from one status to another.
- LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
// (brief) reason for the condition's last transition.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
// Human readable message indicating details about last transition.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
}
type NodeAddressType string
@@ -2166,14 +2469,19 @@ const (
// NodeAddress contains information for the node's address.
type NodeAddress struct {
// Node address type, one of Hostname, ExternalIP or InternalIP.
- Type NodeAddressType `json:"type"`
+ Type NodeAddressType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=NodeAddressType"`
// The node address.
- Address string `json:"address"`
+ Address string `json:"address" protobuf:"bytes,2,opt,name=address"`
}
// ResourceName is the name identifying various resources in a ResourceList.
type ResourceName string
+// Resource names must be not more than 63 characters, consisting of upper- or lower-case alphanumeric characters,
+// with the -, _, and . characters allowed anywhere, except the first or last character.
+// The default convention, matching that for annotations, is to use lower-case names, with dashes, rather than
+// camel case, separating compound words.
+// Fully-qualified resource typenames are constructed from a DNS-style subdomain, followed by a slash `/` and a name.
const (
// CPU, in cores. (500m = .5 cores)
ResourceCPU ResourceName = "cpu"
@@ -2181,6 +2489,9 @@ const (
ResourceMemory ResourceName = "memory"
// Volume size, in bytes (e,g. 5Gi = 5GiB = 5 * 1024 * 1024 * 1024)
ResourceStorage ResourceName = "storage"
+ // NVIDIA GPU, in devices. Alpha, might change: although fractional and allowing values >1, only one whole device per node is assigned.
+ ResourceNvidiaGPU ResourceName = "alpha.kubernetes.io/nvidia-gpu"
+ // Number of Pods that may be running on this Node: see ResourcePods
)
// ResourceList is a set of (resource name, quantity) pairs.
@@ -2193,29 +2504,29 @@ type ResourceList map[ResourceName]resource.Quantity
type Node struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the behavior of a node.
- // http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec NodeSpec `json:"spec,omitempty"`
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec NodeSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Most recently observed status of the node.
// Populated by the system.
// Read-only.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status NodeStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status NodeStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// NodeList is the whole list of all Nodes which have been registered with master.
type NodeList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of nodes
- Items []Node `json:"items"`
+ Items []Node `json:"items" protobuf:"bytes,2,rep,name=items"`
}
type FinalizerName string
@@ -2228,15 +2539,15 @@ const (
// NamespaceSpec describes the attributes on a Namespace.
type NamespaceSpec struct {
// Finalizers is an opaque list of values that must be empty to permanently remove object from storage.
- // More info: http://releases.k8s.io/release-1.2/docs/design/namespaces.md#finalizers
- Finalizers []FinalizerName `json:"finalizers,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#finalizers
+ Finalizers []FinalizerName `json:"finalizers,omitempty" protobuf:"bytes,1,rep,name=finalizers,casttype=FinalizerName"`
}
// NamespaceStatus is information about the current status of a Namespace.
type NamespaceStatus struct {
// Phase is the current lifecycle phase of the namespace.
- // More info: http://releases.k8s.io/release-1.2/docs/design/namespaces.md#phases
- Phase NamespacePhase `json:"phase,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#phases
+ Phase NamespacePhase `json:"phase,omitempty" protobuf:"bytes,1,opt,name=phase,casttype=NamespacePhase"`
}
type NamespacePhase string
@@ -2256,28 +2567,28 @@ const (
type Namespace struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the behavior of the Namespace.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec NamespaceSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec NamespaceSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status describes the current status of a Namespace.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status NamespaceStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status NamespaceStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// NamespaceList is a list of Namespaces.
type NamespaceList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of Namespace objects in the list.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md
- Items []Namespace `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ Items []Namespace `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// Binding ties one object to another.
@@ -2285,11 +2596,17 @@ type NamespaceList struct {
type Binding struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// The target object that you want to bind to the standard object.
- Target ObjectReference `json:"target"`
+ Target ObjectReference `json:"target" protobuf:"bytes,2,opt,name=target"`
+}
+
+// Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
+type Preconditions struct {
+ // Specifies the target UID.
+ UID *types.UID `json:"uid,omitempty" protobuf:"bytes,1,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
}
// DeleteOptions may be provided when deleting an API object
@@ -2300,7 +2617,15 @@ type DeleteOptions struct {
// 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.
- GracePeriodSeconds *int64 `json:"gracePeriodSeconds"`
+ GracePeriodSeconds *int64 `json:"gracePeriodSeconds,omitempty" protobuf:"varint,1,opt,name=gracePeriodSeconds"`
+
+ // Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be
+ // returned.
+ Preconditions *Preconditions `json:"preconditions,omitempty" protobuf:"bytes,2,opt,name=preconditions"`
+
+ // Should the dependent objects be orphaned. If true/false, the "orphan"
+ // finalizer will be added to/removed from the object's finalizers list.
+ OrphanDependents *bool `json:"orphanDependents,omitempty" protobuf:"varint,3,opt,name=orphanDependents"`
}
// ExportOptions is the query options to the standard REST get call.
@@ -2308,9 +2633,9 @@ type ExportOptions struct {
unversioned.TypeMeta `json:",inline"`
// Should this value be exported. Export strips fields that a user can not specify.
- Export bool `json:"export"`
+ Export bool `json:"export" protobuf:"varint,1,opt,name=export"`
// Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
- Exact bool `json:"exact"`
+ Exact bool `json:"exact" protobuf:"varint,2,opt,name=exact"`
}
// ListOptions is the query options to a standard REST list call.
@@ -2319,18 +2644,18 @@ type ListOptions struct {
// A selector to restrict the list of returned objects by their labels.
// Defaults to everything.
- LabelSelector string `json:"labelSelector,omitempty"`
+ LabelSelector string `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
// A selector to restrict the list of returned objects by their fields.
// Defaults to everything.
- FieldSelector string `json:"fieldSelector,omitempty"`
+ FieldSelector string `json:"fieldSelector,omitempty" protobuf:"bytes,2,opt,name=fieldSelector"`
// Watch for changes to the described resources and return them as a stream of
// add, update, and remove notifications. Specify resourceVersion.
- Watch bool `json:"watch,omitempty"`
+ Watch bool `json:"watch,omitempty" protobuf:"varint,3,opt,name=watch"`
// When specified with a watch call, shows changes that occur after that particular version of a resource.
// Defaults to changes from the beginning of history.
- ResourceVersion string `json:"resourceVersion,omitempty"`
+ ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,4,opt,name=resourceVersion"`
// Timeout for the list/watch call.
- TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty"`
+ TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" protobuf:"varint,5,opt,name=timeoutSeconds"`
}
// PodLogOptions is the query options for a Pod's logs REST call.
@@ -2338,31 +2663,31 @@ type PodLogOptions struct {
unversioned.TypeMeta `json:",inline"`
// The container for which to stream logs. Defaults to only container if there is one container in the pod.
- Container string `json:"container,omitempty"`
+ Container string `json:"container,omitempty" protobuf:"bytes,1,opt,name=container"`
// Follow the log stream of the pod. Defaults to false.
- Follow bool `json:"follow,omitempty"`
+ Follow bool `json:"follow,omitempty" protobuf:"varint,2,opt,name=follow"`
// Return previous terminated container logs. Defaults to false.
- Previous bool `json:"previous,omitempty"`
+ Previous bool `json:"previous,omitempty" protobuf:"varint,3,opt,name=previous"`
// A relative time in seconds before the current time from which to show logs. If this value
// precedes the time a pod was started, only logs since the pod start will be returned.
// If this value is in the future, no logs will be returned.
// Only one of sinceSeconds or sinceTime may be specified.
- SinceSeconds *int64 `json:"sinceSeconds,omitempty"`
+ SinceSeconds *int64 `json:"sinceSeconds,omitempty" protobuf:"varint,4,opt,name=sinceSeconds"`
// An RFC3339 timestamp from which to show logs. If this value
// precedes the time a pod was started, only logs since the pod start will be returned.
// If this value is in the future, no logs will be returned.
// Only one of sinceSeconds or sinceTime may be specified.
- SinceTime *unversioned.Time `json:"sinceTime,omitempty"`
+ SinceTime *unversioned.Time `json:"sinceTime,omitempty" protobuf:"bytes,5,opt,name=sinceTime"`
// If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line
// of log output. Defaults to false.
- Timestamps bool `json:"timestamps,omitempty"`
+ Timestamps bool `json:"timestamps,omitempty" protobuf:"varint,6,opt,name=timestamps"`
// If set, the number of lines from the end of the logs to show. If not specified,
// logs are shown from the creation of the container or sinceSeconds or sinceTime
- TailLines *int64 `json:"tailLines,omitempty"`
+ TailLines *int64 `json:"tailLines,omitempty" protobuf:"varint,7,opt,name=tailLines"`
// If set, the number of bytes to read from the server before terminating the
// log output. This may not display a complete final line of logging, and may return
// slightly more or slightly less than the specified limit.
- LimitBytes *int64 `json:"limitBytes,omitempty"`
+ LimitBytes *int64 `json:"limitBytes,omitempty" protobuf:"varint,8,opt,name=limitBytes"`
}
// PodAttachOptions is the query options to a Pod's remote attach call.
@@ -2374,25 +2699,25 @@ type PodAttachOptions struct {
// Stdin if true, redirects the standard input stream of the pod for this call.
// Defaults to false.
- Stdin bool `json:"stdin,omitempty"`
+ Stdin bool `json:"stdin,omitempty" protobuf:"varint,1,opt,name=stdin"`
// Stdout if true indicates that stdout is to be redirected for the attach call.
// Defaults to true.
- Stdout bool `json:"stdout,omitempty"`
+ Stdout bool `json:"stdout,omitempty" protobuf:"varint,2,opt,name=stdout"`
// Stderr if true indicates that stderr is to be redirected for the attach call.
// Defaults to true.
- Stderr bool `json:"stderr,omitempty"`
+ Stderr bool `json:"stderr,omitempty" protobuf:"varint,3,opt,name=stderr"`
// TTY 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.
- TTY bool `json:"tty,omitempty"`
+ TTY bool `json:"tty,omitempty" protobuf:"varint,4,opt,name=tty"`
// The container in which to execute the command.
// Defaults to only container if there is only one container in the pod.
- Container string `json:"container,omitempty"`
+ Container string `json:"container,omitempty" protobuf:"bytes,5,opt,name=container"`
}
// PodExecOptions is the query options to a Pod's remote exec call.
@@ -2404,26 +2729,26 @@ type PodExecOptions struct {
// Redirect the standard input stream of the pod for this call.
// Defaults to false.
- Stdin bool `json:"stdin,omitempty"`
+ Stdin bool `json:"stdin,omitempty" protobuf:"varint,1,opt,name=stdin"`
// Redirect the standard output stream of the pod for this call.
// Defaults to true.
- Stdout bool `json:"stdout,omitempty"`
+ Stdout bool `json:"stdout,omitempty" protobuf:"varint,2,opt,name=stdout"`
// Redirect the standard error stream of the pod for this call.
// Defaults to true.
- Stderr bool `json:"stderr,omitempty"`
+ Stderr bool `json:"stderr,omitempty" protobuf:"varint,3,opt,name=stderr"`
// TTY if true indicates that a tty will be allocated for the exec call.
// Defaults to false.
- TTY bool `json:"tty,omitempty"`
+ TTY bool `json:"tty,omitempty" protobuf:"varint,4,opt,name=tty"`
// Container in which to execute the command.
// Defaults to only container if there is only one container in the pod.
- Container string `json:"container,omitempty"`
+ Container string `json:"container,omitempty" protobuf:"bytes,5,opt,name=container"`
// Command is the remote command to execute. argv array. Not executed within a shell.
- Command []string `json:"command"`
+ Command []string `json:"command" protobuf:"bytes,6,rep,name=command"`
}
// PodProxyOptions is the query options to a Pod's proxy call.
@@ -2431,7 +2756,7 @@ type PodProxyOptions struct {
unversioned.TypeMeta `json:",inline"`
// Path is the URL path to use for the current proxy request to pod.
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,1,opt,name=path"`
}
// NodeProxyOptions is the query options to a Node's proxy call.
@@ -2439,7 +2764,7 @@ type NodeProxyOptions struct {
unversioned.TypeMeta `json:",inline"`
// Path is the URL path to use for the current proxy request to node.
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,1,opt,name=path"`
}
// ServiceProxyOptions is the query options to a Service's proxy call.
@@ -2451,28 +2776,47 @@ type ServiceProxyOptions struct {
// 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.
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,1,opt,name=path"`
+}
+
+// OwnerReference contains enough information to let you identify an owning
+// object. Currently, an owning object must be in the same namespace, so there
+// is no namespace field.
+type OwnerReference struct {
+ // API version of the referent.
+ APIVersion string `json:"apiVersion" protobuf:"bytes,5,opt,name=apiVersion"`
+ // Kind of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`
+ // Name of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name" protobuf:"bytes,3,opt,name=name"`
+ // UID of the referent.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ UID types.UID `json:"uid" protobuf:"bytes,4,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
+ // If true, this reference points to the managing controller.
+ Controller *bool `json:"controller,omitempty" protobuf:"varint,6,opt,name=controller"`
}
// ObjectReference contains enough information to let you inspect or modify the referred object.
type ObjectReference struct {
// Kind of the referent.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- Kind string `json:"kind,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
// Namespace of the referent.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md
- Namespace string `json:"namespace,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md
+ Namespace string `json:"namespace,omitempty" protobuf:"bytes,2,opt,name=namespace"`
// Name of the referent.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name,omitempty" protobuf:"bytes,3,opt,name=name"`
// UID of the referent.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#uids
- UID types.UID `json:"uid,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids
+ UID types.UID `json:"uid,omitempty" protobuf:"bytes,4,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
// API version of the referent.
- APIVersion string `json:"apiVersion,omitempty"`
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,5,opt,name=apiVersion"`
// Specific resourceVersion to which this reference is made, if any.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency
- ResourceVersion string `json:"resourceVersion,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency
+ ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,6,opt,name=resourceVersion"`
// 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].
@@ -2482,31 +2826,31 @@ type ObjectReference struct {
// index 2 in this pod). This syntax is chosen only to have some well-defined way of
// referencing a part of an object.
// TODO: this design is not final and this field is subject to change in the future.
- FieldPath string `json:"fieldPath,omitempty"`
+ FieldPath string `json:"fieldPath,omitempty" protobuf:"bytes,7,opt,name=fieldPath"`
}
// LocalObjectReference contains enough information to let you locate the
// referenced object inside the same namespace.
type LocalObjectReference struct {
// Name of the referent.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
// TODO: Add other useful fields. apiVersion, kind, uid?
- Name string `json:"name,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
}
// SerializedReference is a reference to serialized object.
type SerializedReference struct {
unversioned.TypeMeta `json:",inline"`
// The reference to an object in the system.
- Reference ObjectReference `json:"reference,omitempty"`
+ Reference ObjectReference `json:"reference,omitempty" protobuf:"bytes,1,opt,name=reference"`
}
// EventSource contains information for an event.
type EventSource struct {
// Component from which the event is generated.
- Component string `json:"component,omitempty"`
+ Component string `json:"component,omitempty" protobuf:"bytes,1,opt,name=component"`
// Host name on which the event is generated.
- Host string `json:"host,omitempty"`
+ Host string `json:"host,omitempty" protobuf:"bytes,2,opt,name=host"`
}
// Valid values for event types (new types could be added in future)
@@ -2524,57 +2868,57 @@ const (
type Event struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"`
// The object that this event is about.
- InvolvedObject ObjectReference `json:"involvedObject"`
+ InvolvedObject ObjectReference `json:"involvedObject" protobuf:"bytes,2,opt,name=involvedObject"`
// This should be a short, machine understandable string that gives the reason
// for the transition into the object's current status.
// TODO: provide exact specification for format.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,3,opt,name=reason"`
// A human-readable description of the status of this operation.
// TODO: decide on maximum length.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,4,opt,name=message"`
// The component reporting this event. Should be a short machine understandable string.
- Source EventSource `json:"source,omitempty"`
+ Source EventSource `json:"source,omitempty" protobuf:"bytes,5,opt,name=source"`
// The time at which the event was first recorded. (Time of server receipt is in TypeMeta.)
- FirstTimestamp unversioned.Time `json:"firstTimestamp,omitempty"`
+ FirstTimestamp unversioned.Time `json:"firstTimestamp,omitempty" protobuf:"bytes,6,opt,name=firstTimestamp"`
// The time at which the most recent occurrence of this event was recorded.
- LastTimestamp unversioned.Time `json:"lastTimestamp,omitempty"`
+ LastTimestamp unversioned.Time `json:"lastTimestamp,omitempty" protobuf:"bytes,7,opt,name=lastTimestamp"`
// The number of times this event has occurred.
- Count int32 `json:"count,omitempty"`
+ Count int32 `json:"count,omitempty" protobuf:"varint,8,opt,name=count"`
// Type of this event (Normal, Warning), new types could be added in the future
- Type string `json:"type,omitempty"`
+ Type string `json:"type,omitempty" protobuf:"bytes,9,opt,name=type"`
}
// EventList is a list of events.
type EventList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of events
- Items []Event `json:"items"`
+ Items []Event `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// List holds a list of objects, which may not be known by the server.
type List struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of objects
- Items []runtime.RawExtension `json:"items"`
+ Items []runtime.RawExtension `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// LimitType is a type of object that is limited
@@ -2590,23 +2934,23 @@ const (
// LimitRangeItem defines a min/max usage limit for any resource that matches on kind.
type LimitRangeItem struct {
// Type of resource that this limit applies to.
- Type LimitType `json:"type,omitempty"`
+ Type LimitType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type,casttype=LimitType"`
// Max usage constraints on this kind by resource name.
- Max ResourceList `json:"max,omitempty"`
+ Max ResourceList `json:"max,omitempty" protobuf:"bytes,2,rep,name=max,casttype=ResourceList,castkey=ResourceName"`
// Min usage constraints on this kind by resource name.
- Min ResourceList `json:"min,omitempty"`
+ Min ResourceList `json:"min,omitempty" protobuf:"bytes,3,rep,name=min,casttype=ResourceList,castkey=ResourceName"`
// Default resource requirement limit value by resource name if resource limit is omitted.
- Default ResourceList `json:"default,omitempty"`
+ Default ResourceList `json:"default,omitempty" protobuf:"bytes,4,rep,name=default,casttype=ResourceList,castkey=ResourceName"`
// DefaultRequest is the default resource requirement request value by resource name if resource request is omitted.
- DefaultRequest ResourceList `json:"defaultRequest,omitempty"`
+ DefaultRequest ResourceList `json:"defaultRequest,omitempty" protobuf:"bytes,5,rep,name=defaultRequest,casttype=ResourceList,castkey=ResourceName"`
// 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.
- MaxLimitRequestRatio ResourceList `json:"maxLimitRequestRatio,omitempty"`
+ MaxLimitRequestRatio ResourceList `json:"maxLimitRequestRatio,omitempty" protobuf:"bytes,6,rep,name=maxLimitRequestRatio,casttype=ResourceList,castkey=ResourceName"`
}
// LimitRangeSpec defines a min/max usage limit for resources that match on kind.
type LimitRangeSpec struct {
// Limits is the list of LimitRangeItem objects that are enforced.
- Limits []LimitRangeItem `json:"limits"`
+ Limits []LimitRangeItem `json:"limits" protobuf:"bytes,1,rep,name=limits"`
}
// +genclient=true
@@ -2615,24 +2959,24 @@ type LimitRangeSpec struct {
type LimitRange struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the limits enforced.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec LimitRangeSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec LimitRangeSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
}
// LimitRangeList is a list of LimitRange items.
type LimitRangeList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is a list of LimitRange objects.
- // More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_limit_range.md
- Items []LimitRange `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_limit_range.md
+ Items []LimitRange `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// The following identify resource constants for Kubernetes object types
@@ -2651,14 +2995,18 @@ const (
ResourceConfigMaps ResourceName = "configmaps"
// ResourcePersistentVolumeClaims, number
ResourcePersistentVolumeClaims ResourceName = "persistentvolumeclaims"
+ // ResourceServicesNodePorts, number
+ ResourceServicesNodePorts ResourceName = "services.nodeports"
+ // ResourceServicesLoadBalancers, number
+ ResourceServicesLoadBalancers ResourceName = "services.loadbalancers"
// CPU request, in cores. (500m = .5 cores)
- ResourceCPURequest ResourceName = "cpu.request"
- // CPU limit, in cores. (500m = .5 cores)
- ResourceCPULimit ResourceName = "cpu.limit"
+ ResourceRequestsCPU ResourceName = "requests.cpu"
// Memory request, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
- ResourceMemoryRequest ResourceName = "memory.request"
+ ResourceRequestsMemory ResourceName = "requests.memory"
+ // CPU limit, in cores. (500m = .5 cores)
+ ResourceLimitsCPU ResourceName = "limits.cpu"
// Memory limit, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
- ResourceMemoryLimit ResourceName = "memory.limit"
+ ResourceLimitsMemory ResourceName = "limits.memory"
)
// A ResourceQuotaScope defines a filter that must match each object tracked by a quota
@@ -2678,20 +3026,20 @@ const (
// ResourceQuotaSpec defines the desired hard limits to enforce for Quota.
type ResourceQuotaSpec struct {
// Hard is the set of desired hard limits for each named resource.
- // More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
- Hard ResourceList `json:"hard,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ Hard ResourceList `json:"hard,omitempty" protobuf:"bytes,1,rep,name=hard,casttype=ResourceList,castkey=ResourceName"`
// A collection of filters that must match each object tracked by a quota.
// If not specified, the quota matches all objects.
- Scopes []ResourceQuotaScope `json:"scopes,omitempty"`
+ Scopes []ResourceQuotaScope `json:"scopes,omitempty" protobuf:"bytes,2,rep,name=scopes,casttype=ResourceQuotaScope"`
}
// ResourceQuotaStatus defines the enforced hard limits and observed use.
type ResourceQuotaStatus struct {
// Hard is the set of enforced hard limits for each named resource.
- // More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
- Hard ResourceList `json:"hard,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ Hard ResourceList `json:"hard,omitempty" protobuf:"bytes,1,rep,name=hard,casttype=ResourceList,castkey=ResourceName"`
// Used is the current observed total usage of the resource in the namespace.
- Used ResourceList `json:"used,omitempty"`
+ Used ResourceList `json:"used,omitempty" protobuf:"bytes,2,rep,name=used,casttype=ResourceList,castkey=ResourceName"`
}
// +genclient=true
@@ -2700,28 +3048,28 @@ type ResourceQuotaStatus struct {
type ResourceQuota struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the desired quota.
- // http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec ResourceQuotaSpec `json:"spec,omitempty"`
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ResourceQuotaSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status defines the actual enforced quota and its current usage.
- // http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status ResourceQuotaStatus `json:"status,omitempty"`
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ResourceQuotaStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// ResourceQuotaList is a list of ResourceQuota items.
type ResourceQuotaList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is a list of ResourceQuota objects.
- // More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
- Items []ResourceQuota `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota
+ Items []ResourceQuota `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// +genclient=true
@@ -2731,18 +3079,18 @@ type ResourceQuotaList struct {
type Secret struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Data contains the secret data. Each key must be a valid DNS_SUBDOMAIN
// or leading dot followed by valid DNS_SUBDOMAIN.
// 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
- Data map[string][]byte `json:"data,omitempty"`
+ Data map[string][]byte `json:"data,omitempty" protobuf:"bytes,2,rep,name=data"`
// Used to facilitate programmatic handling of secret data.
- Type SecretType `json:"type,omitempty"`
+ Type SecretType `json:"type,omitempty" protobuf:"bytes,3,opt,name=type,casttype=SecretType"`
}
const MaxSecretSize = 1 * 1024 * 1024
@@ -2803,12 +3151,12 @@ const (
type SecretList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is a list of secret objects.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md
- Items []Secret `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md
+ Items []Secret `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// +genclient=true
@@ -2817,23 +3165,23 @@ type SecretList struct {
type ConfigMap struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Data contains the configuration data.
// Each key must be a valid DNS_SUBDOMAIN with an optional leading dot.
- Data map[string]string `json:"data,omitempty"`
+ Data map[string]string `json:"data,omitempty" protobuf:"bytes,2,rep,name=data"`
}
// ConfigMapList is a resource containing a list of ConfigMap objects.
type ConfigMapList struct {
unversioned.TypeMeta `json:",inline"`
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of ConfigMaps.
- Items []ConfigMap `json:"items,omitempty"`
+ Items []ConfigMap `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// Type and constants for component health validation.
@@ -2848,16 +3196,16 @@ const (
type ComponentCondition struct {
// Type of condition for a component.
// Valid value: "Healthy"
- Type ComponentConditionType `json:"type"`
+ Type ComponentConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=ComponentConditionType"`
// Status of the condition for a component.
// Valid values for "Healthy": "True", "False", or "Unknown".
- Status ConditionStatus `json:"status"`
+ Status ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=ConditionStatus"`
// Message about the condition for a component.
// For example, information about a health check.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,3,opt,name=message"`
// Condition error code for a component.
// For example, a health check error code.
- Error string `json:"error,omitempty"`
+ Error string `json:"error,omitempty" protobuf:"bytes,4,opt,name=error"`
}
// +genclient=true,nonNamespaced=true
@@ -2866,37 +3214,40 @@ type ComponentCondition struct {
type ComponentStatus struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of component conditions observed
- Conditions []ComponentCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ Conditions []ComponentCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,2,rep,name=conditions"`
}
// Status of all the conditions for the component as a list of ComponentStatus objects.
type ComponentStatusList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of ComponentStatus objects.
- Items []ComponentStatus `json:"items"`
+ Items []ComponentStatus `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// DownwardAPIVolumeSource represents a volume containing downward API info.
// Downward API volumes support ownership management and SELinux relabeling.
type DownwardAPIVolumeSource struct {
// Items is a list of downward API volume file
- Items []DownwardAPIVolumeFile `json:"items,omitempty"`
+ Items []DownwardAPIVolumeFile `json:"items,omitempty" protobuf:"bytes,1,rep,name=items"`
}
// DownwardAPIVolumeFile represents information to create the file containing the pod field
type DownwardAPIVolumeFile struct {
// 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 '..'
- Path string `json:"path"`
+ Path string `json:"path" protobuf:"bytes,1,opt,name=path"`
// Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.
- FieldRef ObjectFieldSelector `json:"fieldRef"`
+ FieldRef *ObjectFieldSelector `json:"fieldRef,omitempty" protobuf:"bytes,2,opt,name=fieldRef"`
+ // Selects a resource of the container: only resources limits and requests
+ // (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.
+ ResourceFieldRef *ResourceFieldSelector `json:"resourceFieldRef,omitempty" protobuf:"bytes,3,opt,name=resourceFieldRef"`
}
// SecurityContext holds security configuration that will be applied to a container.
@@ -2905,56 +3256,56 @@ type DownwardAPIVolumeFile struct {
type SecurityContext struct {
// The capabilities to add/drop when running containers.
// Defaults to the default set of capabilities granted by the container runtime.
- Capabilities *Capabilities `json:"capabilities,omitempty"`
+ Capabilities *Capabilities `json:"capabilities,omitempty" protobuf:"bytes,1,opt,name=capabilities"`
// Run container in privileged mode.
// Processes in privileged containers are essentially equivalent to root on the host.
// Defaults to false.
- Privileged *bool `json:"privileged,omitempty"`
+ Privileged *bool `json:"privileged,omitempty" protobuf:"varint,2,opt,name=privileged"`
// 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.
- SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty"`
+ SELinuxOptions *SELinuxOptions `json:"seLinuxOptions,omitempty" protobuf:"bytes,3,opt,name=seLinuxOptions"`
// 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.
- RunAsUser *int64 `json:"runAsUser,omitempty"`
+ RunAsUser *int64 `json:"runAsUser,omitempty" protobuf:"varint,4,opt,name=runAsUser"`
// 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.
- RunAsNonRoot *bool `json:"runAsNonRoot,omitempty"`
+ RunAsNonRoot *bool `json:"runAsNonRoot,omitempty" protobuf:"varint,5,opt,name=runAsNonRoot"`
// Whether this container has a read-only root filesystem.
// Default is false.
- ReadOnlyRootFilesystem *bool `json:"readOnlyRootFilesystem,omitempty"`
+ ReadOnlyRootFilesystem *bool `json:"readOnlyRootFilesystem,omitempty" protobuf:"varint,6,opt,name=readOnlyRootFilesystem"`
}
// SELinuxOptions are the labels to be applied to the container
type SELinuxOptions struct {
// User is a SELinux user label that applies to the container.
- User string `json:"user,omitempty"`
+ User string `json:"user,omitempty" protobuf:"bytes,1,opt,name=user"`
// Role is a SELinux role label that applies to the container.
- Role string `json:"role,omitempty"`
+ Role string `json:"role,omitempty" protobuf:"bytes,2,opt,name=role"`
// Type is a SELinux type label that applies to the container.
- Type string `json:"type,omitempty"`
+ Type string `json:"type,omitempty" protobuf:"bytes,3,opt,name=type"`
// Level is SELinux level label that applies to the container.
- Level string `json:"level,omitempty"`
+ Level string `json:"level,omitempty" protobuf:"bytes,4,opt,name=level"`
}
// RangeAllocation is not a public type.
type RangeAllocation struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Range is string that identifies the range represented by 'data'.
- Range string `json:"range"`
+ Range string `json:"range" protobuf:"bytes,2,opt,name=range"`
// Data is a bit array containing all allocated addresses in the previous segment.
- Data []byte `json:"data"`
+ Data []byte `json:"data" protobuf:"bytes,3,opt,name=data"`
}
const (
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go
similarity index 76%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go
index f1878b5481a99c5309b9b12fbf5fe6d02bbb8087..7587654aa27a3661a5974898e2850b1ef68f3c06 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/v1/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,10 +29,10 @@ package v1
// AUTO-GENERATED FUNCTIONS START HERE
var map_AWSElasticBlockStoreVolumeSource = map[string]string{
"": "Represents a Persistent Disk resource in AWS.\n\nAn 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": "Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore",
+ "volumeID": "Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore",
"partition": "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).",
- "readOnly": "Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\". If omitted, the default is \"false\". More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore",
+ "readOnly": "Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\". If omitted, the default is \"false\". More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore",
}
func (AWSElasticBlockStoreVolumeSource) SwaggerDoc() map[string]string {
@@ -40,14 +40,26 @@ func (AWSElasticBlockStoreVolumeSource) SwaggerDoc() map[string]string {
}
var map_Affinity = map[string]string{
- "": "Affinity is a group of affinity scheduling rules, currently only node affinity, but in the future also inter-pod affinity.",
- "nodeAffinity": "Describes node affinity scheduling rules for the pod.",
+ "": "Affinity is a group of affinity scheduling rules.",
+ "nodeAffinity": "Describes node affinity scheduling rules for the pod.",
+ "podAffinity": "Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).",
+ "podAntiAffinity": "Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).",
}
func (Affinity) SwaggerDoc() map[string]string {
return map_Affinity
}
+var map_AttachedVolume = map[string]string{
+ "": "AttachedVolume describes a volume attached to a node",
+ "name": "Name of the attached volume",
+ "devicePath": "DevicePath represents the device path where the volume should be avilable",
+}
+
+func (AttachedVolume) SwaggerDoc() map[string]string {
+ return map_AttachedVolume
+}
+
var map_AzureFileVolumeSource = map[string]string{
"": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.",
"secretName": "the name of secret that contains Azure Storage Account Name and Key",
@@ -61,7 +73,7 @@ func (AzureFileVolumeSource) SwaggerDoc() map[string]string {
var map_Binding = map[string]string{
"": "Binding ties one object to another. For example, a pod is bound to a node by a scheduler.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"target": "The target object that you want to bind to the standard object.",
}
@@ -81,12 +93,12 @@ func (Capabilities) SwaggerDoc() map[string]string {
var map_CephFSVolumeSource = map[string]string{
"": "Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.",
- "monitors": "Required: Monitors is a collection of Ceph monitors More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it",
+ "monitors": "Required: Monitors is a collection of Ceph monitors More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it",
"path": "Optional: Used as the mounted root, rather than the full Ceph tree, default is /",
- "user": "Optional: User is the rados user name, default is admin More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it",
- "secretFile": "Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it",
- "secretRef": "Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it",
- "readOnly": "Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: http://releases.k8s.io/release-1.2/examples/cephfs/README.md#how-to-use-it",
+ "user": "Optional: User is the rados user name, default is admin More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it",
+ "secretFile": "Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it",
+ "secretRef": "Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it",
+ "readOnly": "Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: http://releases.k8s.io/release-1.3/examples/cephfs/README.md#how-to-use-it",
}
func (CephFSVolumeSource) SwaggerDoc() map[string]string {
@@ -95,9 +107,9 @@ func (CephFSVolumeSource) SwaggerDoc() map[string]string {
var map_CinderVolumeSource = map[string]string{
"": "Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.",
- "volumeID": "volume id used to identify the volume in cinder More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md",
- "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: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md",
- "readOnly": "Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md",
+ "volumeID": "volume id used to identify the volume in cinder More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md",
+ "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: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md",
+ "readOnly": "Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md",
}
func (CinderVolumeSource) SwaggerDoc() map[string]string {
@@ -118,7 +130,7 @@ func (ComponentCondition) SwaggerDoc() map[string]string {
var map_ComponentStatus = map[string]string{
"": "ComponentStatus (and ComponentStatusList) holds the cluster validation info.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"conditions": "List of component conditions observed",
}
@@ -128,7 +140,7 @@ func (ComponentStatus) SwaggerDoc() map[string]string {
var map_ComponentStatusList = map[string]string{
"": "Status of all the conditions for the component as a list of ComponentStatus objects.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of ComponentStatus objects.",
}
@@ -138,7 +150,7 @@ func (ComponentStatusList) SwaggerDoc() map[string]string {
var map_ConfigMap = map[string]string{
"": "ConfigMap holds configuration data for pods to consume.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"data": "Data contains the configuration data. Each key must be a valid DNS_SUBDOMAIN with an optional leading dot.",
}
@@ -157,7 +169,7 @@ func (ConfigMapKeySelector) SwaggerDoc() map[string]string {
var map_ConfigMapList = map[string]string{
"": "ConfigMapList is a resource containing a list of ConfigMap objects.",
- "metadata": "More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is the list of ConfigMaps.",
}
@@ -177,20 +189,20 @@ func (ConfigMapVolumeSource) SwaggerDoc() map[string]string {
var map_Container = map[string]string{
"": "A single application container that you want to run within a pod.",
"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.",
- "image": "Docker image name. More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md",
- "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. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md#containers-and-commands",
- "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. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md#containers-and-commands",
+ "image": "Docker image name. More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md",
+ "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. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands",
+ "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. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md#containers-and-commands",
"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.",
"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.",
"env": "List of environment variables to set in the container. Cannot be updated.",
- "resources": "Compute Resources required by this container. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#resources",
- "volumeMounts": "Pod volumes to mount into the container's filesyste. Cannot be updated.",
- "livenessProbe": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes",
- "readinessProbe": "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes",
+ "resources": "Compute Resources required by this container. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources",
+ "volumeMounts": "Pod volumes to mount into the container's filesystem. Cannot be updated.",
+ "livenessProbe": "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes",
+ "readinessProbe": "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes",
"lifecycle": "Actions that the management system should take in response to container lifecycle events. Cannot be updated.",
"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. Defaults to /dev/termination-log. Cannot be updated.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/images.md#updating-images",
- "securityContext": "Security options the pod should run with. More info: http://releases.k8s.io/release-1.2/docs/design/security_context.md",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#updating-images",
+ "securityContext": "Security options the pod should run with. More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md",
"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.",
"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",
"tty": "Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.",
@@ -275,9 +287,9 @@ var map_ContainerStatus = map[string]string{
"lastState": "Details about the container's last termination condition.",
"ready": "Specifies whether the container has passed its readiness probe.",
"restartCount": "The number of times the container has been restarted, currently based on the number of dead containers that have not yet been removed. Note that this is calculated from dead containers. But those containers are subject to garbage collection. This value will get capped at 5 by GC.",
- "image": "The image the container is running. More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md",
+ "image": "The image the container is running. More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md",
"imageID": "ImageID of the container's image.",
- "containerID": "Container's ID in the format 'docker://<container_id>'. More info: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#container-information",
+ "containerID": "Container's ID in the format 'docker://<container_id>'. More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#container-information",
}
func (ContainerStatus) SwaggerDoc() map[string]string {
@@ -296,6 +308,8 @@ func (DaemonEndpoint) SwaggerDoc() map[string]string {
var map_DeleteOptions = map[string]string{
"": "DeleteOptions may be provided when deleting an API object",
"gracePeriodSeconds": "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.",
+ "preconditions": "Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned.",
+ "orphanDependents": "Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list.",
}
func (DeleteOptions) SwaggerDoc() map[string]string {
@@ -303,9 +317,10 @@ func (DeleteOptions) SwaggerDoc() map[string]string {
}
var map_DownwardAPIVolumeFile = map[string]string{
- "": "DownwardAPIVolumeFile represents information to create the file containing the pod field",
- "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 '..'",
- "fieldRef": "Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.",
+ "": "DownwardAPIVolumeFile represents information to create the file containing the pod field",
+ "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 '..'",
+ "fieldRef": "Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.",
+ "resourceFieldRef": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.",
}
func (DownwardAPIVolumeFile) SwaggerDoc() map[string]string {
@@ -323,7 +338,7 @@ func (DownwardAPIVolumeSource) SwaggerDoc() map[string]string {
var map_EmptyDirVolumeSource = map[string]string{
"": "Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#emptydir",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir",
}
func (EmptyDirVolumeSource) SwaggerDoc() map[string]string {
@@ -332,7 +347,8 @@ func (EmptyDirVolumeSource) SwaggerDoc() map[string]string {
var map_EndpointAddress = map[string]string{
"": "EndpointAddress is a tuple that describes single IP address.",
- "ip": "The IP of this endpoint. May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24).",
+ "ip": "The IP of this endpoint. May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24). IPv6 is also accepted but not fully supported on all platforms. Also, certain kubernetes components, like kube-proxy, are not IPv6 ready.",
+ "hostname": "The Hostname of this endpoint",
"targetRef": "Reference to object providing the endpoint.",
}
@@ -364,7 +380,7 @@ func (EndpointSubset) SwaggerDoc() map[string]string {
var map_Endpoints = map[string]string{
"": "Endpoints is a collection of endpoints that implement the actual service. Example:\n Name: \"mysvc\",\n Subsets: [\n {\n Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}],\n Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}]\n },\n {\n Addresses: [{\"ip\": \"10.10.3.3\"}],\n Ports: [{\"name\": \"a\", \"port\": 93}, {\"name\": \"b\", \"port\": 76}]\n },\n ]",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"subsets": "The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service.",
}
@@ -374,7 +390,7 @@ func (Endpoints) SwaggerDoc() map[string]string {
var map_EndpointsList = map[string]string{
"": "EndpointsList is a list of endpoints.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of endpoints.",
}
@@ -394,10 +410,11 @@ func (EnvVar) SwaggerDoc() map[string]string {
}
var map_EnvVarSource = map[string]string{
- "": "EnvVarSource represents a source for the value of an EnvVar.",
- "fieldRef": "Selects a field of the pod; only name and namespace are supported.",
- "configMapKeyRef": "Selects a key of a ConfigMap.",
- "secretKeyRef": "Selects a key of a secret in the pod's namespace",
+ "": "EnvVarSource represents a source for the value of an EnvVar.",
+ "fieldRef": "Selects a field of the pod; only name and namespace are supported.",
+ "resourceFieldRef": "Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.",
+ "configMapKeyRef": "Selects a key of a ConfigMap.",
+ "secretKeyRef": "Selects a key of a secret in the pod's namespace",
}
func (EnvVarSource) SwaggerDoc() map[string]string {
@@ -406,7 +423,7 @@ func (EnvVarSource) SwaggerDoc() map[string]string {
var map_Event = map[string]string{
"": "Event is a report of an event somewhere in the cluster.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"involvedObject": "The object that this event is about.",
"reason": "This should be a short, machine understandable string that gives the reason for the transition into the object's current status.",
"message": "A human-readable description of the status of this operation.",
@@ -423,7 +440,7 @@ func (Event) SwaggerDoc() map[string]string {
var map_EventList = map[string]string{
"": "EventList is a list of events.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of events",
}
@@ -476,7 +493,7 @@ var map_FlexVolumeSource = map[string]string{
"": "FlexVolume represents a generic volume resource that is provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.",
"driver": "Driver is the name of the driver to use for this volume.",
"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.",
- "secretRef": "Optional: SecretRef is reference to the authentication secret for User, default is empty.",
+ "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.",
"readOnly": "Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.",
"options": "Optional: Extra command options if any.",
}
@@ -496,10 +513,10 @@ func (FlockerVolumeSource) SwaggerDoc() map[string]string {
var map_GCEPersistentDiskVolumeSource = map[string]string{
"": "Represents a Persistent Disk resource in Google Compute Engine.\n\nA 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": "Unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
- "partition": "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
- "readOnly": "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
+ "pdName": "Unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
+ "partition": "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
+ "readOnly": "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
}
func (GCEPersistentDiskVolumeSource) SwaggerDoc() map[string]string {
@@ -519,9 +536,9 @@ func (GitRepoVolumeSource) SwaggerDoc() map[string]string {
var map_GlusterfsVolumeSource = map[string]string{
"": "Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.",
- "endpoints": "EndpointsName is the endpoint name that details Glusterfs topology. More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod",
- "path": "Path is the Glusterfs volume path. More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod",
- "readOnly": "ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md#create-a-pod",
+ "endpoints": "EndpointsName is the endpoint name that details Glusterfs topology. More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod",
+ "path": "Path is the Glusterfs volume path. More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod",
+ "readOnly": "ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md#create-a-pod",
}
func (GlusterfsVolumeSource) SwaggerDoc() map[string]string {
@@ -564,7 +581,7 @@ func (Handler) SwaggerDoc() map[string]string {
var map_HostPathVolumeSource = map[string]string{
"": "Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.",
- "path": "Path of the directory on the host. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath",
+ "path": "Path of the directory on the host. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath",
}
func (HostPathVolumeSource) SwaggerDoc() map[string]string {
@@ -577,7 +594,7 @@ var map_ISCSIVolumeSource = map[string]string{
"iqn": "Target iSCSI Qualified Name.",
"lun": "iSCSI target lun number.",
"iscsiInterface": "Optional: Defaults to 'default' (tcp). iSCSI interface name that uses an iSCSI transport.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#iscsi",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#iscsi",
"readOnly": "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.",
}
@@ -597,8 +614,8 @@ func (KeyToPath) SwaggerDoc() map[string]string {
var map_Lifecycle = map[string]string{
"": "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.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#hook-details",
- "preStop": "PreStop is called immediately before a container is terminated. The container is terminated after the handler completes. The reason for termination is passed to the handler. Regardless of the outcome of the handler, the container is eventually terminated. Other management of the container blocks until the hook completes. More info: http://releases.k8s.io/release-1.2/docs/user-guide/container-environment.md#hook-details",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details",
+ "preStop": "PreStop is called immediately before a container is terminated. The container is terminated after the handler completes. The reason for termination is passed to the handler. Regardless of the outcome of the handler, the container is eventually terminated. Other management of the container blocks until the hook completes. More info: http://releases.k8s.io/release-1.3/docs/user-guide/container-environment.md#hook-details",
}
func (Lifecycle) SwaggerDoc() map[string]string {
@@ -607,8 +624,8 @@ func (Lifecycle) SwaggerDoc() map[string]string {
var map_LimitRange = map[string]string{
"": "LimitRange sets resource usage limits for each kind of resource in a Namespace.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the limits enforced. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the limits enforced. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (LimitRange) SwaggerDoc() map[string]string {
@@ -631,8 +648,8 @@ func (LimitRangeItem) SwaggerDoc() map[string]string {
var map_LimitRangeList = map[string]string{
"": "LimitRangeList is a list of LimitRange items.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "Items is a list of LimitRange objects. More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_limit_range.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "Items is a list of LimitRange objects. More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_limit_range.md",
}
func (LimitRangeList) SwaggerDoc() map[string]string {
@@ -650,7 +667,7 @@ func (LimitRangeSpec) SwaggerDoc() map[string]string {
var map_List = map[string]string{
"": "List holds a list of objects, which may not be known by the server.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of objects",
}
@@ -692,7 +709,7 @@ func (LoadBalancerStatus) SwaggerDoc() map[string]string {
var map_LocalObjectReference = map[string]string{
"": "LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.",
- "name": "Name of the referent. More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
+ "name": "Name of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
}
func (LocalObjectReference) SwaggerDoc() map[string]string {
@@ -701,9 +718,9 @@ func (LocalObjectReference) SwaggerDoc() map[string]string {
var map_NFSVolumeSource = map[string]string{
"": "Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.",
- "server": "Server is the hostname or IP address of the NFS server. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs",
- "path": "Path that is exported by the NFS server. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs",
- "readOnly": "ReadOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs",
+ "server": "Server is the hostname or IP address of the NFS server. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs",
+ "path": "Path that is exported by the NFS server. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs",
+ "readOnly": "ReadOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs",
}
func (NFSVolumeSource) SwaggerDoc() map[string]string {
@@ -712,9 +729,9 @@ func (NFSVolumeSource) SwaggerDoc() map[string]string {
var map_Namespace = map[string]string{
"": "Namespace provides a scope for Names. Use of multiple namespaces is optional.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the behavior of the Namespace. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status describes the current status of a Namespace. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the behavior of the Namespace. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status describes the current status of a Namespace. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Namespace) SwaggerDoc() map[string]string {
@@ -723,8 +740,8 @@ func (Namespace) SwaggerDoc() map[string]string {
var map_NamespaceList = map[string]string{
"": "NamespaceList is a list of Namespaces.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "Items is the list of Namespace objects in the list. More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "Items is the list of Namespace objects in the list. More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md",
}
func (NamespaceList) SwaggerDoc() map[string]string {
@@ -733,7 +750,7 @@ func (NamespaceList) SwaggerDoc() map[string]string {
var map_NamespaceSpec = map[string]string{
"": "NamespaceSpec describes the attributes on a Namespace.",
- "finalizers": "Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: http://releases.k8s.io/release-1.2/docs/design/namespaces.md#finalizers",
+ "finalizers": "Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#finalizers",
}
func (NamespaceSpec) SwaggerDoc() map[string]string {
@@ -742,7 +759,7 @@ func (NamespaceSpec) SwaggerDoc() map[string]string {
var map_NamespaceStatus = map[string]string{
"": "NamespaceStatus is information about the current status of a Namespace.",
- "phase": "Phase is the current lifecycle phase of the namespace. More info: http://releases.k8s.io/release-1.2/docs/design/namespaces.md#phases",
+ "phase": "Phase is the current lifecycle phase of the namespace. More info: http://releases.k8s.io/release-1.3/docs/design/namespaces.md#phases",
}
func (NamespaceStatus) SwaggerDoc() map[string]string {
@@ -751,9 +768,9 @@ func (NamespaceStatus) SwaggerDoc() map[string]string {
var map_Node = map[string]string{
"": "Node is a worker node in Kubernetes, formerly known as minion. Each node will have a unique identifier in the cache (i.e. in etcd).",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the behavior of a node. http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Most recently observed status of the node. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the behavior of a node. http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Most recently observed status of the node. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Node) SwaggerDoc() map[string]string {
@@ -805,7 +822,7 @@ func (NodeDaemonEndpoints) SwaggerDoc() map[string]string {
var map_NodeList = map[string]string{
"": "NodeList is the whole list of all Nodes which have been registered with master.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of nodes",
}
@@ -856,7 +873,7 @@ var map_NodeSpec = map[string]string{
"podCIDR": "PodCIDR represents the pod IP range assigned to the node.",
"externalID": "External ID of the node assigned by some machine database (e.g. a cloud provider). Deprecated.",
"providerID": "ID of the node assigned by the cloud provider in the format: <ProviderName>://<ProviderSpecificNodeID>",
- "unschedulable": "Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#manual-node-administration\"`",
+ "unschedulable": "Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#manual-node-administration\"`",
}
func (NodeSpec) SwaggerDoc() map[string]string {
@@ -865,14 +882,16 @@ func (NodeSpec) SwaggerDoc() map[string]string {
var map_NodeStatus = map[string]string{
"": "NodeStatus is information about the current status of a node.",
- "capacity": "Capacity represents the total resources of a node. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#capacity for more details.",
+ "capacity": "Capacity represents the total resources of a node. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity for more details.",
"allocatable": "Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity.",
- "phase": "NodePhase is the recently observed lifecycle phase of the node. More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-phase",
- "conditions": "Conditions is an array of current observed node conditions. More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-condition",
- "addresses": "List of addresses reachable to the node. Queried from cloud provider, if available. More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-addresses",
+ "phase": "NodePhase is the recently observed lifecycle phase of the node. More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-phase",
+ "conditions": "Conditions is an array of current observed node conditions. More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-condition",
+ "addresses": "List of addresses reachable to the node. Queried from cloud provider, if available. More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-addresses",
"daemonEndpoints": "Endpoints of daemons running on the Node.",
- "nodeInfo": "Set of ids/uuids to uniquely identify the node. More info: http://releases.k8s.io/release-1.2/docs/admin/node.md#node-info",
+ "nodeInfo": "Set of ids/uuids to uniquely identify the node. More info: http://releases.k8s.io/release-1.3/docs/admin/node.md#node-info",
"images": "List of container images on this node",
+ "volumesInUse": "List of attachable volumes in use (mounted) by the node.",
+ "volumesAttached": "List of volumes that are attached to the node.",
}
func (NodeStatus) SwaggerDoc() map[string]string {
@@ -889,6 +908,8 @@ var map_NodeSystemInfo = map[string]string{
"containerRuntimeVersion": "ContainerRuntime Version reported by the node through runtime remote API (e.g. docker://1.5.0).",
"kubeletVersion": "Kubelet Version reported by the node.",
"kubeProxyVersion": "KubeProxy Version reported by the node.",
+ "operatingSystem": "The Operating System reported by the node",
+ "architecture": "The Architecture reported by the node",
}
func (NodeSystemInfo) SwaggerDoc() map[string]string {
@@ -907,18 +928,20 @@ func (ObjectFieldSelector) SwaggerDoc() map[string]string {
var map_ObjectMeta = map[string]string{
"": "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.",
- "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://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
- "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.\n\nIf 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).\n\nApplied only if Name is not specified. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#idempotency",
- "namespace": "Namespace defines the space within 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.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md",
+ "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://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
+ "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.\n\nIf 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).\n\nApplied only if Name is not specified. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#idempotency",
+ "namespace": "Namespace defines the space within 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.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md",
"selfLink": "SelfLink is a URL representing this object. Populated by the system. Read-only.",
- "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.\n\nPopulated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#uids",
- "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.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency",
+ "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.\n\nPopulated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids",
+ "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.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency",
"generation": "A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.",
- "creationTimestamp": "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.\n\nPopulated by the system. Read-only. Null for lists. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "deletionTimestamp": "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 will be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field. Once 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. Once the resource is deleted in the API, the Kubelet will send a hard termination signal to the container. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "creationTimestamp": "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.\n\nPopulated by the system. Read-only. Null for lists. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "deletionTimestamp": "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 will be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field. Once 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. Once the resource is deleted in the API, the Kubelet will send a hard termination signal to the container. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"deletionGracePeriodSeconds": "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.",
- "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://releases.k8s.io/release-1.2/docs/user-guide/labels.md",
- "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://releases.k8s.io/release-1.2/docs/user-guide/annotations.md",
+ "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://releases.k8s.io/release-1.3/docs/user-guide/labels.md",
+ "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://releases.k8s.io/release-1.3/docs/user-guide/annotations.md",
+ "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.",
+ "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.",
}
func (ObjectMeta) SwaggerDoc() map[string]string {
@@ -927,12 +950,12 @@ func (ObjectMeta) SwaggerDoc() map[string]string {
var map_ObjectReference = map[string]string{
"": "ObjectReference contains enough information to let you inspect or modify the referred object.",
- "kind": "Kind of the referent. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "namespace": "Namespace of the referent. More info: http://releases.k8s.io/release-1.2/docs/user-guide/namespaces.md",
- "name": "Name of the referent. More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
- "uid": "UID of the referent. More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#uids",
+ "kind": "Kind of the referent. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "namespace": "Namespace of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/namespaces.md",
+ "name": "Name of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
+ "uid": "UID of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids",
"apiVersion": "API version of the referent.",
- "resourceVersion": "Specific resourceVersion to which this reference is made, if any. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#concurrency-control-and-consistency",
+ "resourceVersion": "Specific resourceVersion to which this reference is made, if any. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#concurrency-control-and-consistency",
"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.",
}
@@ -940,11 +963,24 @@ func (ObjectReference) SwaggerDoc() map[string]string {
return map_ObjectReference
}
+var map_OwnerReference = map[string]string{
+ "": "OwnerReference contains enough information to let you identify an owning object. Currently, an owning object must be in the same namespace, so there is no namespace field.",
+ "apiVersion": "API version of the referent.",
+ "kind": "Kind of the referent. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "name": "Name of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
+ "uid": "UID of the referent. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#uids",
+ "controller": "If true, this reference points to the managing controller.",
+}
+
+func (OwnerReference) SwaggerDoc() map[string]string {
+ return map_OwnerReference
+}
+
var map_PersistentVolume = map[string]string{
- "": "PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines a specification of a persistent volume owned by the cluster. Provisioned by an administrator. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistent-volumes",
- "status": "Status represents the current information/status for the persistent volume. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistent-volumes",
+ "": "PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines a specification of a persistent volume owned by the cluster. Provisioned by an administrator. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes",
+ "status": "Status represents the current information/status for the persistent volume. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistent-volumes",
}
func (PersistentVolume) SwaggerDoc() map[string]string {
@@ -953,9 +989,9 @@ func (PersistentVolume) SwaggerDoc() map[string]string {
var map_PersistentVolumeClaim = map[string]string{
"": "PersistentVolumeClaim is a user's request for and claim to a persistent volume",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the desired characteristics of a volume requested by a pod author. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
- "status": "Status represents the current information/status of a persistent volume claim. Read-only. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the desired characteristics of a volume requested by a pod author. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
+ "status": "Status represents the current information/status of a persistent volume claim. Read-only. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
}
func (PersistentVolumeClaim) SwaggerDoc() map[string]string {
@@ -964,8 +1000,8 @@ func (PersistentVolumeClaim) SwaggerDoc() map[string]string {
var map_PersistentVolumeClaimList = map[string]string{
"": "PersistentVolumeClaimList is a list of PersistentVolumeClaim items.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "A list of persistent volume claims. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "A list of persistent volume claims. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
}
func (PersistentVolumeClaimList) SwaggerDoc() map[string]string {
@@ -974,8 +1010,9 @@ func (PersistentVolumeClaimList) SwaggerDoc() map[string]string {
var map_PersistentVolumeClaimSpec = map[string]string{
"": "PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes",
- "accessModes": "AccessModes contains the desired access modes the volume should have. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes-1",
- "resources": "Resources represents the minimum resources the volume should have. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#resources",
+ "accessModes": "AccessModes contains the desired access modes the volume should have. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1",
+ "selector": "A label query over volumes to consider for binding.",
+ "resources": "Resources represents the minimum resources the volume should have. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#resources",
"volumeName": "VolumeName is the binding reference to the PersistentVolume backing this claim.",
}
@@ -986,7 +1023,7 @@ func (PersistentVolumeClaimSpec) SwaggerDoc() map[string]string {
var map_PersistentVolumeClaimStatus = map[string]string{
"": "PersistentVolumeClaimStatus is the current status of a persistent volume claim.",
"phase": "Phase represents the current phase of PersistentVolumeClaim.",
- "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes-1",
+ "accessModes": "AccessModes contains the actual access modes the volume backing the PVC has. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes-1",
"capacity": "Represents the actual resources of the underlying volume.",
}
@@ -996,7 +1033,7 @@ func (PersistentVolumeClaimStatus) SwaggerDoc() map[string]string {
var map_PersistentVolumeClaimVolumeSource = map[string]string{
"": "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": "ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
+ "claimName": "ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
"readOnly": "Will force the ReadOnly setting in VolumeMounts. Default false.",
}
@@ -1006,8 +1043,8 @@ func (PersistentVolumeClaimVolumeSource) SwaggerDoc() map[string]string {
var map_PersistentVolumeList = map[string]string{
"": "PersistentVolumeList is a list of PersistentVolume items.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "List of persistent volumes. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "List of persistent volumes. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md",
}
func (PersistentVolumeList) SwaggerDoc() map[string]string {
@@ -1016,19 +1053,20 @@ func (PersistentVolumeList) SwaggerDoc() map[string]string {
var map_PersistentVolumeSource = map[string]string{
"": "PersistentVolumeSource is similar to VolumeSource but meant for the administrator who creates PVs. Exactly one of its members must be set.",
- "gcePersistentDisk": "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
- "awsElasticBlockStore": "AWSElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore",
- "hostPath": "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath",
- "glusterfs": "Glusterfs represents a Glusterfs volume that is attached to a host and exposed to the pod. Provisioned by an admin. More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md",
- "nfs": "NFS represents an NFS mount on the host. Provisioned by an admin. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs",
- "rbd": "RBD represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md",
+ "gcePersistentDisk": "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
+ "awsElasticBlockStore": "AWSElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore",
+ "hostPath": "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath",
+ "glusterfs": "Glusterfs represents a Glusterfs volume that is attached to a host and exposed to the pod. Provisioned by an admin. More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md",
+ "nfs": "NFS represents an NFS mount on the host. Provisioned by an admin. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs",
+ "rbd": "RBD represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md",
"iscsi": "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.",
- "cinder": "Cinder represents a cinder volume attached and mounted on kubelets host machine More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md",
+ "cinder": "Cinder represents a cinder volume attached and mounted on kubelets host machine More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md",
"cephfs": "CephFS represents a Ceph FS mount on the host that shares a pod's lifetime",
"fc": "FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.",
"flocker": "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",
"flexVolume": "FlexVolume represents a generic volume resource that is provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.",
"azureFile": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.",
+ "vsphereVolume": "VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine",
}
func (PersistentVolumeSource) SwaggerDoc() map[string]string {
@@ -1037,10 +1075,10 @@ func (PersistentVolumeSource) SwaggerDoc() map[string]string {
var map_PersistentVolumeSpec = map[string]string{
"": "PersistentVolumeSpec is the specification of a persistent volume.",
- "capacity": "A description of the persistent volume's resources and capacity. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#capacity",
- "accessModes": "AccessModes contains all ways the volume can be mounted. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#access-modes",
- "claimRef": "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: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#binding",
- "persistentVolumeReclaimPolicy": "What happens to a persistent volume when released from its claim. Valid options are Retain (default) and Recycle. Recyling must be supported by the volume plugin underlying this persistent volume. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#recycling-policy",
+ "capacity": "A description of the persistent volume's resources and capacity. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#capacity",
+ "accessModes": "AccessModes contains all ways the volume can be mounted. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#access-modes",
+ "claimRef": "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: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#binding",
+ "persistentVolumeReclaimPolicy": "What happens to a persistent volume when released from its claim. Valid options are Retain (default) and Recycle. Recyling must be supported by the volume plugin underlying this persistent volume. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#recycling-policy",
}
func (PersistentVolumeSpec) SwaggerDoc() map[string]string {
@@ -1049,7 +1087,7 @@ func (PersistentVolumeSpec) SwaggerDoc() map[string]string {
var map_PersistentVolumeStatus = map[string]string{
"": "PersistentVolumeStatus is the current status of a persistent volume.",
- "phase": "Phase indicates if a volume is available, bound to a claim, or released by a claim. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#phase",
+ "phase": "Phase indicates if a volume is available, bound to a claim, or released by a claim. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#phase",
"message": "A human-readable message indicating details about why the volume is in this state.",
"reason": "Reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI.",
}
@@ -1060,15 +1098,46 @@ func (PersistentVolumeStatus) SwaggerDoc() map[string]string {
var map_Pod = map[string]string{
"": "Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Specification of the desired behavior of the pod. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Specification of the desired behavior of the pod. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Pod) SwaggerDoc() map[string]string {
return map_Pod
}
+var map_PodAffinity = map[string]string{
+ "": "Pod affinity is a group of inter pod affinity scheduling rules.",
+ "requiredDuringSchedulingIgnoredDuringExecution": "NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented. 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 will 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. RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:\"requiredDuringSchedulingRequiredDuringExecution,omitempty\"` 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.",
+ "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.",
+}
+
+func (PodAffinity) SwaggerDoc() map[string]string {
+ return map_PodAffinity
+}
+
+var map_PodAffinityTerm = map[string]string{
+ "": "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 <topologyKey> tches that of any node on which a pod of the set of pods is running",
+ "labelSelector": "A label query over a set of resources, in this case pods.",
+ "namespaces": "namespaces specifies which namespaces the labelSelector applies to (matches against); nil list means \"this pod's namespace,\" empty list means \"all namespaces\" The json tag here is not \"omitempty\" since we need to distinguish nil and empty. See https://golang.org/pkg/encoding/json/#Marshal for more details.",
+ "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. For PreferredDuringScheduling pod anti-affinity, empty topologyKey is interpreted as \"all topologies\" (\"all topologies\" here means all the topologyKeys indicated by scheduler command-line argument --failure-domains); for affinity and for RequiredDuringScheduling pod anti-affinity, empty topologyKey is not allowed.",
+}
+
+func (PodAffinityTerm) SwaggerDoc() map[string]string {
+ return map_PodAffinityTerm
+}
+
+var map_PodAntiAffinity = map[string]string{
+ "": "Pod anti affinity is a group of inter pod anti affinity scheduling rules.",
+ "requiredDuringSchedulingIgnoredDuringExecution": "NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented. 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 will 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. RequiredDuringSchedulingRequiredDuringExecution []PodAffinityTerm `json:\"requiredDuringSchedulingRequiredDuringExecution,omitempty\"` 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.",
+ "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.",
+}
+
+func (PodAntiAffinity) SwaggerDoc() map[string]string {
+ return map_PodAntiAffinity
+}
+
var map_PodAttachOptions = map[string]string{
"": "PodAttachOptions is the query options to a Pod's remote attach call.",
"stdin": "Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false.",
@@ -1084,8 +1153,8 @@ func (PodAttachOptions) SwaggerDoc() map[string]string {
var map_PodCondition = map[string]string{
"": "PodCondition contains details for the current condition of this pod.",
- "type": "Type is the type of the condition. Currently only Ready. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions",
- "status": "Status is the status of the condition. Can be True, False, Unknown. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions",
+ "type": "Type is the type of the condition. Currently only Ready. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions",
+ "status": "Status is the status of the condition. Can be True, False, Unknown. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions",
"lastProbeTime": "Last time we probed the condition.",
"lastTransitionTime": "Last time the condition transitioned from one status to another.",
"reason": "Unique, one-word, CamelCase reason for the condition's last transition.",
@@ -1112,8 +1181,8 @@ func (PodExecOptions) SwaggerDoc() map[string]string {
var map_PodList = map[string]string{
"": "PodList is a list of Pods.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "List of pods. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pods.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "List of pods. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pods.md",
}
func (PodList) SwaggerDoc() map[string]string {
@@ -1160,21 +1229,23 @@ func (PodSecurityContext) SwaggerDoc() map[string]string {
var map_PodSpec = map[string]string{
"": "PodSpec is a description of a pod.",
- "volumes": "List of volumes that can be mounted by containers belonging to the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md",
- "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. More info: http://releases.k8s.io/release-1.2/docs/user-guide/containers.md",
- "restartPolicy": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#restartpolicy",
+ "volumes": "List of volumes that can be mounted by containers belonging to the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md",
+ "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. More info: http://releases.k8s.io/release-1.3/docs/user-guide/containers.md",
+ "restartPolicy": "Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#restartpolicy",
"terminationGracePeriodSeconds": "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 delete immediately. 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.",
"activeDeadlineSeconds": "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.",
"dnsPolicy": "Set DNS policy for containers within the pod. One of 'ClusterFirst' or 'Default'. Defaults to \"ClusterFirst\".",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/node-selection/README.md",
- "serviceAccountName": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: http://releases.k8s.io/release-1.2/docs/design/service_accounts.md",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/node-selection/README.md",
+ "serviceAccountName": "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md",
"serviceAccount": "DeprecatedServiceAccount is a depreciated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead.",
"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.",
"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.",
"hostPID": "Use the host's pid namespace. Optional: Default to false.",
"hostIPC": "Use the host's ipc namespace. Optional: Default to false.",
"securityContext": "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field.",
- "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. For example, in the case of docker, only DockerConfig type secrets are honored. More info: http://releases.k8s.io/release-1.2/docs/user-guide/images.md#specifying-imagepullsecrets-on-a-pod",
+ "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. For example, in the case of docker, only DockerConfig type secrets are honored. More info: http://releases.k8s.io/release-1.3/docs/user-guide/images.md#specifying-imagepullsecrets-on-a-pod",
+ "hostname": "Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.",
+ "subdomain": "If specified, the fully qualified Pod hostname will be \"<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>\". If not specified, the pod will not have a domainname at all.",
}
func (PodSpec) SwaggerDoc() map[string]string {
@@ -1183,14 +1254,14 @@ func (PodSpec) SwaggerDoc() map[string]string {
var map_PodStatus = map[string]string{
"": "PodStatus represents information about the status of a pod. Status may trail the actual state of a system.",
- "phase": "Current condition of the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-phase",
- "conditions": "Current service state of pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#pod-conditions",
+ "phase": "Current condition of the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-phase",
+ "conditions": "Current service state of pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#pod-conditions",
"message": "A human readable message indicating details about why the pod is in this condition.",
"reason": "A brief CamelCase message indicating details about why the pod is in this state. e.g. 'OutOfDisk'",
"hostIP": "IP address of the host to which the pod is assigned. Empty if not yet scheduled.",
"podIP": "IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.",
"startTime": "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.",
- "containerStatuses": "The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-statuses",
+ "containerStatuses": "The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-statuses",
}
func (PodStatus) SwaggerDoc() map[string]string {
@@ -1199,8 +1270,8 @@ func (PodStatus) SwaggerDoc() map[string]string {
var map_PodStatusResult = map[string]string{
"": "PodStatusResult is a wrapper for PodStatus returned by kubelet that can be encode/decoded",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "status": "Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "status": "Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (PodStatusResult) SwaggerDoc() map[string]string {
@@ -1209,8 +1280,8 @@ func (PodStatusResult) SwaggerDoc() map[string]string {
var map_PodTemplate = map[string]string{
"": "PodTemplate describes a template for creating copies of a predefined pod.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "template": "Template defines the pods that will be created from this pod template. http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "template": "Template defines the pods that will be created from this pod template. http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (PodTemplate) SwaggerDoc() map[string]string {
@@ -1219,7 +1290,7 @@ func (PodTemplate) SwaggerDoc() map[string]string {
var map_PodTemplateList = map[string]string{
"": "PodTemplateList is a list of PodTemplates.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of pod templates",
}
@@ -1229,14 +1300,23 @@ func (PodTemplateList) SwaggerDoc() map[string]string {
var map_PodTemplateSpec = map[string]string{
"": "PodTemplateSpec describes the data a pod should have when created from a template",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Specification of the desired behavior of the pod. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Specification of the desired behavior of the pod. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (PodTemplateSpec) SwaggerDoc() map[string]string {
return map_PodTemplateSpec
}
+var map_Preconditions = map[string]string{
+ "": "Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.",
+ "uid": "Specifies the target UID.",
+}
+
+func (Preconditions) SwaggerDoc() map[string]string {
+ return map_Preconditions
+}
+
var map_PreferredSchedulingTerm = map[string]string{
"": "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": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.",
@@ -1249,8 +1329,8 @@ func (PreferredSchedulingTerm) SwaggerDoc() map[string]string {
var map_Probe = map[string]string{
"": "Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.",
- "initialDelaySeconds": "Number of seconds after the container has started before liveness probes are initiated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes",
- "timeoutSeconds": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: http://releases.k8s.io/release-1.2/docs/user-guide/pod-states.md#container-probes",
+ "initialDelaySeconds": "Number of seconds after the container has started before liveness probes are initiated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes",
+ "timeoutSeconds": "Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: http://releases.k8s.io/release-1.3/docs/user-guide/pod-states.md#container-probes",
"periodSeconds": "How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.",
"successThreshold": "Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness. Minimum value is 1.",
"failureThreshold": "Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.",
@@ -1262,14 +1342,14 @@ func (Probe) SwaggerDoc() map[string]string {
var map_RBDVolumeSource = map[string]string{
"": "Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.",
- "monitors": "A collection of Ceph monitors. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
- "image": "The rados image name. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#rbd",
- "pool": "The rados pool name. Default is rbd. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it.",
- "user": "The rados user name. Default is admin. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
- "keyring": "Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
- "secretRef": "SecretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is empty. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
- "readOnly": "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md#how-to-use-it",
+ "monitors": "A collection of Ceph monitors. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
+ "image": "The rados image name. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#rbd",
+ "pool": "The rados pool name. Default is rbd. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it.",
+ "user": "The rados user name. Default is admin. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
+ "keyring": "Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
+ "secretRef": "SecretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
+ "readOnly": "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md#how-to-use-it",
}
func (RBDVolumeSource) SwaggerDoc() map[string]string {
@@ -1278,7 +1358,7 @@ func (RBDVolumeSource) SwaggerDoc() map[string]string {
var map_RangeAllocation = map[string]string{
"": "RangeAllocation is not a public type.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"range": "Range is string that identifies the range represented by 'data'.",
"data": "Data is a bit array containing all allocated addresses in the previous segment.",
}
@@ -1289,9 +1369,9 @@ func (RangeAllocation) SwaggerDoc() map[string]string {
var map_ReplicationController = map[string]string{
"": "ReplicationController represents the configuration of a replication controller.",
- "metadata": "If the Labels of a ReplicationController are empty, they are defaulted to be the same as the Pod(s) that the replication controller manages. Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the specification of the desired behavior of the replication controller. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status is the most recently observed status of the replication controller. This data may be out of date by some window of time. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "If the Labels of a ReplicationController are empty, they are defaulted to be the same as the Pod(s) that the replication controller manages. Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the specification of the desired behavior of the replication controller. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is the most recently observed status of the replication controller. This data may be out of date by some window of time. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (ReplicationController) SwaggerDoc() map[string]string {
@@ -1300,8 +1380,8 @@ func (ReplicationController) SwaggerDoc() map[string]string {
var map_ReplicationControllerList = map[string]string{
"": "ReplicationControllerList is a collection of replication controllers.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "List of replication controllers. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "List of replication controllers. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md",
}
func (ReplicationControllerList) SwaggerDoc() map[string]string {
@@ -1310,9 +1390,9 @@ func (ReplicationControllerList) SwaggerDoc() map[string]string {
var map_ReplicationControllerSpec = map[string]string{
"": "ReplicationControllerSpec is the specification of a replication controller.",
- "replicas": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "template": "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: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template",
+ "replicas": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "template": "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: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template",
}
func (ReplicationControllerSpec) SwaggerDoc() map[string]string {
@@ -1321,7 +1401,7 @@ func (ReplicationControllerSpec) SwaggerDoc() map[string]string {
var map_ReplicationControllerStatus = map[string]string{
"": "ReplicationControllerStatus represents the current status of a replication controller.",
- "replicas": "Replicas is the most recently oberved number of replicas. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
+ "replicas": "Replicas is the most recently oberved number of replicas. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
"fullyLabeledReplicas": "The number of pods that have labels matching the labels of the pod template of the replication controller.",
"observedGeneration": "ObservedGeneration reflects the generation of the most recently observed replication controller.",
}
@@ -1330,11 +1410,22 @@ func (ReplicationControllerStatus) SwaggerDoc() map[string]string {
return map_ReplicationControllerStatus
}
+var map_ResourceFieldSelector = map[string]string{
+ "": "ResourceFieldSelector represents container resources (cpu, memory) and their output format",
+ "containerName": "Container name: required for volumes, optional for env vars",
+ "resource": "Required: resource to select",
+ "divisor": "Specifies the output format of the exposed resources, defaults to \"1\"",
+}
+
+func (ResourceFieldSelector) SwaggerDoc() map[string]string {
+ return map_ResourceFieldSelector
+}
+
var map_ResourceQuota = map[string]string{
"": "ResourceQuota sets aggregate quota restrictions enforced per namespace",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the desired quota. http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status defines the actual enforced quota and its current usage. http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the desired quota. http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status defines the actual enforced quota and its current usage. http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (ResourceQuota) SwaggerDoc() map[string]string {
@@ -1343,8 +1434,8 @@ func (ResourceQuota) SwaggerDoc() map[string]string {
var map_ResourceQuotaList = map[string]string{
"": "ResourceQuotaList is a list of ResourceQuota items.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "Items is a list of ResourceQuota objects. More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "Items is a list of ResourceQuota objects. More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
}
func (ResourceQuotaList) SwaggerDoc() map[string]string {
@@ -1353,7 +1444,7 @@ func (ResourceQuotaList) SwaggerDoc() map[string]string {
var map_ResourceQuotaSpec = map[string]string{
"": "ResourceQuotaSpec defines the desired hard limits to enforce for Quota.",
- "hard": "Hard is the set of desired hard limits for each named resource. More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
+ "hard": "Hard is the set of desired hard limits for each named resource. More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
"scopes": "A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.",
}
@@ -1363,7 +1454,7 @@ func (ResourceQuotaSpec) SwaggerDoc() map[string]string {
var map_ResourceQuotaStatus = map[string]string{
"": "ResourceQuotaStatus defines the enforced hard limits and observed use.",
- "hard": "Hard is the set of enforced hard limits for each named resource. More info: http://releases.k8s.io/release-1.2/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
+ "hard": "Hard is the set of enforced hard limits for each named resource. More info: http://releases.k8s.io/release-1.3/docs/design/admission_control_resource_quota.md#admissioncontrol-plugin-resourcequota",
"used": "Used is the current observed total usage of the resource in the namespace.",
}
@@ -1373,8 +1464,8 @@ func (ResourceQuotaStatus) SwaggerDoc() map[string]string {
var map_ResourceRequirements = map[string]string{
"": "ResourceRequirements describes the compute resource requirements.",
- "limits": "Limits describes the maximum amount of compute resources allowed. More info: http://releases.k8s.io/release-1.2/docs/design/resources.md#resource-specifications",
- "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: http://releases.k8s.io/release-1.2/docs/design/resources.md#resource-specifications",
+ "limits": "Limits describes the maximum amount of compute resources allowed. More info: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications",
+ "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: http://releases.k8s.io/release-1.3/docs/design/resources.md#resource-specifications",
}
func (ResourceRequirements) SwaggerDoc() map[string]string {
@@ -1395,7 +1486,7 @@ func (SELinuxOptions) SwaggerDoc() map[string]string {
var map_Secret = map[string]string{
"": "Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"data": "Data contains the secret data. Each key must be a valid DNS_SUBDOMAIN or leading dot followed by valid DNS_SUBDOMAIN. 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",
"type": "Used to facilitate programmatic handling of secret data.",
}
@@ -1415,8 +1506,8 @@ func (SecretKeySelector) SwaggerDoc() map[string]string {
var map_SecretList = map[string]string{
"": "SecretList is a list of Secret.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "Items is a list of secret objects. More info: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "Items is a list of secret objects. More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md",
}
func (SecretList) SwaggerDoc() map[string]string {
@@ -1425,7 +1516,8 @@ func (SecretList) SwaggerDoc() map[string]string {
var map_SecretVolumeSource = map[string]string{
"": "Adapts a Secret into a volume.\n\nThe 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.",
- "secretName": "Name of the secret in the pod's namespace to use. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#secrets",
+ "secretName": "Name of the secret in the pod's namespace to use. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets",
+ "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. Paths must be relative and may not contain the '..' path or start with '..'.",
}
func (SecretVolumeSource) SwaggerDoc() map[string]string {
@@ -1457,9 +1549,9 @@ func (SerializedReference) SwaggerDoc() map[string]string {
var map_Service = map[string]string{
"": "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.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the behavior of a service. http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Most recently observed status of the service. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the behavior of a service. http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Most recently observed status of the service. Populated by the system. Read-only. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Service) SwaggerDoc() map[string]string {
@@ -1468,9 +1560,9 @@ func (Service) SwaggerDoc() map[string]string {
var map_ServiceAccount = map[string]string{
"": "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",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "secrets": "Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount. More info: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/secrets.md#manually-specifying-an-imagepullsecret",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "secrets": "Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount. More info: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/secrets.md#manually-specifying-an-imagepullsecret",
}
func (ServiceAccount) SwaggerDoc() map[string]string {
@@ -1479,8 +1571,8 @@ func (ServiceAccount) SwaggerDoc() map[string]string {
var map_ServiceAccountList = map[string]string{
"": "ServiceAccountList is a list of ServiceAccount objects",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "List of ServiceAccounts. More info: http://releases.k8s.io/release-1.2/docs/design/service_accounts.md#service-accounts",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "List of ServiceAccounts. More info: http://releases.k8s.io/release-1.3/docs/design/service_accounts.md#service-accounts",
}
func (ServiceAccountList) SwaggerDoc() map[string]string {
@@ -1489,7 +1581,7 @@ func (ServiceAccountList) SwaggerDoc() map[string]string {
var map_ServiceList = map[string]string{
"": "ServiceList holds a list of services.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
"items": "List of services",
}
@@ -1502,8 +1594,8 @@ var map_ServicePort = map[string]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. This maps to the 'Name' field in EndpointPort objects. Optional if only one ServicePort is defined on this service.",
"protocol": "The IP protocol for this port. Supports \"TCP\" and \"UDP\". Default is TCP.",
"port": "The port that will be exposed by this service.",
- "targetPort": "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: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#defining-a-service",
- "nodePort": "The port on each node on which this service is exposed when type=NodePort or LoadBalancer. Usually assigned by the system. If specified, it will be allocated to the service if unused or else creation of the service will fail. Default is to auto-allocate a port if the ServiceType of this Service requires one. More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#type--nodeport",
+ "targetPort": "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: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#defining-a-service",
+ "nodePort": "The port on each node on which this service is exposed when type=NodePort or LoadBalancer. Usually assigned by the system. If specified, it will be allocated to the service if unused or else creation of the service will fail. Default is to auto-allocate a port if the ServiceType of this Service requires one. More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#type--nodeport",
}
func (ServicePort) SwaggerDoc() map[string]string {
@@ -1520,15 +1612,16 @@ func (ServiceProxyOptions) SwaggerDoc() map[string]string {
}
var map_ServiceSpec = map[string]string{
- "": "ServiceSpec describes the attributes that a user creates on a service.",
- "ports": "The list of ports that are exposed by this service. More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies",
- "selector": "This service will route traffic to pods having labels matching this selector. Label keys and values that must match in order to receive traffic for this service. If empty, all pods are selected, if not specified, endpoints must be manually specified. More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#overview",
- "clusterIP": "ClusterIP is usually assigned by the master and is the IP address of the service. If specified, it will be allocated to the service if it is unused or else creation of the service will fail. Valid values are None, empty string (\"\"), or a valid IP address. 'None' can be specified for a headless service when proxying is not required. Cannot be updated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies",
- "type": "Type of exposed service. Must be ClusterIP, NodePort, or LoadBalancer. Defaults to ClusterIP. More info: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#external-services",
- "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. A previous form of this functionality exists as the deprecatedPublicIPs field. When using this field, callers should also clear the deprecatedPublicIPs field.",
- "deprecatedPublicIPs": "deprecatedPublicIPs is deprecated and replaced by the externalIPs field with almost the exact same semantics. This field is retained in the v1 API for compatibility until at least 8/20/2016. It will be removed from any new API revisions. If both deprecatedPublicIPs *and* externalIPs are set, deprecatedPublicIPs is used.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/services.md#virtual-ips-and-service-proxies",
- "loadBalancerIP": "Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. 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.",
+ "": "ServiceSpec describes the attributes that a user creates on a service.",
+ "ports": "The list of ports that are exposed by this service. More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies",
+ "selector": "This service will route traffic to pods having labels matching this selector. Label keys and values that must match in order to receive traffic for this service. If empty, all pods are selected, if not specified, endpoints must be manually specified. More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#overview",
+ "clusterIP": "ClusterIP is usually assigned by the master and is the IP address of the service. If specified, it will be allocated to the service if it is unused or else creation of the service will fail. Valid values are None, empty string (\"\"), or a valid IP address. 'None' can be specified for a headless service when proxying is not required. Cannot be updated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies",
+ "type": "Type of exposed service. Must be ClusterIP, NodePort, or LoadBalancer. Defaults to ClusterIP. More info: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#external-services",
+ "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. A previous form of this functionality exists as the deprecatedPublicIPs field. When using this field, callers should also clear the deprecatedPublicIPs field.",
+ "deprecatedPublicIPs": "deprecatedPublicIPs is deprecated and replaced by the externalIPs field with almost the exact same semantics. This field is retained in the v1 API for compatibility until at least 8/20/2016. It will be removed from any new API revisions. If both deprecatedPublicIPs *and* externalIPs are set, deprecatedPublicIPs is used.",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/services.md#virtual-ips-and-service-proxies",
+ "loadBalancerIP": "Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. 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.",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/services-firewalls.md",
}
func (ServiceSpec) SwaggerDoc() map[string]string {
@@ -1553,9 +1646,32 @@ func (TCPSocketAction) SwaggerDoc() map[string]string {
return map_TCPSocketAction
}
+var map_Taint = map[string]string{
+ "": "The node this Taint is attached to has the effect \"effect\" on any pod that that does not tolerate the Taint.",
+ "key": "Required. The taint key to be applied to a node.",
+ "value": "Required. The taint value corresponding to the taint key.",
+ "effect": "Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule and PreferNoSchedule.",
+}
+
+func (Taint) SwaggerDoc() map[string]string {
+ return map_Taint
+}
+
+var map_Toleration = map[string]string{
+ "": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
+ "key": "Required. Key is the taint key that the toleration applies to.",
+ "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.",
+ "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.",
+ "effect": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and PreferNoSchedule.",
+}
+
+func (Toleration) SwaggerDoc() map[string]string {
+ return map_Toleration
+}
+
var map_Volume = map[string]string{
"": "Volume represents a named volume in a pod that may be accessed by any container in the pod.",
- "name": "Volume's name. Must be a DNS_LABEL and unique within the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
+ "name": "Volume's name. Must be a DNS_LABEL and unique within the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
}
func (Volume) SwaggerDoc() map[string]string {
@@ -1567,6 +1683,7 @@ var map_VolumeMount = map[string]string{
"name": "This must match the Name of a Volume.",
"readOnly": "Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.",
"mountPath": "Path within the container at which the volume should be mounted. Must not contain ':'.",
+ "subPath": "Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).",
}
func (VolumeMount) SwaggerDoc() map[string]string {
@@ -1575,29 +1692,50 @@ func (VolumeMount) SwaggerDoc() map[string]string {
var map_VolumeSource = map[string]string{
"": "Represents the source of a volume to mount. Only one of its members may be specified.",
- "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: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#hostpath",
- "emptyDir": "EmptyDir represents a temporary directory that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#emptydir",
- "gcePersistentDisk": "GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#gcepersistentdisk",
- "awsElasticBlockStore": "AWSElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#awselasticblockstore",
+ "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: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#hostpath",
+ "emptyDir": "EmptyDir represents a temporary directory that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#emptydir",
+ "gcePersistentDisk": "GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#gcepersistentdisk",
+ "awsElasticBlockStore": "AWSElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#awselasticblockstore",
"gitRepo": "GitRepo represents a git repository at a particular revision.",
- "secret": "Secret represents a secret that should populate this volume. More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#secrets",
- "nfs": "NFS represents an NFS mount on the host that shares a pod's lifetime More info: http://releases.k8s.io/release-1.2/docs/user-guide/volumes.md#nfs",
- "iscsi": "ISCSI represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.2/examples/iscsi/README.md",
- "glusterfs": "Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.2/examples/glusterfs/README.md",
- "persistentVolumeClaim": "PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: http://releases.k8s.io/release-1.2/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
- "rbd": "RBD represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.2/examples/rbd/README.md",
- "flexVolume": "FlexVolume represents a generic volume resource that is provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.",
- "cinder": "Cinder represents a cinder volume attached and mounted on kubelets host machine More info: http://releases.k8s.io/release-1.2/examples/mysql-cinder-pd/README.md",
- "cephfs": "CephFS represents a Ceph FS mount on the host that shares a pod's lifetime",
- "flocker": "Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running",
- "downwardAPI": "DownwardAPI represents downward API about the pod that should populate this volume",
- "fc": "FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.",
- "azureFile": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.",
- "configMap": "ConfigMap represents a configMap that should populate this volume",
+ "secret": "Secret represents a secret that should populate this volume. More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#secrets",
+ "nfs": "NFS represents an NFS mount on the host that shares a pod's lifetime More info: http://releases.k8s.io/release-1.3/docs/user-guide/volumes.md#nfs",
+ "iscsi": "ISCSI represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: http://releases.k8s.io/release-1.3/examples/iscsi/README.md",
+ "glusterfs": "Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.3/examples/glusterfs/README.md",
+ "persistentVolumeClaim": "PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: http://releases.k8s.io/release-1.3/docs/user-guide/persistent-volumes.md#persistentvolumeclaims",
+ "rbd": "RBD represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: http://releases.k8s.io/release-1.3/examples/rbd/README.md",
+ "flexVolume": "FlexVolume represents a generic volume resource that is provisioned/attached using a exec based plugin. This is an alpha feature and may change in future.",
+ "cinder": "Cinder represents a cinder volume attached and mounted on kubelets host machine More info: http://releases.k8s.io/release-1.3/examples/mysql-cinder-pd/README.md",
+ "cephfs": "CephFS represents a Ceph FS mount on the host that shares a pod's lifetime",
+ "flocker": "Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running",
+ "downwardAPI": "DownwardAPI represents downward API about the pod that should populate this volume",
+ "fc": "FC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.",
+ "azureFile": "AzureFile represents an Azure File Service mount on the host and bind mount to the pod.",
+ "configMap": "ConfigMap represents a configMap that should populate this volume",
+ "vsphereVolume": "VsphereVolume represents a vSphere volume attached and mounted on kubelets host machine",
}
func (VolumeSource) SwaggerDoc() map[string]string {
return map_VolumeSource
}
+var map_VsphereVirtualDiskVolumeSource = map[string]string{
+ "": "Represents a vSphere volume resource.",
+ "volumePath": "Path that identifies vSphere volume vmdk",
+ "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.",
+}
+
+func (VsphereVirtualDiskVolumeSource) SwaggerDoc() map[string]string {
+ return map_VsphereVirtualDiskVolumeSource
+}
+
+var map_WeightedPodAffinityTerm = map[string]string{
+ "": "The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)",
+ "weight": "weight associated with matching the corresponding podAffinityTerm, in the range 1-100.",
+ "podAffinityTerm": "Required. A pod affinity term, associated with the corresponding weight.",
+}
+
+func (WeightedPodAffinityTerm) SwaggerDoc() map[string]string {
+ return map_WeightedPodAffinityTerm
+}
+
// AUTO-GENERATED FUNCTIONS END HERE
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/doc.go b/vendor/k8s.io/kubernetes/pkg/api/validation/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/doc.go
rename to vendor/k8s.io/kubernetes/pkg/api/validation/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/events.go b/vendor/k8s.io/kubernetes/pkg/api/validation/events.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/events.go
rename to vendor/k8s.io/kubernetes/pkg/api/validation/events.go
index d1a89c45c6f09aebfd79f1f06ec49c123f0104e2..0a5de5443bb3ee216b1e21d6b19aaa82ee4b7df1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/events.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/validation/events.go
@@ -25,20 +25,21 @@ import (
// ValidateEvent makes sure that the event makes sense.
func ValidateEvent(event *api.Event) field.ErrorList {
allErrs := field.ErrorList{}
- // There is no namespace required for node.
+ // There is no namespace required for node or persistent volume.
// However, older client code accidentally sets event.Namespace
// to api.NamespaceDefault, so we accept that too, but "" is preferred.
- if event.InvolvedObject.Kind == "Node" &&
+ if (event.InvolvedObject.Kind == "Node" || event.InvolvedObject.Kind == "PersistentVolume") &&
event.Namespace != api.NamespaceDefault &&
event.Namespace != "" {
allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "not allowed for node"))
}
if event.InvolvedObject.Kind != "Node" &&
+ event.InvolvedObject.Kind != "PersistentVolume" &&
event.Namespace != event.InvolvedObject.Namespace {
allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match involvedObject"))
}
- if !validation.IsDNS1123Subdomain(event.Namespace) {
- allErrs = append(allErrs, field.Invalid(field.NewPath("namespace"), event.Namespace, ""))
+ for _, msg := range validation.IsDNS1123Subdomain(event.Namespace) {
+ allErrs = append(allErrs, field.Invalid(field.NewPath("namespace"), event.Namespace, msg))
}
return allErrs
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/name.go b/vendor/k8s.io/kubernetes/pkg/api/validation/name.go
similarity index 80%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/name.go
rename to vendor/k8s.io/kubernetes/pkg/api/validation/name.go
index e36775b601d55a86d2831f225b136e8d362c8cbf..cf2eb8bb2990a5ff0a54606729c5bb536c89e79d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/name.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/validation/name.go
@@ -28,36 +28,36 @@ var NameMayNotBe = []string{".", ".."}
var NameMayNotContain = []string{"/", "%"}
// IsValidPathSegmentName validates the name can be safely encoded as a path segment
-func IsValidPathSegmentName(name string) (bool, string) {
+func IsValidPathSegmentName(name string) []string {
for _, illegalName := range NameMayNotBe {
if name == illegalName {
- return false, fmt.Sprintf(`name may not be %q`, illegalName)
+ return []string{fmt.Sprintf(`may not be '%s'`, illegalName)}
}
}
for _, illegalContent := range NameMayNotContain {
if strings.Contains(name, illegalContent) {
- return false, fmt.Sprintf(`name may not contain %q`, illegalContent)
+ return []string{fmt.Sprintf(`may not contain '%s'`, illegalContent)}
}
}
- return true, ""
+ return nil
}
// IsValidPathSegmentPrefix validates the name can be used as a prefix for a name which will be encoded as a path segment
// It does not check for exact matches with disallowed names, since an arbitrary suffix might make the name valid
-func IsValidPathSegmentPrefix(name string) (bool, string) {
+func IsValidPathSegmentPrefix(name string) []string {
for _, illegalContent := range NameMayNotContain {
if strings.Contains(name, illegalContent) {
- return false, fmt.Sprintf(`name may not contain %q`, illegalContent)
+ return []string{fmt.Sprintf(`may not contain '%s'`, illegalContent)}
}
}
- return true, ""
+ return nil
}
// ValidatePathSegmentName validates the name can be safely encoded as a path segment
-func ValidatePathSegmentName(name string, prefix bool) (bool, string) {
+func ValidatePathSegmentName(name string, prefix bool) []string {
if prefix {
return IsValidPathSegmentPrefix(name)
} else {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/schema.go b/vendor/k8s.io/kubernetes/pkg/api/validation/schema.go
similarity index 73%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/schema.go
rename to vendor/k8s.io/kubernetes/pkg/api/validation/schema.go
index 713b96ac6536d979c31de3ceed31adf47d4e7434..345666c970b2be996dd010e46b7b70e2d6338549 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/schema.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/validation/schema.go
@@ -26,6 +26,7 @@ import (
"github.com/emicklei/go-restful/swagger"
"github.com/golang/glog"
apiutil "k8s.io/kubernetes/pkg/api/util"
+ "k8s.io/kubernetes/pkg/runtime"
utilerrors "k8s.io/kubernetes/pkg/util/errors"
"k8s.io/kubernetes/pkg/util/yaml"
)
@@ -62,15 +63,17 @@ type NullSchema struct{}
func (NullSchema) ValidateBytes(data []byte) error { return nil }
type SwaggerSchema struct {
- api swagger.ApiDeclaration
+ api swagger.ApiDeclaration
+ delegate Schema // For delegating to other api groups
}
-func NewSwaggerSchemaFromBytes(data []byte) (Schema, error) {
+func NewSwaggerSchemaFromBytes(data []byte, factory Schema) (Schema, error) {
schema := &SwaggerSchema{}
err := json.Unmarshal(data, &schema.api)
if err != nil {
return nil, err
}
+ schema.delegate = factory
return schema, nil
}
@@ -78,11 +81,15 @@ func NewSwaggerSchemaFromBytes(data []byte) (Schema, error) {
// It return nil if every item is ok.
// Otherwise it return an error list contain errors of every item.
func (s *SwaggerSchema) validateList(obj map[string]interface{}) []error {
- allErrs := []error{}
items, exists := obj["items"]
if !exists {
- return append(allErrs, fmt.Errorf("no items field in %#v", obj))
+ return []error{fmt.Errorf("no items field in %#v", obj)}
}
+ return s.validateItems(items)
+}
+
+func (s *SwaggerSchema) validateItems(items interface{}) []error {
+ allErrs := []error{}
itemList, ok := items.([]interface{})
if !ok {
return append(allErrs, fmt.Errorf("items isn't a slice"))
@@ -125,6 +132,7 @@ func (s *SwaggerSchema) validateList(obj map[string]interface{}) []error {
allErrs = append(allErrs, errs...)
}
}
+
return allErrs
}
@@ -171,6 +179,25 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName stri
allErrs := []error{}
models := s.api.Models
model, ok := models.At(typeName)
+
+ // Verify the api version matches. This is required for nested types with differing api versions because
+ // s.api only has schema for 1 api version (the parent object type's version).
+ // e.g. an extensions/v1beta1 Template embedding a /v1 Service requires the schema for the extensions/v1beta1
+ // api to delegate to the schema for the /v1 api.
+ // Only do this for !ok objects so that cross ApiVersion vendored types take precedence.
+ if !ok && s.delegate != nil {
+ fields, mapOk := obj.(map[string]interface{})
+ if !mapOk {
+ return append(allErrs, fmt.Errorf("field %s: expected object of type map[string]interface{}, but the actual type is %T", fieldName, obj))
+ }
+ if delegated, err := s.delegateIfDifferentApiVersion(runtime.Unstructured{Object: fields}); delegated {
+ if err != nil {
+ allErrs = append(allErrs, err)
+ }
+ return allErrs
+ }
+ }
+
if !ok {
return append(allErrs, TypeNotFoundError(typeName))
}
@@ -194,6 +221,17 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName stri
}
for key, value := range fields {
details, ok := properties.At(key)
+
+ // Special case for runtime.RawExtension and runtime.Objects because they always fail to validate
+ // This is because the actual values will be of some sub-type (e.g. Deployment) not the expected
+ // super-type (RawExtension)
+ if s.isGenericArray(details) {
+ errs := s.validateItems(value)
+ if len(errs) > 0 {
+ allErrs = append(allErrs, errs...)
+ }
+ continue
+ }
if !ok {
allErrs = append(allErrs, fmt.Errorf("found invalid field %s for %s", key, typeName))
continue
@@ -219,8 +257,44 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName stri
return allErrs
}
+// delegateIfDifferentApiVersion delegates the validation of an object if its ApiGroup does not match the
+// current SwaggerSchema.
+// First return value is true if the validation was delegated (by a different ApiGroup SwaggerSchema)
+// Second return value is the result of the delegated validation if performed.
+func (s *SwaggerSchema) delegateIfDifferentApiVersion(obj runtime.Unstructured) (bool, error) {
+ // Never delegate objects in the same ApiVersion or we will get infinite recursion
+ if !s.isDifferentApiVersion(obj) {
+ return false, nil
+ }
+
+ // Convert the object back into bytes so that we can pass it to the ValidateBytes function
+ m, err := json.Marshal(obj.Object)
+ if err != nil {
+ return true, err
+ }
+
+ // Delegate validation of this object to the correct SwaggerSchema for its ApiGroup
+ return true, s.delegate.ValidateBytes(m)
+}
+
+// isDifferentApiVersion Returns true if obj lives in a different ApiVersion than the SwaggerSchema does.
+// The SwaggerSchema will not be able to process objects in different ApiVersions unless they are vendored.
+func (s *SwaggerSchema) isDifferentApiVersion(obj runtime.Unstructured) bool {
+ groupVersion := obj.GetAPIVersion()
+ return len(groupVersion) > 0 && s.api.ApiVersion != groupVersion
+}
+
+// isGenericArray Returns true if p is an array of generic Objects - either RawExtension or Object.
+func (s *SwaggerSchema) isGenericArray(p swagger.ModelProperty) bool {
+ return p.DataTypeFields.Type != nil &&
+ *p.DataTypeFields.Type == "array" &&
+ p.Items != nil &&
+ p.Items.Ref != nil &&
+ (*p.Items.Ref == "runtime.RawExtension" || *p.Items.Ref == "runtime.Object")
+}
+
// This matches type name in the swagger spec, such as "v1.Binding".
-var versionRegexp = regexp.MustCompile(`^v.+\..*`)
+var versionRegexp = regexp.MustCompile(`^(v.+|unversioned)\..*`)
func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType string, fieldDetails *swagger.ModelProperty) []error {
// TODO: caesarxuchao: because we have multiple group/versions and objects
@@ -284,8 +358,8 @@ func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType st
}
// API servers before release 1.3 produce swagger spec with `type: "any"` as the fallback type, while newer servers produce spec with `type: "object"`.
// We have both here so that kubectl can work with both old and new api servers.
- case "any":
case "object":
+ case "any":
default:
return append(allErrs, fmt.Errorf("unexpected type: %v", fieldType))
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/validation.go b/vendor/k8s.io/kubernetes/pkg/api/validation/validation.go
similarity index 80%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/validation.go
rename to vendor/k8s.io/kubernetes/pkg/api/validation/validation.go
index 88be16a175e9967332de2d83f73cad20dc1ea8a0..5a12e79bfc800ec047b6765ee23ae9f8dd0e5f83 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/validation/validation.go
+++ b/vendor/k8s.io/kubernetes/pkg/api/validation/validation.go
@@ -33,6 +33,9 @@ import (
utilpod "k8s.io/kubernetes/pkg/api/pod"
"k8s.io/kubernetes/pkg/api/resource"
apiservice "k8s.io/kubernetes/pkg/api/service"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ unversionedvalidation "k8s.io/kubernetes/pkg/api/unversioned/validation"
+ "k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/capabilities"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/util/intstr"
@@ -55,11 +58,6 @@ func InclusiveRangeErrorMsg(lo, hi int) string {
return fmt.Sprintf(`must be between %d and %d, inclusive`, lo, hi)
}
-var labelValueErrorMsg string = fmt.Sprintf(`must have at most %d characters, matching regex %s: e.g. "MyValue" or ""`, validation.LabelValueMaxLength, validation.LabelValueFmt)
-var qualifiedNameErrorMsg string = fmt.Sprintf(`must be a qualified name (at most %d characters, matching regex %s), with an optional DNS subdomain prefix (at most %d characters, matching regex %s) and slash (/): e.g. "MyName" or "example.com/MyName"`, validation.QualifiedNameMaxLength, validation.QualifiedNameFmt, validation.DNS1123SubdomainMaxLength, validation.DNS1123SubdomainFmt)
-var DNSSubdomainErrorMsg string = fmt.Sprintf(`must be a DNS subdomain (at most %d characters, matching regex %s): e.g. "example.com"`, validation.DNS1123SubdomainMaxLength, validation.DNS1123SubdomainFmt)
-var DNS1123LabelErrorMsg string = fmt.Sprintf(`must be a DNS label (at most %d characters, matching regex %s): e.g. "my-name"`, validation.DNS1123LabelMaxLength, validation.DNS1123LabelFmt)
-var DNS952LabelErrorMsg string = fmt.Sprintf(`must be a DNS 952 label (at most %d characters, matching regex %s): e.g. "my-name"`, validation.DNS952LabelMaxLength, validation.DNS952LabelFmt)
var pdPartitionErrorMsg string = InclusiveRangeErrorMsg(1, 255)
var PortRangeErrorMsg string = InclusiveRangeErrorMsg(1, 65535)
var IdRangeErrorMsg string = InclusiveRangeErrorMsg(0, math.MaxInt32)
@@ -67,24 +65,9 @@ var PortNameErrorMsg string = fmt.Sprintf(`must be an IANA_SVC_NAME (at most 15
const totalAnnotationSizeLimitB int = 256 * (1 << 10) // 256 kB
-func ValidateLabelName(labelName string, fldPath *field.Path) field.ErrorList {
- allErrs := field.ErrorList{}
- if !validation.IsQualifiedName(labelName) {
- allErrs = append(allErrs, field.Invalid(fldPath, labelName, qualifiedNameErrorMsg))
- }
- return allErrs
-}
-
-// ValidateLabels validates that a set of labels are correctly defined.
-func ValidateLabels(labels map[string]string, fldPath *field.Path) field.ErrorList {
- allErrs := field.ErrorList{}
- for k, v := range labels {
- allErrs = append(allErrs, ValidateLabelName(k, fldPath)...)
- if !validation.IsValidLabelValue(v) {
- allErrs = append(allErrs, field.Invalid(fldPath, v, labelValueErrorMsg))
- }
- }
- return allErrs
+// BannedOwners is a black list of object that are not allowed to be owners.
+var BannedOwners = map[unversioned.GroupVersionKind]struct{}{
+ v1.SchemeGroupVersion.WithKind("Event"): {},
}
// ValidateHasLabel requires that api.ObjectMeta has a Label with key and expectedValue
@@ -106,8 +89,8 @@ func ValidateAnnotations(annotations map[string]string, fldPath *field.Path) fie
allErrs := field.ErrorList{}
var totalSize int64
for k, v := range annotations {
- if !validation.IsQualifiedName(strings.ToLower(k)) {
- allErrs = append(allErrs, field.Invalid(fldPath, k, qualifiedNameErrorMsg))
+ for _, msg := range validation.IsQualifiedName(strings.ToLower(k)) {
+ allErrs = append(allErrs, field.Invalid(fldPath, k, msg))
}
totalSize += (int64)(len(k)) + (int64)(len(v))
}
@@ -123,14 +106,24 @@ func ValidatePodSpecificAnnotations(annotations map[string]string, fldPath *fiel
allErrs = append(allErrs, ValidateAffinityInPodAnnotations(annotations, fldPath)...)
}
- if hostname, exists := annotations[utilpod.PodHostnameAnnotation]; exists && !validation.IsDNS1123Label(hostname) {
- allErrs = append(allErrs, field.Invalid(fldPath, utilpod.PodHostnameAnnotation, DNS1123LabelErrorMsg))
+ if annotations[api.TolerationsAnnotationKey] != "" {
+ allErrs = append(allErrs, ValidateTolerationsInPodAnnotations(annotations, fldPath)...)
+ }
+
+ if hostname, exists := annotations[utilpod.PodHostnameAnnotation]; exists {
+ for _, msg := range validation.IsDNS1123Label(hostname) {
+ allErrs = append(allErrs, field.Invalid(fldPath, utilpod.PodHostnameAnnotation, msg))
+ }
}
- if subdomain, exists := annotations[utilpod.PodSubdomainAnnotation]; exists && !validation.IsDNS1123Label(subdomain) {
- allErrs = append(allErrs, field.Invalid(fldPath, utilpod.PodSubdomainAnnotation, DNS1123LabelErrorMsg))
+ if subdomain, exists := annotations[utilpod.PodSubdomainAnnotation]; exists {
+ for _, msg := range validation.IsDNS1123Label(subdomain) {
+ allErrs = append(allErrs, field.Invalid(fldPath, utilpod.PodSubdomainAnnotation, msg))
+ }
}
+ allErrs = append(allErrs, ValidateSeccompPodAnnotations(annotations, fldPath)...)
+
return allErrs
}
@@ -145,10 +138,51 @@ func ValidateEndpointsSpecificAnnotations(annotations map[string]string, fldPath
return allErrs
}
+func validateOwnerReference(ownerReference api.OwnerReference, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ gvk := unversioned.FromAPIVersionAndKind(ownerReference.APIVersion, ownerReference.Kind)
+ // gvk.Group is empty for the legacy group.
+ if len(gvk.Version) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("apiVersion"), ownerReference.APIVersion, "version must not be empty"))
+ }
+ if len(gvk.Kind) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("kind"), ownerReference.Kind, "kind must not be empty"))
+ }
+ if len(ownerReference.Name) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), ownerReference.Name, "name must not be empty"))
+ }
+ if len(ownerReference.UID) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("uid"), ownerReference.UID, "uid must not be empty"))
+ }
+ if _, ok := BannedOwners[gvk]; ok {
+ allErrs = append(allErrs, field.Invalid(fldPath, ownerReference, fmt.Sprintf("%s is disallowed from being an owner", gvk)))
+ }
+ return allErrs
+}
+
+func ValidateOwnerReferences(ownerReferences []api.OwnerReference, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ controllerName := ""
+ for _, ref := range ownerReferences {
+ allErrs = append(allErrs, validateOwnerReference(ref, fldPath)...)
+ if ref.Controller != nil && *ref.Controller {
+ if controllerName != "" {
+ allErrs = append(allErrs, field.Invalid(fldPath, ownerReferences,
+ fmt.Sprintf("Only one reference can have Controller set to true. Found \"true\" in references for %v and %v", controllerName, ref.Name)))
+ } else {
+ controllerName = ref.Name
+ }
+ }
+ }
+ return allErrs
+}
+
// ValidateNameFunc validates that the provided name is valid for a given resource type.
-// Not all resources have the same validation rules for names. Prefix is true if the
-// name will have a value appended to it.
-type ValidateNameFunc func(name string, prefix bool) (bool, string)
+// Not all resources have the same validation rules for names. Prefix is true
+// if the name will have a value appended to it. If the name is not valid,
+// this returns a list of descriptions of individual characteristics of the
+// value that were not valid. Otherwise this returns an empty list or nil.
+type ValidateNameFunc func(name string, prefix bool) []string
// maskTrailingDash replaces the final character of a string with a subdomain safe
// value if is a dash.
@@ -162,106 +196,77 @@ func maskTrailingDash(name string) string {
// ValidatePodName can be used to check whether the given pod name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidatePodName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidatePodName = NameIsDNSSubdomain
// ValidateReplicationControllerName can be used to check whether the given replication
// controller name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateReplicationControllerName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateReplicationControllerName = NameIsDNSSubdomain
// ValidateServiceName can be used to check whether the given service name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateServiceName(name string, prefix bool) (bool, string) {
- return NameIsDNS952Label(name, prefix)
-}
+var ValidateServiceName = NameIsDNS952Label
// ValidateNodeName can be used to check whether the given node name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateNodeName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateNodeName = NameIsDNSSubdomain
// ValidateNamespaceName can be used to check whether the given namespace name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateNamespaceName(name string, prefix bool) (bool, string) {
- return NameIsDNSLabel(name, prefix)
-}
+var ValidateNamespaceName = NameIsDNSLabel
// ValidateLimitRangeName can be used to check whether the given limit range name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateLimitRangeName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateLimitRangeName = NameIsDNSSubdomain
// ValidateResourceQuotaName can be used to check whether the given
// resource quota name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateResourceQuotaName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateResourceQuotaName = NameIsDNSSubdomain
// ValidateSecretName can be used to check whether the given secret name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateSecretName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateSecretName = NameIsDNSSubdomain
// ValidateServiceAccountName can be used to check whether the given service account name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateServiceAccountName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateServiceAccountName = NameIsDNSSubdomain
// ValidateEndpointsName can be used to check whether the given endpoints name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateEndpointsName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateEndpointsName = NameIsDNSSubdomain
// NameIsDNSSubdomain is a ValidateNameFunc for names that must be a DNS subdomain.
-func NameIsDNSSubdomain(name string, prefix bool) (bool, string) {
+func NameIsDNSSubdomain(name string, prefix bool) []string {
if prefix {
name = maskTrailingDash(name)
}
- if validation.IsDNS1123Subdomain(name) {
- return true, ""
- }
- return false, DNSSubdomainErrorMsg
+ return validation.IsDNS1123Subdomain(name)
}
// NameIsDNSLabel is a ValidateNameFunc for names that must be a DNS 1123 label.
-func NameIsDNSLabel(name string, prefix bool) (bool, string) {
+func NameIsDNSLabel(name string, prefix bool) []string {
if prefix {
name = maskTrailingDash(name)
}
- if validation.IsDNS1123Label(name) {
- return true, ""
- }
- return false, DNS1123LabelErrorMsg
+ return validation.IsDNS1123Label(name)
}
// NameIsDNS952Label is a ValidateNameFunc for names that must be a DNS 952 label.
-func NameIsDNS952Label(name string, prefix bool) (bool, string) {
+func NameIsDNS952Label(name string, prefix bool) []string {
if prefix {
name = maskTrailingDash(name)
}
- if validation.IsDNS952Label(name) {
- return true, ""
- }
- return false, DNS952LabelErrorMsg
+ return validation.IsDNS952Label(name)
}
// Validates that given value is not negative.
@@ -298,8 +303,8 @@ func ValidateObjectMeta(meta *api.ObjectMeta, requiresNamespace bool, nameFn Val
allErrs := field.ErrorList{}
if len(meta.GenerateName) != 0 {
- if ok, qualifier := nameFn(meta.GenerateName, true); !ok {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("generateName"), meta.GenerateName, qualifier))
+ for _, msg := range nameFn(meta.GenerateName, true) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("generateName"), meta.GenerateName, msg))
}
}
// If the generated name validates, but the calculated value does not, it's a problem with generation, and we
@@ -308,15 +313,17 @@ func ValidateObjectMeta(meta *api.ObjectMeta, requiresNamespace bool, nameFn Val
if len(meta.Name) == 0 {
allErrs = append(allErrs, field.Required(fldPath.Child("name"), "name or generateName is required"))
} else {
- if ok, qualifier := nameFn(meta.Name, false); !ok {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), meta.Name, qualifier))
+ for _, msg := range nameFn(meta.Name, false) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), meta.Name, msg))
}
}
if requiresNamespace {
if len(meta.Namespace) == 0 {
allErrs = append(allErrs, field.Required(fldPath.Child("namespace"), ""))
- } else if ok, _ := ValidateNamespaceName(meta.Namespace, false); !ok {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), meta.Namespace, DNS1123LabelErrorMsg))
+ } else {
+ for _, msg := range ValidateNamespaceName(meta.Namespace, false) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), meta.Namespace, msg))
+ }
}
} else {
if len(meta.Namespace) != 0 {
@@ -324,9 +331,12 @@ func ValidateObjectMeta(meta *api.ObjectMeta, requiresNamespace bool, nameFn Val
}
}
allErrs = append(allErrs, ValidateNonnegativeField(meta.Generation, fldPath.Child("generation"))...)
- allErrs = append(allErrs, ValidateLabels(meta.Labels, fldPath.Child("labels"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabels(meta.Labels, fldPath.Child("labels"))...)
allErrs = append(allErrs, ValidateAnnotations(meta.Annotations, fldPath.Child("annotations"))...)
-
+ allErrs = append(allErrs, ValidateOwnerReferences(meta.OwnerReferences, fldPath.Child("ownerReferences"))...)
+ for _, finalizer := range meta.Finalizers {
+ allErrs = append(allErrs, validateFinalizerName(finalizer, fldPath.Child("finalizers"))...)
+ }
return allErrs
}
@@ -377,8 +387,9 @@ func ValidateObjectMetaUpdate(newMeta, oldMeta *api.ObjectMeta, fldPath *field.P
allErrs = append(allErrs, ValidateImmutableField(newMeta.UID, oldMeta.UID, fldPath.Child("uid"))...)
allErrs = append(allErrs, ValidateImmutableField(newMeta.CreationTimestamp, oldMeta.CreationTimestamp, fldPath.Child("creationTimestamp"))...)
- allErrs = append(allErrs, ValidateLabels(newMeta.Labels, fldPath.Child("labels"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabels(newMeta.Labels, fldPath.Child("labels"))...)
allErrs = append(allErrs, ValidateAnnotations(newMeta.Annotations, fldPath.Child("annotations"))...)
+ allErrs = append(allErrs, ValidateOwnerReferences(newMeta.OwnerReferences, fldPath.Child("ownerReferences"))...)
return allErrs
}
@@ -392,8 +403,10 @@ func validateVolumes(volumes []api.Volume, fldPath *field.Path) (sets.String, fi
el := validateVolumeSource(&vol.VolumeSource, idxPath)
if len(vol.Name) == 0 {
el = append(el, field.Required(idxPath.Child("name"), ""))
- } else if !validation.IsDNS1123Label(vol.Name) {
- el = append(el, field.Invalid(idxPath.Child("name"), vol.Name, DNS1123LabelErrorMsg))
+ } else if msgs := validation.IsDNS1123Label(vol.Name); len(msgs) != 0 {
+ for i := range msgs {
+ el = append(el, field.Invalid(idxPath.Child("name"), vol.Name, msgs[i]))
+ }
} else if allNames.Has(vol.Name) {
el = append(el, field.Duplicate(idxPath.Child("name"), vol.Name))
}
@@ -554,6 +567,14 @@ func validateVolumeSource(source *api.VolumeSource, fldPath *field.Path) field.E
numVolumes++
allErrs = append(allErrs, validateAzureFile(source.AzureFile, fldPath.Child("azureFile"))...)
}
+ if source.VsphereVolume != nil {
+ if numVolumes > 0 {
+ allErrs = append(allErrs, field.Forbidden(fldPath.Child("vsphereVolume"), "may not specify more than 1 volume type"))
+ } else {
+ numVolumes++
+ allErrs = append(allErrs, validateVsphereVolumeSource(source.VsphereVolume, fldPath.Child("vsphereVolume"))...)
+ }
+ }
if numVolumes == 0 {
allErrs = append(allErrs, field.Required(fldPath, "must specify a volume type"))
}
@@ -701,7 +722,38 @@ func validateDownwardAPIVolumeSource(downwardAPIVolume *api.DownwardAPIVolumeSou
allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
}
allErrs = append(allErrs, validateVolumeSourcePath(downwardAPIVolumeFile.Path, fldPath.Child("path"))...)
- allErrs = append(allErrs, validateObjectFieldSelector(&downwardAPIVolumeFile.FieldRef, &validDownwardAPIFieldPathExpressions, fldPath.Child("fieldRef"))...)
+ if downwardAPIVolumeFile.FieldRef != nil {
+ allErrs = append(allErrs, validateObjectFieldSelector(downwardAPIVolumeFile.FieldRef, &validDownwardAPIFieldPathExpressions, fldPath.Child("fieldRef"))...)
+ if downwardAPIVolumeFile.ResourceFieldRef != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath, "resource", "fieldRef and resourceFieldRef can not be specified simultaneously"))
+ }
+ } else if downwardAPIVolumeFile.ResourceFieldRef != nil {
+ allErrs = append(allErrs, validateContainerResourceFieldSelector(downwardAPIVolumeFile.ResourceFieldRef, &validContainerResourceFieldPathExpressions, fldPath.Child("resourceFieldRef"), true)...)
+ } else {
+ allErrs = append(allErrs, field.Required(fldPath, "one of fieldRef and resourceFieldRef is required"))
+ }
+ }
+ return allErrs
+}
+
+// This validate will make sure targetPath:
+// 1. is not abs path
+// 2. does not start with '../'
+// 3. does not contain '/../'
+// 4. does not end with '/..'
+func validateSubPath(targetPath string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if path.IsAbs(targetPath) {
+ allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must be a relative path"))
+ }
+ if strings.HasPrefix(targetPath, "../") {
+ allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must not start with '../'"))
+ }
+ if strings.Contains(targetPath, "/../") {
+ allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must not contain '/../'"))
+ }
+ if strings.HasSuffix(targetPath, "/..") {
+ allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must not end with '/..'"))
}
return allErrs
}
@@ -775,10 +827,18 @@ func validateAzureFile(azure *api.AzureFileVolumeSource, fldPath *field.Path) fi
return allErrs
}
-func ValidatePersistentVolumeName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
+func validateVsphereVolumeSource(cd *api.VsphereVirtualDiskVolumeSource, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if len(cd.VolumePath) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("volumePath"), ""))
+ }
+ return allErrs
}
+// ValidatePersistentVolumeName checks that a name is appropriate for a
+// PersistentVolumeName object.
+var ValidatePersistentVolumeName = NameIsDNSSubdomain
+
var supportedAccessModes = sets.NewString(string(api.ReadWriteOnce), string(api.ReadOnlyMany), string(api.ReadWriteMany))
func ValidatePersistentVolume(pv *api.PersistentVolume) field.ErrorList {
@@ -903,6 +963,14 @@ func ValidatePersistentVolume(pv *api.PersistentVolume) field.ErrorList {
numVolumes++
allErrs = append(allErrs, validateAzureFile(pv.Spec.AzureFile, specPath.Child("azureFile"))...)
}
+ if pv.Spec.VsphereVolume != nil {
+ if numVolumes > 0 {
+ allErrs = append(allErrs, field.Forbidden(specPath.Child("vsphereVolume"), "may not specify more than 1 volume type"))
+ } else {
+ numVolumes++
+ allErrs = append(allErrs, validateVsphereVolumeSource(pv.Spec.VsphereVolume, specPath.Child("vsphereVolume"))...)
+ }
+ }
if numVolumes == 0 {
allErrs = append(allErrs, field.Required(specPath, "must specify a volume type"))
}
@@ -935,6 +1003,9 @@ func ValidatePersistentVolumeClaim(pvc *api.PersistentVolumeClaim) field.ErrorLi
if len(pvc.Spec.AccessModes) == 0 {
allErrs = append(allErrs, field.Required(specPath.Child("accessModes"), "at least 1 accessMode is required"))
}
+ if pvc.Spec.Selector != nil {
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(pvc.Spec.Selector, specPath.Child("selector"))...)
+ }
for _, mode := range pvc.Spec.AccessModes {
if mode != api.ReadWriteOnce && mode != api.ReadOnlyMany && mode != api.ReadWriteMany {
allErrs = append(allErrs, field.NotSupported(specPath.Child("accessModes"), mode, supportedAccessModes.List()))
@@ -994,10 +1065,10 @@ func validateContainerPorts(ports []api.ContainerPort, fldPath *field.Path) fiel
}
if port.ContainerPort == 0 {
allErrs = append(allErrs, field.Invalid(idxPath.Child("containerPort"), port.ContainerPort, PortRangeErrorMsg))
- } else if !validation.IsValidPortNum(port.ContainerPort) {
+ } else if !validation.IsValidPortNum(int(port.ContainerPort)) {
allErrs = append(allErrs, field.Invalid(idxPath.Child("containerPort"), port.ContainerPort, PortRangeErrorMsg))
}
- if port.HostPort != 0 && !validation.IsValidPortNum(port.HostPort) {
+ if port.HostPort != 0 && !validation.IsValidPortNum(int(port.HostPort)) {
allErrs = append(allErrs, field.Invalid(idxPath.Child("hostPort"), port.HostPort, PortRangeErrorMsg))
}
if len(port.Protocol) == 0 {
@@ -1025,6 +1096,7 @@ func validateEnv(vars []api.EnvVar, fldPath *field.Path) field.ErrorList {
}
var validFieldPathExpressionsEnv = sets.NewString("metadata.name", "metadata.namespace", "status.podIP")
+var validContainerResourceFieldPathExpressions = sets.NewString("limits.cpu", "limits.memory", "requests.cpu", "requests.memory")
func validateEnvVarValueFrom(ev api.EnvVar, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
@@ -1039,6 +1111,10 @@ func validateEnvVarValueFrom(ev api.EnvVar, fldPath *field.Path) field.ErrorList
numSources++
allErrs = append(allErrs, validateObjectFieldSelector(ev.ValueFrom.FieldRef, &validFieldPathExpressionsEnv, fldPath.Child("fieldRef"))...)
}
+ if ev.ValueFrom.ResourceFieldRef != nil {
+ numSources++
+ allErrs = append(allErrs, validateContainerResourceFieldSelector(ev.ValueFrom.ResourceFieldRef, &validContainerResourceFieldPathExpressions, fldPath.Child("resourceFieldRef"), false)...)
+ }
if ev.ValueFrom.ConfigMapKeyRef != nil {
numSources++
allErrs = append(allErrs, validateConfigMapKeySelector(ev.ValueFrom.ConfigMapKeyRef, fldPath.Child("configMapKeyRef"))...)
@@ -1078,6 +1154,42 @@ func validateObjectFieldSelector(fs *api.ObjectFieldSelector, expressions *sets.
return allErrs
}
+func validateContainerResourceFieldSelector(fs *api.ResourceFieldSelector, expressions *sets.String, fldPath *field.Path, volume bool) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ if volume && len(fs.ContainerName) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("containerName"), ""))
+ } else if len(fs.Resource) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("resource"), ""))
+ } else if !expressions.Has(fs.Resource) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("resource"), fs.Resource, expressions.List()))
+ }
+ allErrs = append(allErrs, validateContainerResourceDivisor(fs.Resource, fs.Divisor, fldPath)...)
+ return allErrs
+}
+
+var validContainerResourceDivisorForCPU = sets.NewString("1m", "1")
+var validContainerResourceDivisorForMemory = sets.NewString("1", "1k", "1M", "1G", "1T", "1P", "1E", "1Ki", "1Mi", "1Gi", "1Ti", "1Pi", "1Ei")
+
+func validateContainerResourceDivisor(rName string, divisor resource.Quantity, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ unsetDivisor := resource.Quantity{}
+ if unsetDivisor.Cmp(divisor) == 0 {
+ return allErrs
+ }
+ switch rName {
+ case "limits.cpu", "requests.cpu":
+ if !validContainerResourceDivisorForCPU.Has(divisor.String()) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, fmt.Sprintf("only divisor's values 1m and 1 are supported with the cpu resource")))
+ }
+ case "limits.memory", "requests.memory":
+ if !validContainerResourceDivisorForMemory.Has(divisor.String()) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, fmt.Sprintf("only divisor's values 1, 1k, 1M, 1G, 1T, 1P, 1E, 1Ki, 1Mi, 1Gi, 1Ti, 1Pi, 1Ei are supported with the memory resource")))
+ }
+ }
+ return allErrs
+}
+
func validateConfigMapKeySelector(s *api.ConfigMapKeySelector, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
@@ -1110,6 +1222,7 @@ func validateSecretKeySelector(s *api.SecretKeySelector, fldPath *field.Path) fi
func validateVolumeMounts(mounts []api.VolumeMount, volumes sets.String, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
+ mountpoints := sets.NewString()
for i, mnt := range mounts {
idxPath := fldPath.Index(i)
@@ -1123,6 +1236,13 @@ func validateVolumeMounts(mounts []api.VolumeMount, volumes sets.String, fldPath
} else if strings.Contains(mnt.MountPath, ":") {
allErrs = append(allErrs, field.Invalid(idxPath.Child("mountPath"), mnt.MountPath, "must not contain ':'"))
}
+ if mountpoints.Has(mnt.MountPath) {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("mountPath"), mnt.MountPath, "must be unique"))
+ }
+ mountpoints.Insert(mnt.MountPath)
+ if len(mnt.SubPath) > 0 {
+ allErrs = append(allErrs, validateSubPath(mnt.SubPath, fldPath.Child("subPath"))...)
+ }
}
return allErrs
}
@@ -1276,6 +1396,37 @@ func validatePullPolicy(policy api.PullPolicy, fldPath *field.Path) field.ErrorL
return allErrors
}
+func validateInitContainers(containers, otherContainers []api.Container, volumes sets.String, fldPath *field.Path) field.ErrorList {
+ var allErrs field.ErrorList
+ if len(containers) > 0 {
+ allErrs = append(allErrs, validateContainers(containers, volumes, fldPath)...)
+ }
+
+ allNames := sets.String{}
+ for _, ctr := range otherContainers {
+ allNames.Insert(ctr.Name)
+ }
+ for i, ctr := range containers {
+ idxPath := fldPath.Index(i)
+ if allNames.Has(ctr.Name) {
+ allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), ctr.Name))
+ }
+ if len(ctr.Name) > 0 {
+ allNames.Insert(ctr.Name)
+ }
+ if ctr.Lifecycle != nil {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("lifecycle"), ctr.Lifecycle, "must not be set for init containers"))
+ }
+ if ctr.LivenessProbe != nil {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("livenessProbe"), ctr.LivenessProbe, "must not be set for init containers"))
+ }
+ if ctr.ReadinessProbe != nil {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("readinessProbe"), ctr.ReadinessProbe, "must not be set for init containers"))
+ }
+ }
+ return allErrs
+}
+
func validateContainers(containers []api.Container, volumes sets.String, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
@@ -1288,8 +1439,10 @@ func validateContainers(containers []api.Container, volumes sets.String, fldPath
idxPath := fldPath.Index(i)
if len(ctr.Name) == 0 {
allErrs = append(allErrs, field.Required(idxPath.Child("name"), ""))
- } else if !validation.IsDNS1123Label(ctr.Name) {
- allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), ctr.Name, DNS1123LabelErrorMsg))
+ } else if msgs := validation.IsDNS1123Label(ctr.Name); len(msgs) != 0 {
+ for i := range msgs {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), ctr.Name, msgs[i]))
+ }
} else if allNames.Has(ctr.Name) {
allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), ctr.Name))
} else {
@@ -1382,6 +1535,60 @@ func validateImagePullSecrets(imagePullSecrets []api.LocalObjectReference, fldPa
return allErrors
}
+func validateTaintEffect(effect *api.TaintEffect, allowEmpty bool, fldPath *field.Path) field.ErrorList {
+ if !allowEmpty && len(*effect) == 0 {
+ return field.ErrorList{field.Required(fldPath, "")}
+ }
+
+ allErrors := field.ErrorList{}
+ switch *effect {
+ // TODO: Replace next line with subsequent commented-out line when implement TaintEffectNoScheduleNoAdmit, TaintEffectNoScheduleNoAdmitNoExecute.
+ case api.TaintEffectNoSchedule, api.TaintEffectPreferNoSchedule:
+ // case api.TaintEffectNoSchedule, api.TaintEffectPreferNoSchedule, api.TaintEffectNoScheduleNoAdmit, api.TaintEffectNoScheduleNoAdmitNoExecute:
+ default:
+ validValues := []string{
+ string(api.TaintEffectNoSchedule),
+ string(api.TaintEffectPreferNoSchedule),
+ // TODO: Uncomment this block when implement TaintEffectNoScheduleNoAdmit, TaintEffectNoScheduleNoAdmitNoExecute.
+ // string(api.TaintEffectNoScheduleNoAdmit),
+ // string(api.TaintEffectNoScheduleNoAdmitNoExecute),
+ }
+ allErrors = append(allErrors, field.NotSupported(fldPath, effect, validValues))
+ }
+ return allErrors
+}
+
+// validateTolerations tests if given tolerations have valid data.
+func validateTolerations(tolerations []api.Toleration, fldPath *field.Path) field.ErrorList {
+ allErrors := field.ErrorList{}
+ for i, toleration := range tolerations {
+ idxPath := fldPath.Index(i)
+ // validate the toleration key
+ allErrors = append(allErrors, unversionedvalidation.ValidateLabelName(toleration.Key, idxPath.Child("key"))...)
+
+ // validate toleration operator and value
+ switch toleration.Operator {
+ case api.TolerationOpEqual, "":
+ if errs := validation.IsValidLabelValue(toleration.Value); len(errs) != 0 {
+ allErrors = append(allErrors, field.Invalid(idxPath.Child("operator"), toleration.Value, strings.Join(errs, ";")))
+ }
+ case api.TolerationOpExists:
+ if len(toleration.Value) > 0 {
+ allErrors = append(allErrors, field.Invalid(idxPath.Child("operator"), toleration, "value must be empty when `operator` is 'Exists'"))
+ }
+ default:
+ validValues := []string{string(api.TolerationOpEqual), string(api.TolerationOpExists)}
+ allErrors = append(allErrors, field.NotSupported(idxPath.Child("operator"), toleration.Operator, validValues))
+ }
+
+ // validate toleration effect
+ if len(toleration.Effect) > 0 {
+ allErrors = append(allErrors, validateTaintEffect(&toleration.Effect, true, idxPath.Child("effect"))...)
+ }
+ }
+ return allErrors
+}
+
// ValidatePod tests if required fields in the pod are set.
func ValidatePod(pod *api.Pod) field.ErrorList {
fldPath := field.NewPath("metadata")
@@ -1401,19 +1608,20 @@ func ValidatePodSpec(spec *api.PodSpec, fldPath *field.Path) field.ErrorList {
allVolumes, vErrs := validateVolumes(spec.Volumes, fldPath.Child("volumes"))
allErrs = append(allErrs, vErrs...)
allErrs = append(allErrs, validateContainers(spec.Containers, allVolumes, fldPath.Child("containers"))...)
+ allErrs = append(allErrs, validateInitContainers(spec.InitContainers, spec.Containers, allVolumes, fldPath.Child("initContainers"))...)
allErrs = append(allErrs, validateRestartPolicy(&spec.RestartPolicy, fldPath.Child("restartPolicy"))...)
allErrs = append(allErrs, validateDNSPolicy(&spec.DNSPolicy, fldPath.Child("dnsPolicy"))...)
- allErrs = append(allErrs, ValidateLabels(spec.NodeSelector, fldPath.Child("nodeSelector"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabels(spec.NodeSelector, fldPath.Child("nodeSelector"))...)
allErrs = append(allErrs, ValidatePodSecurityContext(spec.SecurityContext, spec, fldPath, fldPath.Child("securityContext"))...)
allErrs = append(allErrs, validateImagePullSecrets(spec.ImagePullSecrets, fldPath.Child("imagePullSecrets"))...)
if len(spec.ServiceAccountName) > 0 {
- if ok, msg := ValidateServiceAccountName(spec.ServiceAccountName, false); !ok {
+ for _, msg := range ValidateServiceAccountName(spec.ServiceAccountName, false) {
allErrs = append(allErrs, field.Invalid(fldPath.Child("serviceAccountName"), spec.ServiceAccountName, msg))
}
}
if len(spec.NodeName) > 0 {
- if ok, msg := ValidateNodeName(spec.NodeName, false); !ok {
+ for _, msg := range ValidateNodeName(spec.NodeName, false) {
allErrs = append(allErrs, field.Invalid(fldPath.Child("nodeName"), spec.NodeName, msg))
}
}
@@ -1423,6 +1631,19 @@ func ValidatePodSpec(spec *api.PodSpec, fldPath *field.Path) field.ErrorList {
allErrs = append(allErrs, field.Invalid(fldPath.Child("activeDeadlineSeconds"), spec.ActiveDeadlineSeconds, "must be greater than 0"))
}
}
+
+ if len(spec.Hostname) > 0 {
+ for _, msg := range validation.IsDNS1123Label(spec.Hostname) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("hostname"), spec.Hostname, msg))
+ }
+ }
+
+ if len(spec.Subdomain) > 0 {
+ for _, msg := range validation.IsDNS1123Label(spec.Subdomain) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("subdomain"), spec.Subdomain, msg))
+ }
+ }
+
return allErrs
}
@@ -1446,7 +1667,7 @@ func ValidateNodeSelectorRequirement(rq api.NodeSelectorRequirement, fldPath *fi
default:
allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), rq.Operator, "not a valid selector operator"))
}
- allErrs = append(allErrs, ValidateLabelName(rq.Key, fldPath.Child("key"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(rq.Key, fldPath.Child("key"))...)
return allErrs
}
@@ -1493,6 +1714,87 @@ func ValidatePreferredSchedulingTerms(terms []api.PreferredSchedulingTerm, fldPa
return allErrs
}
+// validatePodAffinityTerm tests that the specified podAffinityTerm fields have valid data
+func validatePodAffinityTerm(podAffinityTerm api.PodAffinityTerm, allowEmptyTopologyKey bool, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(podAffinityTerm.LabelSelector, fldPath.Child("matchExpressions"))...)
+ for _, name := range podAffinityTerm.Namespaces {
+ for _, msg := range ValidateNamespaceName(name, false) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), name, msg))
+ }
+ }
+ if !allowEmptyTopologyKey && len(podAffinityTerm.TopologyKey) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("topologyKey"), "can only be empty for PreferredDuringScheduling pod anti affinity"))
+ }
+ if len(podAffinityTerm.TopologyKey) != 0 {
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(podAffinityTerm.TopologyKey, fldPath.Child("topologyKey"))...)
+ }
+ return allErrs
+}
+
+// validatePodAffinityTerms tests that the specified podAffinityTerms fields have valid data
+func validatePodAffinityTerms(podAffinityTerms []api.PodAffinityTerm, allowEmptyTopologyKey bool, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ for i, podAffinityTerm := range podAffinityTerms {
+ allErrs = append(allErrs, validatePodAffinityTerm(podAffinityTerm, allowEmptyTopologyKey, fldPath.Index(i))...)
+ }
+ return allErrs
+}
+
+// validateWeightedPodAffinityTerms tests that the specified weightedPodAffinityTerms fields have valid data
+func validateWeightedPodAffinityTerms(weightedPodAffinityTerms []api.WeightedPodAffinityTerm, allowEmptyTopologyKey bool, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ for j, weightedTerm := range weightedPodAffinityTerms {
+ if weightedTerm.Weight <= 0 || weightedTerm.Weight > 100 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Index(j).Child("weight"), weightedTerm.Weight, "must be in the range 1-100"))
+ }
+ allErrs = append(allErrs, validatePodAffinityTerm(weightedTerm.PodAffinityTerm, allowEmptyTopologyKey, fldPath.Index(j).Child("podAffinityTerm"))...)
+ }
+ return allErrs
+}
+
+// validatePodAntiAffinity tests that the specified podAntiAffinity fields have valid data
+func validatePodAntiAffinity(podAntiAffinity *api.PodAntiAffinity, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ // TODO:Uncomment below code once RequiredDuringSchedulingRequiredDuringExecution is implemented.
+ // if podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil {
+ // allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution, false,
+ // fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
+ //}
+ if podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ // empty topologyKey is not allowed for hard pod anti-affinity
+ allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution, false,
+ fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
+ }
+ if podAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ // empty topologyKey is allowed for soft pod anti-affinity
+ allErrs = append(allErrs, validateWeightedPodAffinityTerms(podAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution, true,
+ fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
+ }
+ return allErrs
+}
+
+// validatePodAffinity tests that the specified podAffinity fields have valid data
+func validatePodAffinity(podAffinity *api.PodAffinity, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ // TODO:Uncomment below code once RequiredDuringSchedulingRequiredDuringExecution is implemented.
+ // if podAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil {
+ // allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingRequiredDuringExecution, false,
+ // fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
+ //}
+ if podAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {
+ // empty topologyKey is not allowed for hard pod affinity
+ allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingIgnoredDuringExecution, false,
+ fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
+ }
+ if podAffinity.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+ // empty topologyKey is not allowed for soft pod affinity
+ allErrs = append(allErrs, validateWeightedPodAffinityTerms(podAffinity.PreferredDuringSchedulingIgnoredDuringExecution, false,
+ fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
+ }
+ return allErrs
+}
+
// ValidateAffinityInPodAnnotations tests that the serialized Affinity in Pod.Annotations has valid data
func ValidateAffinityInPodAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
@@ -1503,21 +1805,70 @@ func ValidateAffinityInPodAnnotations(annotations map[string]string, fldPath *fi
return allErrs
}
+ affinityFldPath := fldPath.Child(api.AffinityAnnotationKey)
if affinity.NodeAffinity != nil {
na := affinity.NodeAffinity
-
+ naFldPath := affinityFldPath.Child("nodeAffinity")
// TODO: Uncomment the next three lines once RequiredDuringSchedulingRequiredDuringExecution is implemented.
// if na.RequiredDuringSchedulingRequiredDuringExecution != nil {
- // allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingRequiredDuringExecution, fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
+ // allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingRequiredDuringExecution, naFldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
// }
if na.RequiredDuringSchedulingIgnoredDuringExecution != nil {
- allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingIgnoredDuringExecution, fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
+ allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingIgnoredDuringExecution, naFldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
}
if len(na.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
- allErrs = append(allErrs, ValidatePreferredSchedulingTerms(na.PreferredDuringSchedulingIgnoredDuringExecution, fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
+ allErrs = append(allErrs, ValidatePreferredSchedulingTerms(na.PreferredDuringSchedulingIgnoredDuringExecution, naFldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
+ }
+ }
+ if affinity.PodAffinity != nil {
+ allErrs = append(allErrs, validatePodAffinity(affinity.PodAffinity, affinityFldPath.Child("podAffinity"))...)
+ }
+ if affinity.PodAntiAffinity != nil {
+ allErrs = append(allErrs, validatePodAntiAffinity(affinity.PodAntiAffinity, affinityFldPath.Child("podAntiAffinity"))...)
+ }
+
+ return allErrs
+}
+// ValidateTolerationsInPodAnnotations tests that the serialized tolerations in Pod.Annotations has valid data
+func ValidateTolerationsInPodAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ tolerations, err := api.GetTolerationsFromPodAnnotations(annotations)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath, api.TolerationsAnnotationKey, err.Error()))
+ return allErrs
+ }
+ if len(tolerations) > 0 {
+ allErrs = append(allErrs, validateTolerations(tolerations, fldPath.Child(api.TolerationsAnnotationKey))...)
+ }
+
+ return allErrs
+}
+
+func validateSeccompProfile(p string, fldPath *field.Path) field.ErrorList {
+ if p == "docker/default" {
+ return nil
+ }
+ if p == "unconfined" {
+ return nil
+ }
+ if strings.HasPrefix(p, "localhost/") {
+ return validateSubPath(strings.TrimPrefix(p, "localhost/"), fldPath)
+ }
+ return field.ErrorList{field.Invalid(fldPath, p, "must be a valid seccomp profile")}
+}
+
+func ValidateSeccompPodAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if p, exists := annotations[api.SeccompPodAnnotationKey]; exists {
+ allErrs = append(allErrs, validateSeccompProfile(p, fldPath.Child(api.SeccompPodAnnotationKey))...)
+ }
+ for k, p := range annotations {
+ if strings.HasPrefix(k, api.SeccompContainerAnnotationKeyPrefix) {
+ allErrs = append(allErrs, validateSeccompProfile(p, fldPath.Child(k))...)
}
}
@@ -1695,7 +2046,7 @@ func ValidateService(service *api.Service) field.ErrorList {
}
if service.Spec.Selector != nil {
- allErrs = append(allErrs, ValidateLabels(service.Spec.Selector, specPath.Child("selector"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabels(service.Spec.Selector, specPath.Child("selector"))...)
}
if len(service.Spec.SessionAffinity) == 0 {
@@ -1770,12 +2121,26 @@ func ValidateService(service *api.Service) field.ErrorList {
nodePorts[key] = true
}
- _, err := apiservice.GetLoadBalancerSourceRanges(service.Annotations)
- if err != nil {
- v := service.Annotations[apiservice.AnnotationLoadBalancerSourceRangesKey]
- allErrs = append(allErrs, field.Invalid(field.NewPath("metadata", "annotations").Key(apiservice.AnnotationLoadBalancerSourceRangesKey), v, "must be a comma separated list of CIDRs e.g. 192.168.0.0/16,10.0.0.0/8"))
+ // Validate SourceRange field and annotation
+ _, ok := service.Annotations[apiservice.AnnotationLoadBalancerSourceRangesKey]
+ if len(service.Spec.LoadBalancerSourceRanges) > 0 || ok {
+ var fieldPath *field.Path
+ var val string
+ if len(service.Spec.LoadBalancerSourceRanges) > 0 {
+ fieldPath = specPath.Child("LoadBalancerSourceRanges")
+ val = fmt.Sprintf("%v", service.Spec.LoadBalancerSourceRanges)
+ } else {
+ fieldPath = field.NewPath("metadata", "annotations").Key(apiservice.AnnotationLoadBalancerSourceRangesKey)
+ val = service.Annotations[apiservice.AnnotationLoadBalancerSourceRangesKey]
+ }
+ if service.Spec.Type != api.ServiceTypeLoadBalancer {
+ allErrs = append(allErrs, field.Invalid(fieldPath, "", "may only be used when `type` is 'LoadBalancer'"))
+ }
+ _, err := apiservice.GetLoadBalancerSourceRanges(service)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fieldPath, val, "must be a list of IP ranges. For example, 10.240.0.0/24,10.250.0.0/24 "))
+ }
}
-
return allErrs
}
@@ -1785,8 +2150,10 @@ func validateServicePort(sp *api.ServicePort, requireName, isHeadlessService boo
if requireName && len(sp.Name) == 0 {
allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
} else if len(sp.Name) != 0 {
- if !validation.IsDNS1123Label(sp.Name) {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), sp.Name, DNS1123LabelErrorMsg))
+ if msgs := validation.IsDNS1123Label(sp.Name); len(msgs) != 0 {
+ for i := range msgs {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), sp.Name, msgs[i]))
+ }
} else if allNames.Has(sp.Name) {
allErrs = append(allErrs, field.Duplicate(fldPath.Child("name"), sp.Name))
} else {
@@ -1794,7 +2161,7 @@ func validateServicePort(sp *api.ServicePort, requireName, isHeadlessService boo
}
}
- if !validation.IsValidPortNum(sp.Port) {
+ if !validation.IsValidPortNum(int(sp.Port)) {
allErrs = append(allErrs, field.Invalid(fldPath.Child("port"), sp.Port, PortRangeErrorMsg))
}
@@ -1877,7 +2244,7 @@ func ValidateNonEmptySelector(selectorMap map[string]string, fldPath *field.Path
}
// Validates the given template and ensures that it is in accordance with the desrired selector and replicas.
-func ValidatePodTemplateSpecForRC(template *api.PodTemplateSpec, selectorMap map[string]string, replicas int, fldPath *field.Path) field.ErrorList {
+func ValidatePodTemplateSpecForRC(template *api.PodTemplateSpec, selectorMap map[string]string, replicas int32, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
if template == nil {
allErrs = append(allErrs, field.Required(fldPath, ""))
@@ -1914,7 +2281,7 @@ func ValidateReplicationControllerSpec(spec *api.ReplicationControllerSpec, fldP
// ValidatePodTemplateSpec validates the spec of a pod template
func ValidatePodTemplateSpec(spec *api.PodTemplateSpec, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
- allErrs = append(allErrs, ValidateLabels(spec.Labels, fldPath.Child("labels"))...)
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabels(spec.Labels, fldPath.Child("labels"))...)
allErrs = append(allErrs, ValidateAnnotations(spec.Annotations, fldPath.Child("annotations"))...)
allErrs = append(allErrs, ValidatePodSpecificAnnotations(spec.Annotations, fldPath.Child("annotations"))...)
allErrs = append(allErrs, ValidatePodSpec(&spec.Spec, fldPath.Child("spec"))...)
@@ -1936,9 +2303,51 @@ func ValidateReadOnlyPersistentDisks(volumes []api.Volume, fldPath *field.Path)
return allErrs
}
+// validateTaints tests if given taints have valid data.
+func validateTaints(taints []api.Taint, fldPath *field.Path) field.ErrorList {
+ allErrors := field.ErrorList{}
+ for i, currTaint := range taints {
+ idxPath := fldPath.Index(i)
+ // validate the taint key
+ allErrors = append(allErrors, unversionedvalidation.ValidateLabelName(currTaint.Key, idxPath.Child("key"))...)
+ // validate the taint value
+ if errs := validation.IsValidLabelValue(currTaint.Value); len(errs) != 0 {
+ allErrors = append(allErrors, field.Invalid(idxPath.Child("value"), currTaint.Value, strings.Join(errs, ";")))
+ }
+ // validate the taint effect
+ allErrors = append(allErrors, validateTaintEffect(&currTaint.Effect, false, idxPath.Child("effect"))...)
+ }
+ return allErrors
+}
+
+// ValidateTaintsInNodeAnnotations tests that the serialized taints in Node.Annotations has valid data
+func ValidateTaintsInNodeAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ taints, err := api.GetTaintsFromNodeAnnotations(annotations)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath, api.TaintsAnnotationKey, err.Error()))
+ return allErrs
+ }
+ if len(taints) > 0 {
+ allErrs = append(allErrs, validateTaints(taints, fldPath.Child(api.TaintsAnnotationKey))...)
+ }
+
+ return allErrs
+}
+
+func ValidateNodeSpecificAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
+ if annotations[api.TaintsAnnotationKey] != "" {
+ return ValidateTaintsInNodeAnnotations(annotations, fldPath)
+ }
+ return field.ErrorList{}
+}
+
// ValidateNode tests if required fields in the node are set.
func ValidateNode(node *api.Node) field.ErrorList {
- allErrs := ValidateObjectMeta(&node.ObjectMeta, false, ValidateNodeName, field.NewPath("metadata"))
+ fldPath := field.NewPath("metadata")
+ allErrs := ValidateObjectMeta(&node.ObjectMeta, false, ValidateNodeName, fldPath)
+ allErrs = append(allErrs, ValidateNodeSpecificAnnotations(node.ObjectMeta.Annotations, fldPath.Child("annotations"))...)
// Only validate spec. All status fields are optional and can be updated later.
@@ -1953,7 +2362,9 @@ func ValidateNode(node *api.Node) field.ErrorList {
// ValidateNodeUpdate tests to make sure a node update can be applied. Modifies oldNode.
func ValidateNodeUpdate(node, oldNode *api.Node) field.ErrorList {
- allErrs := ValidateObjectMetaUpdate(&node.ObjectMeta, &oldNode.ObjectMeta, field.NewPath("metadata"))
+ fldPath := field.NewPath("metadata")
+ allErrs := ValidateObjectMetaUpdate(&node.ObjectMeta, &oldNode.ObjectMeta, fldPath)
+ allErrs = append(allErrs, ValidateNodeSpecificAnnotations(node.ObjectMeta.Annotations, fldPath.Child("annotations"))...)
// TODO: Enable the code once we have better api object.status update model. Currently,
// anyone can update node status.
@@ -2001,8 +2412,11 @@ func ValidateNodeUpdate(node, oldNode *api.Node) field.ErrorList {
// Refer to docs/design/resources.md for more details.
func validateResourceName(value string, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
- if !validation.IsQualifiedName(value) {
- return append(allErrs, field.Invalid(fldPath, value, qualifiedNameErrorMsg))
+ for _, msg := range validation.IsQualifiedName(value) {
+ allErrs = append(allErrs, field.Invalid(fldPath, value, msg))
+ }
+ if len(allErrs) != 0 {
+ return allErrs
}
if len(strings.Split(value, "/")) == 1 {
@@ -2041,8 +2455,11 @@ func validateResourceQuotaResourceName(value string, fldPath *field.Path) field.
// Validate limit range types
func validateLimitRangeTypeName(value string, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
- if !validation.IsQualifiedName(value) {
- return append(allErrs, field.Invalid(fldPath, value, qualifiedNameErrorMsg))
+ for _, msg := range validation.IsQualifiedName(value) {
+ allErrs = append(allErrs, field.Invalid(fldPath, value, msg))
+ }
+ if len(allErrs) != 0 {
+ return allErrs
}
if len(strings.Split(value, "/")) == 1 {
@@ -2273,7 +2690,7 @@ func ValidateSecret(secret *api.Secret) field.ErrorList {
if _, exists := secret.Data[api.TLSPrivateKeyKey]; !exists {
allErrs = append(allErrs, field.Required(dataPath.Key(api.TLSPrivateKeyKey), ""))
}
- // TODO: Verify that the key matches the cert.
+ // TODO: Verify that the key matches the cert.
default:
// no-op
}
@@ -2298,9 +2715,7 @@ func ValidateSecretUpdate(newSecret, oldSecret *api.Secret) field.ErrorList {
// ValidateConfigMapName can be used to check whether the given ConfigMap name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
-func ValidateConfigMapName(name string, prefix bool) (bool, string) {
- return NameIsDNSSubdomain(name, prefix)
-}
+var ValidateConfigMapName = NameIsDNSSubdomain
// ValidateConfigMap tests whether required fields in the ConfigMap are set.
func ValidateConfigMap(cfg *api.ConfigMap) field.ErrorList {
@@ -2342,6 +2757,7 @@ func validateBasicResource(quantity resource.Quantity, fldPath *field.Path) fiel
func ValidateResourceRequirements(requirements *api.ResourceRequirements, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
limPath := fldPath.Child("limits")
+ reqPath := fldPath.Child("requests")
for resourceName, quantity := range requirements.Limits {
fldPath := limPath.Key(string(resourceName))
// Validate resource name.
@@ -2352,12 +2768,14 @@ func ValidateResourceRequirements(requirements *api.ResourceRequirements, fldPat
// Check that request <= limit.
requestQuantity, exists := requirements.Requests[resourceName]
if exists {
- if quantity.Cmp(requestQuantity) < 0 {
+ // For GPUs, require that no request be set.
+ if resourceName == api.ResourceNvidiaGPU {
+ allErrs = append(allErrs, field.Invalid(reqPath, requestQuantity.String(), "cannot be set"))
+ } else if quantity.Cmp(requestQuantity) < 0 {
allErrs = append(allErrs, field.Invalid(fldPath, quantity.String(), "must be greater than or equal to request"))
}
}
}
- reqPath := fldPath.Child("requests")
for resourceName, quantity := range requirements.Requests {
fldPath := reqPath.Key(string(resourceName))
// Validate resource name.
@@ -2509,8 +2927,11 @@ func ValidateNamespace(namespace *api.Namespace) field.ErrorList {
// Validate finalizer names
func validateFinalizerName(stringValue string, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
- if !validation.IsQualifiedName(stringValue) {
- return append(allErrs, field.Invalid(fldPath, stringValue, qualifiedNameErrorMsg))
+ for _, msg := range validation.IsQualifiedName(stringValue) {
+ allErrs = append(allErrs, field.Invalid(fldPath, stringValue, msg))
+ }
+ if len(allErrs) != 0 {
+ return allErrs
}
if len(strings.Split(stringValue, "/")) == 1 {
@@ -2587,6 +3008,9 @@ func validateEndpointSubsets(subsets []api.EndpointSubset, fldPath *field.Path)
for addr := range ss.Addresses {
allErrs = append(allErrs, validateEndpointAddress(&ss.Addresses[addr], idxPath.Child("addresses").Index(addr))...)
}
+ for addr := range ss.NotReadyAddresses {
+ allErrs = append(allErrs, validateEndpointAddress(&ss.NotReadyAddresses[addr], idxPath.Child("notReadyAddresses").Index(addr))...)
+ }
for port := range ss.Ports {
allErrs = append(allErrs, validateEndpointPort(&ss.Ports[port], len(ss.Ports) > 1, idxPath.Child("ports").Index(port))...)
}
@@ -2597,8 +3021,15 @@ func validateEndpointSubsets(subsets []api.EndpointSubset, fldPath *field.Path)
func validateEndpointAddress(address *api.EndpointAddress, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
- if !validation.IsValidIPv4(address.IP) {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("ip"), address.IP, "must be a valid IPv4 address"))
+ if !validation.IsValidIP(address.IP) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("ip"), address.IP, "must be a valid IP address"))
+ }
+ if len(address.Hostname) > 0 {
+ for _, msg := range validation.IsDNS1123Label(address.Hostname) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("hostname"), address.Hostname, msg))
+ }
+ }
+ if len(allErrs) > 0 {
return allErrs
}
return validateIpIsNotLinkLocalOrLoopback(address.IP, fldPath.Child("ip"))
@@ -2630,11 +3061,11 @@ func validateEndpointPort(port *api.EndpointPort, requireName bool, fldPath *fie
if requireName && len(port.Name) == 0 {
allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
} else if len(port.Name) != 0 {
- if !validation.IsDNS1123Label(port.Name) {
- allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), port.Name, DNS1123LabelErrorMsg))
+ for _, msg := range validation.IsDNS1123Label(port.Name) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), port.Name, msg))
}
}
- if !validation.IsValidPortNum(port.Port) {
+ if !validation.IsValidPortNum(int(port.Port)) {
allErrs = append(allErrs, field.Invalid(fldPath.Child("port"), port.Port, PortRangeErrorMsg))
}
if len(port.Protocol) == 0 {
@@ -2705,8 +3136,8 @@ func ValidateLoadBalancerStatus(status *api.LoadBalancerStatus, fldPath *field.P
}
}
if len(ingress.Hostname) > 0 {
- if valid, errMsg := NameIsDNSSubdomain(ingress.Hostname, false); !valid {
- allErrs = append(allErrs, field.Invalid(idxPath.Child("hostname"), ingress.Hostname, errMsg))
+ for _, msg := range validation.IsDNS1123Subdomain(ingress.Hostname) {
+ allErrs = append(allErrs, field.Invalid(idxPath.Child("hostname"), ingress.Hostname, msg))
}
if isIP := (net.ParseIP(ingress.Hostname) != nil); isIP {
allErrs = append(allErrs, field.Invalid(idxPath.Child("hostname"), ingress.Hostname, "must be a DNS name, not an IP address"))
@@ -2727,7 +3158,7 @@ func isValidHostnamesMap(serializedPodHostNames string) bool {
}
for ip, hostRecord := range podHostNames {
- if !validation.IsDNS1123Label(hostRecord.HostName) {
+ if len(validation.IsDNS1123Label(hostRecord.HostName)) != 0 {
return false
}
if net.ParseIP(ip) == nil {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/doc.go b/vendor/k8s.io/kubernetes/pkg/apimachinery/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/doc.go
rename to vendor/k8s.io/kubernetes/pkg/apimachinery/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go b/vendor/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go
rename to vendor/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go
index 8903fd3a5ce15b44c739bf531140ce68d74effa6..c418de3b05b45a8eeb5fa44f521a295c98e535f5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go
+++ b/vendor/k8s.io/kubernetes/pkg/apimachinery/registered/registered.go
@@ -35,6 +35,10 @@ var (
// registeredGroupVersions stores all API group versions for which RegisterGroup is called.
registeredVersions = map[unversioned.GroupVersion]struct{}{}
+ // thirdPartyGroupVersions are API versions which are dynamically
+ // registered (and unregistered) via API calls to the apiserver
+ thirdPartyGroupVersions []unversioned.GroupVersion
+
// enabledVersions represents all enabled API versions. It should be a
// subset of registeredVersions. Please call EnableVersions() to add
// enabled versions.
@@ -158,6 +162,60 @@ func IsRegistered(group string) bool {
return found
}
+// IsRegisteredVersion returns if a version is registered.
+func IsRegisteredVersion(v unversioned.GroupVersion) bool {
+ _, found := registeredVersions[v]
+ return found
+}
+
+// RegisteredGroupVersions returns all registered group versions.
+func RegisteredGroupVersions() []unversioned.GroupVersion {
+ ret := []unversioned.GroupVersion{}
+ for groupVersion := range registeredVersions {
+ ret = append(ret, groupVersion)
+ }
+ return ret
+}
+
+// IsThirdPartyAPIGroupVersion returns true if the api version is a user-registered group/version.
+func IsThirdPartyAPIGroupVersion(gv unversioned.GroupVersion) bool {
+ for ix := range thirdPartyGroupVersions {
+ if thirdPartyGroupVersions[ix] == gv {
+ return true
+ }
+ }
+ return false
+}
+
+// AddThirdPartyAPIGroupVersions sets the list of third party versions,
+// registers them in the API machinery and enables them.
+// Skips GroupVersions that are already registered.
+// Returns the list of GroupVersions that were skipped.
+func AddThirdPartyAPIGroupVersions(gvs ...unversioned.GroupVersion) []unversioned.GroupVersion {
+ filteredGVs := []unversioned.GroupVersion{}
+ skippedGVs := []unversioned.GroupVersion{}
+ for ix := range gvs {
+ if !IsRegisteredVersion(gvs[ix]) {
+ filteredGVs = append(filteredGVs, gvs[ix])
+ } else {
+ glog.V(3).Infof("Skipping %s, because its already registered", gvs[ix].String())
+ skippedGVs = append(skippedGVs, gvs[ix])
+ }
+ }
+ if len(filteredGVs) == 0 {
+ return skippedGVs
+ }
+ RegisterVersions(filteredGVs)
+ EnableVersions(filteredGVs...)
+ next := make([]unversioned.GroupVersion, len(gvs))
+ for ix := range filteredGVs {
+ next[ix] = filteredGVs[ix]
+ }
+ thirdPartyGroupVersions = next
+
+ return skippedGVs
+}
+
// TODO: This is an expedient function, because we don't check if a Group is
// supported throughout the code base. We will abandon this function and
// checking the error returned by the Group() function.
@@ -181,9 +239,13 @@ func GroupOrDie(group string) *apimachinery.GroupMeta {
// all other groups alphabetical.
func RESTMapper(versionPatterns ...unversioned.GroupVersion) meta.RESTMapper {
unionMapper := meta.MultiRESTMapper{}
+ unionedGroups := sets.NewString()
for enabledVersion := range enabledVersions {
- groupMeta := groupMetaMap[enabledVersion.Group]
- unionMapper = append(unionMapper, groupMeta.RESTMapper)
+ if !unionedGroups.Has(enabledVersion.Group) {
+ unionedGroups.Insert(enabledVersion.Group)
+ groupMeta := groupMetaMap[enabledVersion.Group]
+ unionMapper = append(unionMapper, groupMeta.RESTMapper)
+ }
}
if len(versionPatterns) != 0 {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/types.go b/vendor/k8s.io/kubernetes/pkg/apimachinery/types.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apimachinery/types.go
rename to vendor/k8s.io/kubernetes/pkg/apimachinery/types.go
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a2135c6a990f47598790c137ba8d13608a7e8f4
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/deep_copy_generated.go
@@ -0,0 +1,117 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package apps
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_apps_PetSet,
+ DeepCopy_apps_PetSetList,
+ DeepCopy_apps_PetSetSpec,
+ DeepCopy_apps_PetSetStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_apps_PetSet(in PetSet, out *PetSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_apps_PetSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_apps_PetSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_apps_PetSetList(in PetSetList, out *PetSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PetSet, len(in))
+ for i := range in {
+ if err := DeepCopy_apps_PetSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_apps_PetSetSpec(in PetSetSpec, out *PetSetSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := api.DeepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ if in.VolumeClaimTemplates != nil {
+ in, out := in.VolumeClaimTemplates, &out.VolumeClaimTemplates
+ *out = make([]api.PersistentVolumeClaim, len(in))
+ for i := range in {
+ if err := api.DeepCopy_api_PersistentVolumeClaim(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeClaimTemplates = nil
+ }
+ out.ServiceName = in.ServiceName
+ return nil
+}
+
+func DeepCopy_apps_PetSetStatus(in PetSetStatus, out *PetSetStatus, c *conversion.Cloner) error {
+ if in.ObservedGeneration != nil {
+ in, out := in.ObservedGeneration, &out.ObservedGeneration
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ObservedGeneration = nil
+ }
+ out.Replicas = in.Replicas
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/install/install.go
new file mode 100644
index 0000000000000000000000000000000000000000..b4d9011d37fd825c0e86e4e3406350e0e87e5ee3
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/install/install.go
@@ -0,0 +1,125 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 install installs the apps API group, making it available as
+// an option to all of the API encoding/decoding machinery.
+package install
+
+import (
+ "fmt"
+
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apimachinery"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/apis/apps/v1alpha1"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/sets"
+)
+
+const importPrefix = "k8s.io/kubernetes/pkg/apis/apps"
+
+var accessor = meta.NewAccessor()
+
+// availableVersions lists all known external versions for this group from most preferred to least preferred
+var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
+
+func init() {
+ registered.RegisterVersions(availableVersions)
+ externalVersions := []unversioned.GroupVersion{}
+ for _, v := range availableVersions {
+ if registered.IsAllowedVersion(v) {
+ externalVersions = append(externalVersions, v)
+ }
+ }
+ if len(externalVersions) == 0 {
+ glog.V(4).Infof("No version is registered for group %v", apps.GroupName)
+ return
+ }
+
+ if err := registered.EnableVersions(externalVersions...); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+ if err := enableVersions(externalVersions); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+}
+
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+ addVersionsToScheme(externalVersions...)
+ preferredExternalVersion := externalVersions[0]
+
+ groupMeta := apimachinery.GroupMeta{
+ GroupVersion: preferredExternalVersion,
+ GroupVersions: externalVersions,
+ RESTMapper: newRESTMapper(externalVersions),
+ SelfLinker: runtime.SelfLinker(accessor),
+ InterfacesFor: interfacesFor,
+ }
+
+ if err := registered.RegisterGroup(groupMeta); err != nil {
+ return err
+ }
+ api.RegisterRESTMapper(groupMeta.RESTMapper)
+ return nil
+}
+
+func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
+ // the list of kinds that are scoped at the root of the api hierarchy
+ // if a kind is not enumerated here, it is assumed to have a namespace scope
+ rootScoped := sets.NewString()
+
+ ignoredKinds := sets.NewString()
+
+ return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
+}
+
+// interfacesFor returns the default Codec and ResourceVersioner for a given version
+// string, or an error if the version is not known.
+func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+ switch version {
+ case v1alpha1.SchemeGroupVersion:
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: accessor,
+ }, nil
+ default:
+ g, _ := registered.Group(apps.GroupName)
+ return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+ }
+}
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+ // add the internal version to Scheme
+ apps.AddToScheme(api.Scheme)
+ // add the enabled external versions to Scheme
+ for _, v := range externalVersions {
+ if !registered.IsEnabledVersion(v) {
+ glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+ continue
+ }
+ switch v {
+ case v1alpha1.SchemeGroupVersion:
+ v1alpha1.AddToScheme(api.Scheme)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/register.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/register.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/apps/register.go
index 29ad86a09f37581bddb52f291e2db0553d75ee34..dd5b9a900e1f317ae1ad8ac97bdaee31a25f9613 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/register.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,9 +14,10 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package metrics
+package apps
import (
+ "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/runtime"
)
@@ -27,7 +28,7 @@ func AddToScheme(scheme *runtime.Scheme) {
}
// GroupName is the group name use in this package
-const GroupName = "metrics"
+const GroupName = "apps"
// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
@@ -46,10 +47,8 @@ func Resource(resource string) unversioned.GroupResource {
func addKnownTypes(scheme *runtime.Scheme) {
// TODO this will get cleaned up with the scheme types are fixed
scheme.AddKnownTypes(SchemeGroupVersion,
- &RawNode{},
- &RawPod{},
+ &PetSet{},
+ &PetSetList{},
+ &api.ListOptions{},
)
}
-
-func (obj *RawNode) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *RawPod) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..a084509225af6d6cd393395217ef20e2d0bb00a7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/types.generated.go
@@ -0,0 +1,1634 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package apps
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_api "k8s.io/kubernetes/pkg/api"
+ pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_api.ObjectMeta
+ var v1 pkg4_resource.Quantity
+ var v2 pkg1_unversioned.TypeMeta
+ var v3 pkg3_types.UID
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
+ }
+}
+
+func (x *PetSet) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSet) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = PetSetSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = PetSetStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = PetSetSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = PetSetStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Replicas != 0
+ yyq2[1] = x.Selector != nil
+ yyq2[3] = len(x.VolumeClaimTemplates) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy10 := &x.Template
+ yy10.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.Template
+ yy12.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.VolumeClaimTemplates == nil {
+ r.EncodeNil()
+ } else {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ h.encSliceapi_PersistentVolumeClaim(([]pkg2_api.PersistentVolumeClaim)(x.VolumeClaimTemplates), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumeClaimTemplates"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumeClaimTemplates == nil {
+ r.EncodeNil()
+ } else {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.encSliceapi_PersistentVolumeClaim(([]pkg2_api.PersistentVolumeClaim)(x.VolumeClaimTemplates), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_api.PodTemplateSpec{}
+ } else {
+ yyv7 := &x.Template
+ yyv7.CodecDecodeSelf(d)
+ }
+ case "volumeClaimTemplates":
+ if r.TryDecodeAsNil() {
+ x.VolumeClaimTemplates = nil
+ } else {
+ yyv8 := &x.VolumeClaimTemplates
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decSliceapi_PersistentVolumeClaim((*[]pkg2_api.PersistentVolumeClaim)(yyv8), d)
+ }
+ }
+ case "serviceName":
+ if r.TryDecodeAsNil() {
+ x.ServiceName = ""
+ } else {
+ x.ServiceName = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_api.PodTemplateSpec{}
+ } else {
+ yyv15 := &x.Template
+ yyv15.CodecDecodeSelf(d)
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumeClaimTemplates = nil
+ } else {
+ yyv16 := &x.VolumeClaimTemplates
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else {
+ h.decSliceapi_PersistentVolumeClaim((*[]pkg2_api.PersistentVolumeClaim)(yyv16), d)
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServiceName = ""
+ } else {
+ x.ServiceName = string(r.DecodeString())
+ }
+ for {
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj11-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.ObservedGeneration != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.ObservedGeneration
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.ObservedGeneration
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "observedGeneration":
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePetSet(([]PetSet)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePetSet(([]PetSet)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePetSet((*[]PetSet)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePetSet((*[]PetSet)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceapi_PersistentVolumeClaim(v []pkg2_api.PersistentVolumeClaim, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceapi_PersistentVolumeClaim(v *[]pkg2_api.PersistentVolumeClaim, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []pkg2_api.PersistentVolumeClaim{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]pkg2_api.PersistentVolumeClaim, yyrl1)
+ }
+ } else {
+ yyv1 = make([]pkg2_api.PersistentVolumeClaim, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.PersistentVolumeClaim{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, pkg2_api.PersistentVolumeClaim{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.PersistentVolumeClaim{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, pkg2_api.PersistentVolumeClaim{}) // var yyz1 pkg2_api.PersistentVolumeClaim
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.PersistentVolumeClaim{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []pkg2_api.PersistentVolumeClaim{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSlicePetSet(v []PetSet, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePetSet(v *[]PetSet, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PetSet{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 744)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PetSet, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PetSet, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PetSet{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PetSet{}) // var yyz1 PetSet
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PetSet{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/types.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..87019c4566eedba615bf1150779d5d6ae289cd1b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/types.go
@@ -0,0 +1,94 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 apps
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+)
+
+// PetSet 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 PetSet guarantees that a given network identity will always
+// map to the same storage identity. PetSet is currently in alpha and
+// and subject to change without notice.
+type PetSet struct {
+ unversioned.TypeMeta `json:",inline"`
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Spec defines the desired identities of pets in this set.
+ Spec PetSetSpec `json:"spec,omitempty"`
+
+ // Status is the current status of Pets in this PetSet. This data
+ // may be out of date by some window of time.
+ Status PetSetStatus `json:"status,omitempty"`
+}
+
+// A PetSetSpec is the specification of a PetSet.
+type PetSetSpec struct {
+ // 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.
+ // TODO: Consider a rename of this field.
+ Replicas int `json:"replicas,omitempty"`
+
+ // Selector is a label query over pods that should match the replica count.
+ // If empty, defaulted to labels on the pod template.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *unversioned.LabelSelector `json:"selector,omitempty"`
+
+ // Template is the object that describes the pod that will be created if
+ // insufficient replicas are detected. Each pod stamped out by the PetSet
+ // will fulfill this Template, but have a unique identity from the rest
+ // of the PetSet.
+ Template api.PodTemplateSpec `json:"template"`
+
+ // VolumeClaimTemplates is a list of claims that pets are allowed to reference.
+ // The PetSet controller is responsible for mapping network identities to
+ // claims in a way that maintains the identity of a pet. 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.
+ // TODO: Define the behavior if a claim already exists with the same name.
+ VolumeClaimTemplates []api.PersistentVolumeClaim `json:"volumeClaimTemplates,omitempty"`
+
+ // ServiceName is the name of the service that governs this PetSet.
+ // This service must exist before the PetSet, and is responsible for
+ // the network identity of the set. Pets get DNS/hostnames that follow the
+ // pattern: pet-specific-string.serviceName.default.svc.cluster.local
+ // where "pet-specific-string" is managed by the PetSet controller.
+ ServiceName string `json:"serviceName"`
+}
+
+// PetSetStatus represents the current state of a PetSet.
+type PetSetStatus struct {
+ // most recent generation observed by this autoscaler.
+ ObservedGeneration *int64 `json:"observedGeneration,omitempty"`
+
+ // Replicas is the number of actual replicas.
+ Replicas int `json:"replicas"`
+}
+
+// PetSetList is a collection of PetSets.
+type PetSetList struct {
+ unversioned.TypeMeta `json:",inline"`
+ unversioned.ListMeta `json:"metadata,omitempty"`
+ Items []PetSet `json:"items"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion.go
new file mode 100644
index 0000000000000000000000000000000000000000..48f1f2b4d3276f42da82d5e60a9cf397088f2bb4
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion.go
@@ -0,0 +1,118 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addConversionFuncs(scheme *runtime.Scheme) {
+ // Add non-generated conversion functions to handle the *int32 -> int
+ // conversion. A pointer is useful in the versioned type so we can default
+ // it, but a plain int32 is more convenient in the internal type. These
+ // functions are the same as the autogenerated ones in every other way.
+ err := scheme.AddConversionFuncs(
+ Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec,
+ Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec,
+ )
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+
+ err = api.Scheme.AddFieldLabelConversionFunc("apps/v1alpha1", "PetSet",
+ func(label, value string) (string, string, error) {
+ switch label {
+ case "metadata.name", "metadata.namespace", "status.successful":
+ return label, value, nil
+ default:
+ return "", "", fmt.Errorf("field label not supported: %s", label)
+ }
+ })
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec(in *PetSetSpec, out *apps.PetSetSpec, s conversion.Scope) error {
+ if in.Replicas != nil {
+ out.Replicas = int(*in.Replicas)
+ }
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := s.Convert(&in.Template, &out.Template, 0); err != nil {
+ return err
+ }
+ if in.VolumeClaimTemplates != nil {
+ in, out := &in.VolumeClaimTemplates, &out.VolumeClaimTemplates
+ *out = make([]api.PersistentVolumeClaim, len(*in))
+ for i := range *in {
+ if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeClaimTemplates = nil
+ }
+ out.ServiceName = in.ServiceName
+ return nil
+}
+
+func Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec(in *apps.PetSetSpec, out *PetSetSpec, s conversion.Scope) error {
+ out.Replicas = new(int32)
+ *out.Replicas = int32(in.Replicas)
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := s.Convert(&in.Template, &out.Template, 0); err != nil {
+ return err
+ }
+ if in.VolumeClaimTemplates != nil {
+ in, out := &in.VolumeClaimTemplates, &out.VolumeClaimTemplates
+ *out = make([]v1.PersistentVolumeClaim, len(*in))
+ for i := range *in {
+ if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeClaimTemplates = nil
+ }
+ out.ServiceName = in.ServiceName
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfd6ce44b2751f80190bb9070b044fb43e4239f9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/conversion_generated.go
@@ -0,0 +1,156 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ apps "k8s.io/kubernetes/pkg/apis/apps"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1alpha1_PetSet_To_apps_PetSet,
+ Convert_apps_PetSet_To_v1alpha1_PetSet,
+ Convert_v1alpha1_PetSetList_To_apps_PetSetList,
+ Convert_apps_PetSetList_To_v1alpha1_PetSetList,
+ Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec,
+ Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec,
+ Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus,
+ Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1alpha1_PetSet_To_apps_PetSet(in *PetSet, out *apps.PetSet, s conversion.Scope) error {
+ SetDefaults_PetSet(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1alpha1_PetSetSpec_To_apps_PetSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1alpha1_PetSet_To_apps_PetSet(in *PetSet, out *apps.PetSet, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PetSet_To_apps_PetSet(in, out, s)
+}
+
+func autoConvert_apps_PetSet_To_v1alpha1_PetSet(in *apps.PetSet, out *PetSet, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_apps_PetSetSpec_To_v1alpha1_PetSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_apps_PetSet_To_v1alpha1_PetSet(in *apps.PetSet, out *PetSet, s conversion.Scope) error {
+ return autoConvert_apps_PetSet_To_v1alpha1_PetSet(in, out, s)
+}
+
+func autoConvert_v1alpha1_PetSetList_To_apps_PetSetList(in *PetSetList, out *apps.PetSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]apps.PetSet, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_PetSet_To_apps_PetSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_PetSetList_To_apps_PetSetList(in *PetSetList, out *apps.PetSetList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PetSetList_To_apps_PetSetList(in, out, s)
+}
+
+func autoConvert_apps_PetSetList_To_v1alpha1_PetSetList(in *apps.PetSetList, out *PetSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PetSet, len(*in))
+ for i := range *in {
+ if err := Convert_apps_PetSet_To_v1alpha1_PetSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_apps_PetSetList_To_v1alpha1_PetSetList(in *apps.PetSetList, out *PetSetList, s conversion.Scope) error {
+ return autoConvert_apps_PetSetList_To_v1alpha1_PetSetList(in, out, s)
+}
+
+func autoConvert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in *PetSetStatus, out *apps.PetSetStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = int(in.Replicas)
+ return nil
+}
+
+func Convert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in *PetSetStatus, out *apps.PetSetStatus, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PetSetStatus_To_apps_PetSetStatus(in, out, s)
+}
+
+func autoConvert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in *apps.PetSetStatus, out *PetSetStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = int32(in.Replicas)
+ return nil
+}
+
+func Convert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in *apps.PetSetStatus, out *PetSetStatus, s conversion.Scope) error {
+ return autoConvert_apps_PetSetStatus_To_v1alpha1_PetSetStatus(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..6e51cacbc25cc9c8eb3bd80bd3727246b50c60df
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/deep_copy_generated.go
@@ -0,0 +1,124 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1alpha1_PetSet,
+ DeepCopy_v1alpha1_PetSetList,
+ DeepCopy_v1alpha1_PetSetSpec,
+ DeepCopy_v1alpha1_PetSetStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1alpha1_PetSet(in PetSet, out *PetSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1alpha1_PetSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1alpha1_PetSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PetSetList(in PetSetList, out *PetSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PetSet, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_PetSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PetSetSpec(in PetSetSpec, out *PetSetSpec, c *conversion.Cloner) error {
+ if in.Replicas != nil {
+ in, out := in.Replicas, &out.Replicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Replicas = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ if in.VolumeClaimTemplates != nil {
+ in, out := in.VolumeClaimTemplates, &out.VolumeClaimTemplates
+ *out = make([]v1.PersistentVolumeClaim, len(in))
+ for i := range in {
+ if err := v1.DeepCopy_v1_PersistentVolumeClaim(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.VolumeClaimTemplates = nil
+ }
+ out.ServiceName = in.ServiceName
+ return nil
+}
+
+func DeepCopy_v1alpha1_PetSetStatus(in PetSetStatus, out *PetSetStatus, c *conversion.Cloner) error {
+ if in.ObservedGeneration != nil {
+ in, out := in.ObservedGeneration, &out.ObservedGeneration
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ObservedGeneration = nil
+ }
+ out.Replicas = in.Replicas
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..e41028138afd80e07e39fd74e6cc3b0eacf4fee5
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/defaults.go
@@ -0,0 +1,46 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_PetSet,
+ )
+}
+
+func SetDefaults_PetSet(obj *PetSet) {
+ labels := obj.Spec.Template.Labels
+ if labels != nil {
+ if obj.Spec.Selector == nil {
+ obj.Spec.Selector = &unversioned.LabelSelector{
+ MatchLabels: labels,
+ }
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+ if obj.Spec.Replicas == nil {
+ obj.Spec.Replicas = new(int32)
+ *obj.Spec.Replicas = 1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..65a03a2093dc4d92ed81d9112ce200244fbc8a24
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1alpha1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..88f1bcd40735410f1066fa9687de61dd39cc18a8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.pb.go
@@ -0,0 +1,969 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1alpha1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.proto
+
+ It has these top-level messages:
+ PetSet
+ PetSetList
+ PetSetSpec
+ PetSetStatus
+*/
+package v1alpha1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *PetSet) Reset() { *m = PetSet{} }
+func (m *PetSet) String() string { return proto.CompactTextString(m) }
+func (*PetSet) ProtoMessage() {}
+
+func (m *PetSetList) Reset() { *m = PetSetList{} }
+func (m *PetSetList) String() string { return proto.CompactTextString(m) }
+func (*PetSetList) ProtoMessage() {}
+
+func (m *PetSetSpec) Reset() { *m = PetSetSpec{} }
+func (m *PetSetSpec) String() string { return proto.CompactTextString(m) }
+func (*PetSetSpec) ProtoMessage() {}
+
+func (m *PetSetStatus) Reset() { *m = PetSetStatus{} }
+func (m *PetSetStatus) String() string { return proto.CompactTextString(m) }
+func (*PetSetStatus) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*PetSet)(nil), "k8s.io.kubernetes.pkg.apis.apps.v1alpha1.PetSet")
+ proto.RegisterType((*PetSetList)(nil), "k8s.io.kubernetes.pkg.apis.apps.v1alpha1.PetSetList")
+ proto.RegisterType((*PetSetSpec)(nil), "k8s.io.kubernetes.pkg.apis.apps.v1alpha1.PetSetSpec")
+ proto.RegisterType((*PetSetStatus)(nil), "k8s.io.kubernetes.pkg.apis.apps.v1alpha1.PetSetStatus")
+}
+func (m *PetSet) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PetSet) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *PetSetList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PetSetList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n4, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PetSetSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PetSetSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n5, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n6, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.VolumeClaimTemplates) > 0 {
+ for _, msg := range m.VolumeClaimTemplates {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ServiceName)))
+ i += copy(data[i:], m.ServiceName)
+ return i, nil
+}
+
+func (m *PetSetStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PetSetStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ObservedGeneration))
+ }
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *PetSet) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PetSetList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PetSetSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ n += 1 + sovGenerated(uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.VolumeClaimTemplates) > 0 {
+ for _, e := range m.VolumeClaimTemplates {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.ServiceName)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PetSetStatus) Size() (n int) {
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
+ }
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *PetSet) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PetSet: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PetSet: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PetSetList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PetSetList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PetSetList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PetSet{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PetSetSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PetSetSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PetSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Replicas = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &k8s_io_kubernetes_pkg_api_unversioned.LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, k8s_io_kubernetes_pkg_api_v1.PersistentVolumeClaim{})
+ if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServiceName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PetSetStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PetSetStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PetSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ObservedGeneration = &v
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..3bf7e6936aefe2391e6e3b182cd4690ccd80289a
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/generated.proto
@@ -0,0 +1,102 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.apps.v1alpha1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1alpha1";
+
+// PetSet 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 PetSet guarantees that a given network identity will always
+// map to the same storage identity. PetSet is currently in alpha
+// and subject to change without notice.
+message PetSet {
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec defines the desired identities of pets in this set.
+ optional PetSetSpec spec = 2;
+
+ // Status is the current status of Pets in this PetSet. This data
+ // may be out of date by some window of time.
+ optional PetSetStatus status = 3;
+}
+
+// PetSetList is a collection of PetSets.
+message PetSetList {
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ repeated PetSet items = 2;
+}
+
+// A PetSetSpec is the specification of a PetSet.
+message PetSetSpec {
+ // 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.
+ // TODO: Consider a rename of this field.
+ optional int32 replicas = 1;
+
+ // Selector is a label query over pods that should match the replica count.
+ // If empty, defaulted to labels on the pod template.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional k8s.io.kubernetes.pkg.api.unversioned.LabelSelector selector = 2;
+
+ // Template is the object that describes the pod that will be created if
+ // insufficient replicas are detected. Each pod stamped out by the PetSet
+ // will fulfill this Template, but have a unique identity from the rest
+ // of the PetSet.
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 3;
+
+ // VolumeClaimTemplates is a list of claims that pets are allowed to reference.
+ // The PetSet controller is responsible for mapping network identities to
+ // claims in a way that maintains the identity of a pet. 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.
+ // TODO: Define the behavior if a claim already exists with the same name.
+ repeated k8s.io.kubernetes.pkg.api.v1.PersistentVolumeClaim volumeClaimTemplates = 4;
+
+ // ServiceName is the name of the service that governs this PetSet.
+ // This service must exist before the PetSet, and is responsible for
+ // the network identity of the set. Pets get DNS/hostnames that follow the
+ // pattern: pet-specific-string.serviceName.default.svc.cluster.local
+ // where "pet-specific-string" is managed by the PetSet controller.
+ optional string serviceName = 5;
+}
+
+// PetSetStatus represents the current state of a PetSet.
+message PetSetStatus {
+ // most recent generation observed by this autoscaler.
+ optional int64 observedGeneration = 1;
+
+ // Replicas is the number of actual replicas.
+ optional int32 replicas = 2;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..9ab37dfb0df8a7cc1cf613169812b51cf78989a7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/register.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "apps"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1alpha1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &PetSet{},
+ &PetSetList{},
+ &v1.ListOptions{},
+ &v1.DeleteOptions{},
+ )
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
+
+func (obj *PetSet) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
+func (obj *PetSetList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..a544c4e6ad08269c3e9fd8813decce33465dc734
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.generated.go
@@ -0,0 +1,1664 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v1alpha1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg4_resource.Quantity
+ var v1 pkg1_unversioned.TypeMeta
+ var v2 pkg2_v1.ObjectMeta
+ var v3 pkg3_types.UID
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
+ }
+}
+
+func (x *PetSet) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSet) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = PetSetSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = PetSetStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = PetSetSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = PetSetStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Replicas != nil
+ yyq2[1] = x.Selector != nil
+ yyq2[3] = len(x.VolumeClaimTemplates) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Replicas == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.Replicas
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Replicas == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.Replicas
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy12 := &x.Template
+ yy12.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy14 := &x.Template
+ yy14.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.VolumeClaimTemplates == nil {
+ r.EncodeNil()
+ } else {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ h.encSlicev1_PersistentVolumeClaim(([]pkg2_v1.PersistentVolumeClaim)(x.VolumeClaimTemplates), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumeClaimTemplates"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.VolumeClaimTemplates == nil {
+ r.EncodeNil()
+ } else {
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ h.encSlicev1_PersistentVolumeClaim(([]pkg2_v1.PersistentVolumeClaim)(x.VolumeClaimTemplates), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ if x.Replicas != nil {
+ x.Replicas = nil
+ }
+ } else {
+ if x.Replicas == nil {
+ x.Replicas = new(int32)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_v1.PodTemplateSpec{}
+ } else {
+ yyv8 := &x.Template
+ yyv8.CodecDecodeSelf(d)
+ }
+ case "volumeClaimTemplates":
+ if r.TryDecodeAsNil() {
+ x.VolumeClaimTemplates = nil
+ } else {
+ yyv9 := &x.VolumeClaimTemplates
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicev1_PersistentVolumeClaim((*[]pkg2_v1.PersistentVolumeClaim)(yyv9), d)
+ }
+ }
+ case "serviceName":
+ if r.TryDecodeAsNil() {
+ x.ServiceName = ""
+ } else {
+ x.ServiceName = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Replicas != nil {
+ x.Replicas = nil
+ }
+ } else {
+ if x.Replicas == nil {
+ x.Replicas = new(int32)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ *((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_v1.PodTemplateSpec{}
+ } else {
+ yyv17 := &x.Template
+ yyv17.CodecDecodeSelf(d)
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.VolumeClaimTemplates = nil
+ } else {
+ yyv18 := &x.VolumeClaimTemplates
+ yym19 := z.DecBinary()
+ _ = yym19
+ if false {
+ } else {
+ h.decSlicev1_PersistentVolumeClaim((*[]pkg2_v1.PersistentVolumeClaim)(yyv18), d)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServiceName = ""
+ } else {
+ x.ServiceName = string(r.DecodeString())
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.ObservedGeneration != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.ObservedGeneration
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.ObservedGeneration
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "observedGeneration":
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PetSetList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePetSet(([]PetSet)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePetSet(([]PetSet)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PetSetList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PetSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePetSet((*[]PetSet)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PetSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePetSet((*[]PetSet)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSlicev1_PersistentVolumeClaim(v []pkg2_v1.PersistentVolumeClaim, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicev1_PersistentVolumeClaim(v *[]pkg2_v1.PersistentVolumeClaim, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []pkg2_v1.PersistentVolumeClaim{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]pkg2_v1.PersistentVolumeClaim, yyrl1)
+ }
+ } else {
+ yyv1 = make([]pkg2_v1.PersistentVolumeClaim, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.PersistentVolumeClaim{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, pkg2_v1.PersistentVolumeClaim{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.PersistentVolumeClaim{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, pkg2_v1.PersistentVolumeClaim{}) // var yyz1 pkg2_v1.PersistentVolumeClaim
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.PersistentVolumeClaim{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []pkg2_v1.PersistentVolumeClaim{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSlicePetSet(v []PetSet, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePetSet(v *[]PetSet, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PetSet{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 768)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PetSet, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PetSet, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PetSet{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PetSet{}) // var yyz1 PetSet
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PetSet{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PetSet{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb0aa48a1d1a41d6a18f07945d0313807d256d9d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types.go
@@ -0,0 +1,94 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+)
+
+// PetSet 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 PetSet guarantees that a given network identity will always
+// map to the same storage identity. PetSet is currently in alpha
+// and subject to change without notice.
+type PetSet struct {
+ unversioned.TypeMeta `json:",inline"`
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Spec defines the desired identities of pets in this set.
+ Spec PetSetSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+
+ // Status is the current status of Pets in this PetSet. This data
+ // may be out of date by some window of time.
+ Status PetSetStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// A PetSetSpec is the specification of a PetSet.
+type PetSetSpec struct {
+ // 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.
+ // TODO: Consider a rename of this field.
+ Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
+
+ // Selector is a label query over pods that should match the replica count.
+ // If empty, defaulted to labels on the pod template.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *unversioned.LabelSelector `json:"selector,omitempty" protobuf:"bytes,2,opt,name=selector"`
+
+ // Template is the object that describes the pod that will be created if
+ // insufficient replicas are detected. Each pod stamped out by the PetSet
+ // will fulfill this Template, but have a unique identity from the rest
+ // of the PetSet.
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,3,opt,name=template"`
+
+ // VolumeClaimTemplates is a list of claims that pets are allowed to reference.
+ // The PetSet controller is responsible for mapping network identities to
+ // claims in a way that maintains the identity of a pet. 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.
+ // TODO: Define the behavior if a claim already exists with the same name.
+ VolumeClaimTemplates []v1.PersistentVolumeClaim `json:"volumeClaimTemplates,omitempty" protobuf:"bytes,4,rep,name=volumeClaimTemplates"`
+
+ // ServiceName is the name of the service that governs this PetSet.
+ // This service must exist before the PetSet, and is responsible for
+ // the network identity of the set. Pets get DNS/hostnames that follow the
+ // pattern: pet-specific-string.serviceName.default.svc.cluster.local
+ // where "pet-specific-string" is managed by the PetSet controller.
+ ServiceName string `json:"serviceName" protobuf:"bytes,5,opt,name=serviceName"`
+}
+
+// PetSetStatus represents the current state of a PetSet.
+type PetSetStatus struct {
+ // most recent generation observed by this autoscaler.
+ ObservedGeneration *int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"`
+
+ // Replicas is the number of actual replicas.
+ Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"`
+}
+
+// PetSetList is a collection of PetSets.
+type PetSetList struct {
+ unversioned.TypeMeta `json:",inline"`
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+ Items []PetSet `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types_swagger_doc_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ce682b4b583b7a2011705bde2b3f6f92e28b82e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/apps/v1alpha1/types_swagger_doc_generated.go
@@ -0,0 +1,71 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+// This file contains a collection of methods that can be used from go-restful to
+// generate Swagger API documentation for its models. Please read this PR for more
+// information on the implementation: https://github.com/emicklei/go-restful/pull/215
+//
+// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if
+// they are on one line! For multiple line or blocks that you want to ignore use ---.
+// Any context after a --- is ignored.
+//
+// Those methods can be generated by using hack/update-generated-swagger-docs.sh
+
+// AUTO-GENERATED FUNCTIONS START HERE
+var map_PetSet = map[string]string{
+ "": "PetSet represents a set of pods with consistent identities. Identities are defined as:\n - Network: A single stable DNS and hostname.\n - Storage: As many VolumeClaims as requested.\nThe PetSet guarantees that a given network identity will always map to the same storage identity. PetSet is currently in alpha and subject to change without notice.",
+ "spec": "Spec defines the desired identities of pets in this set.",
+ "status": "Status is the current status of Pets in this PetSet. This data may be out of date by some window of time.",
+}
+
+func (PetSet) SwaggerDoc() map[string]string {
+ return map_PetSet
+}
+
+var map_PetSetList = map[string]string{
+ "": "PetSetList is a collection of PetSets.",
+}
+
+func (PetSetList) SwaggerDoc() map[string]string {
+ return map_PetSetList
+}
+
+var map_PetSetSpec = map[string]string{
+ "": "A PetSetSpec is the specification of a PetSet.",
+ "replicas": "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.",
+ "selector": "Selector is a label query over pods that should match the replica count. If empty, defaulted to labels on the pod template. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "template": "Template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the PetSet will fulfill this Template, but have a unique identity from the rest of the PetSet.",
+ "volumeClaimTemplates": "VolumeClaimTemplates is a list of claims that pets are allowed to reference. The PetSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pet. 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.",
+ "serviceName": "ServiceName is the name of the service that governs this PetSet. This service must exist before the PetSet, and is responsible for the network identity of the set. Pets get DNS/hostnames that follow the pattern: pet-specific-string.serviceName.default.svc.cluster.local where \"pet-specific-string\" is managed by the PetSet controller.",
+}
+
+func (PetSetSpec) SwaggerDoc() map[string]string {
+ return map_PetSetSpec
+}
+
+var map_PetSetStatus = map[string]string{
+ "": "PetSetStatus represents the current state of a PetSet.",
+ "observedGeneration": "most recent generation observed by this autoscaler.",
+ "replicas": "Replicas is the number of actual replicas.",
+}
+
+func (PetSetStatus) SwaggerDoc() map[string]string {
+ return map_PetSetStatus
+}
+
+// AUTO-GENERATED FUNCTIONS END HERE
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..75ac7281ed242ba2c33b74d3d171c17a5fc78734
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/deep_copy_generated.go
@@ -0,0 +1,91 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package authentication
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_authenticationk8sio_TokenReview,
+ DeepCopy_authenticationk8sio_TokenReviewSpec,
+ DeepCopy_authenticationk8sio_TokenReviewStatus,
+ DeepCopy_authenticationk8sio_UserInfo,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_authenticationk8sio_TokenReview(in TokenReview, out *TokenReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authenticationk8sio_TokenReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authenticationk8sio_TokenReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_authenticationk8sio_TokenReviewSpec(in TokenReviewSpec, out *TokenReviewSpec, c *conversion.Cloner) error {
+ out.Token = in.Token
+ return nil
+}
+
+func DeepCopy_authenticationk8sio_TokenReviewStatus(in TokenReviewStatus, out *TokenReviewStatus, c *conversion.Cloner) error {
+ out.Authenticated = in.Authenticated
+ if err := DeepCopy_authenticationk8sio_UserInfo(in.User, &out.User, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_authenticationk8sio_UserInfo(in UserInfo, out *UserInfo, c *conversion.Cloner) error {
+ out.Username = in.Username
+ out.UID = in.UID
+ if in.Groups != nil {
+ in, out := in.Groups, &out.Groups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Groups = nil
+ }
+ if in.Extra != nil {
+ in, out := in.Extra, &out.Extra
+ *out = make(map[string][]string)
+ for key, val := range in {
+ if newVal, err := c.DeepCopy(val); err != nil {
+ return err
+ } else {
+ (*out)[key] = newVal.([]string)
+ }
+ }
+ } else {
+ out.Extra = nil
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/install/install.go
new file mode 100644
index 0000000000000000000000000000000000000000..29447d217781d4033603a3a5520d899e2c622121
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/install/install.go
@@ -0,0 +1,123 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 install installs the experimental API group, making it available as
+// an option to all of the API encoding/decoding machinery.
+package install
+
+import (
+ "fmt"
+
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apimachinery"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/authentication.k8s.io"
+ "k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/sets"
+)
+
+const importPrefix = "k8s.io/kubernetes/pkg/apis/authentication.k8s.io"
+
+var accessor = meta.NewAccessor()
+
+// availableVersions lists all known external versions for this group from most preferred to least preferred
+var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
+
+func init() {
+ registered.RegisterVersions(availableVersions)
+ externalVersions := []unversioned.GroupVersion{}
+ for _, v := range availableVersions {
+ if registered.IsAllowedVersion(v) {
+ externalVersions = append(externalVersions, v)
+ }
+ }
+ if len(externalVersions) == 0 {
+ glog.V(4).Infof("No version is registered for group %v", authentication.GroupName)
+ return
+ }
+
+ if err := registered.EnableVersions(externalVersions...); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+ if err := enableVersions(externalVersions); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+}
+
+// TODO: enableVersions should be centralized rather than spread in each API
+// group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+ addVersionsToScheme(externalVersions...)
+ preferredExternalVersion := externalVersions[0]
+
+ groupMeta := apimachinery.GroupMeta{
+ GroupVersion: preferredExternalVersion,
+ GroupVersions: externalVersions,
+ RESTMapper: newRESTMapper(externalVersions),
+ SelfLinker: runtime.SelfLinker(accessor),
+ InterfacesFor: interfacesFor,
+ }
+
+ if err := registered.RegisterGroup(groupMeta); err != nil {
+ return err
+ }
+ api.RegisterRESTMapper(groupMeta.RESTMapper)
+ return nil
+}
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+ // add the internal version to Scheme
+ authentication.AddToScheme(api.Scheme)
+ // add the enabled external versions to Scheme
+ for _, v := range externalVersions {
+ if !registered.IsEnabledVersion(v) {
+ glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+ continue
+ }
+ switch v {
+ case v1beta1.SchemeGroupVersion:
+ v1beta1.AddToScheme(api.Scheme)
+ }
+ }
+}
+
+func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
+ rootScoped := sets.NewString("TokenReview")
+ ignoredKinds := sets.NewString()
+ return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
+}
+
+func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+ switch version {
+ case v1beta1.SchemeGroupVersion:
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: accessor,
+ }, nil
+ default:
+ g, _ := registered.Group(authentication.GroupName)
+ return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/register.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..4dda3140fc254f0957429aaddbc81f939d5c61e6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/register.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 authentication
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "authentication.k8s.io"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+}
+
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &TokenReview{},
+ )
+}
+
+func (obj *TokenReview) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..b3b72d653b1bc401e74bcf48aeb079f47f88284b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.generated.go
@@ -0,0 +1,1265 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package authentication
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ "reflect"
+ "runtime"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg1_unversioned.TypeMeta
+ _ = v0
+ }
+}
+
+func (x *TokenReview) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4 := &x.Spec
+ yy4.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.Spec
+ yy6.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy9 := &x.Status
+ yy9.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Status
+ yy11.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReview) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "Spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = TokenReviewSpec{}
+ } else {
+ yyv4 := &x.Spec
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "Status":
+ if r.TryDecodeAsNil() {
+ x.Status = TokenReviewStatus{}
+ } else {
+ yyv5 := &x.Status
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = TokenReviewSpec{}
+ } else {
+ yyv9 := &x.Spec
+ yyv9.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = TokenReviewStatus{}
+ } else {
+ yyv10 := &x.Status
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *TokenReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [1]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(1)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Token))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Token"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Token))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReviewSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "Token":
+ if r.TryDecodeAsNil() {
+ x.Token = ""
+ } else {
+ x.Token = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Token = ""
+ } else {
+ x.Token = string(r.DecodeString())
+ }
+ for {
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj5-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *TokenReviewStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Authenticated))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Authenticated"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Authenticated))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy7 := &x.User
+ yy7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("User"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.User
+ yy9.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReviewStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReviewStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "Authenticated":
+ if r.TryDecodeAsNil() {
+ x.Authenticated = false
+ } else {
+ x.Authenticated = bool(r.DecodeBool())
+ }
+ case "User":
+ if r.TryDecodeAsNil() {
+ x.User = UserInfo{}
+ } else {
+ yyv5 := &x.User
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Authenticated = false
+ } else {
+ x.Authenticated = bool(r.DecodeBool())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.User = UserInfo{}
+ } else {
+ yyv8 := &x.User
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *UserInfo) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 4
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Username))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Username"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Username))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("UID"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Groups == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Groups, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Groups"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Groups == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Groups, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Extra"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *UserInfo) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *UserInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "Username":
+ if r.TryDecodeAsNil() {
+ x.Username = ""
+ } else {
+ x.Username = string(r.DecodeString())
+ }
+ case "UID":
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = string(r.DecodeString())
+ }
+ case "Groups":
+ if r.TryDecodeAsNil() {
+ x.Groups = nil
+ } else {
+ yyv6 := &x.Groups
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "Extra":
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv8 := &x.Extra
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv8), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *UserInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Username = ""
+ } else {
+ x.Username = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Groups = nil
+ } else {
+ yyv13 := &x.Groups
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv13, false, d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv15 := &x.Extra
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv15), d)
+ }
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeMapStart(len(v))
+ for yyk1, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyk1))
+ }
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyv1 == nil {
+ r.EncodeNil()
+ } else {
+ yym3 := z.EncBinary()
+ _ = yym3
+ if false {
+ } else {
+ z.F.EncSliceStringV(yyv1, false, e)
+ }
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyl1 := r.ReadMapStart()
+ yybh1 := z.DecBasicHandle()
+ if yyv1 == nil {
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyv1 = make(map[string][]string, yyrl1)
+ *v = yyv1
+ }
+ var yymk1 string
+ var yymv1 []string
+ var yymg1 bool
+ if yybh1.MapValueReset {
+ yymg1 = true
+ }
+ if yyl1 > 0 {
+ for yyj1 := 0; yyj1 < yyl1; yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv3 := &yymv1
+ yym4 := z.DecBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv3, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } else if yyl1 < 0 {
+ for yyj1 := 0; !r.CheckBreak(); yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv6 := &yymv1
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } // else len==0: TODO: Should we clear map entries?
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) encSlicestring(v []string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyv1))
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicestring(v *[]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 string
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..02ec0d2b2b7a6e8212ac4008987273783a71ebba
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/types.go
@@ -0,0 +1,61 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 authentication
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+)
+
+// TokenReview attempts to authenticate a token to a known user.
+type TokenReview struct {
+ unversioned.TypeMeta
+
+ // Spec holds information about the request being evaluated
+ Spec TokenReviewSpec
+
+ // Status is filled in by the server and indicates whether the request can be authenticated.
+ Status TokenReviewStatus
+}
+
+// TokenReviewSpec is a description of the token authentication request.
+type TokenReviewSpec struct {
+ // Token is the opaque bearer token.
+ Token string
+}
+
+// TokenReviewStatus is the result of the token authentication request.
+type TokenReviewStatus struct {
+ // Authenticated indicates that the token was associated with a known user.
+ Authenticated bool
+ // User is the UserInfo associated with the provided token.
+ User UserInfo
+}
+
+// UserInfo holds the information about the user needed to implement the
+// user.Info interface.
+type UserInfo struct {
+ // The name that uniquely identifies this user among all active users.
+ Username string
+ // 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.
+ UID string
+ // The names of groups this user is a part of.
+ Groups []string
+ // Any additional information provided by the authenticator.
+ Extra map[string][]string
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion.go
similarity index 72%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion.go
index 2a0daee203c49b0fff339496f528a6fc9566ae74..6a8545d1340949338c1b8e319688af9f845d70c7 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,14 +14,15 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
-
package v1beta1
-import api "k8s.io/kubernetes/pkg/api"
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs()
+func addConversionFuncs(scheme *runtime.Scheme) {
+ // Add non-generated conversion functions
+ err := scheme.AddConversionFuncs()
if err != nil {
// If one of the conversion functions is malformed, detect it immediately.
panic(err)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..9972f82ed10063167cda63ff8b2a57591cee7206
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/conversion_generated.go
@@ -0,0 +1,143 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ authentication_k8s_io "k8s.io/kubernetes/pkg/apis/authentication.k8s.io"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1beta1_TokenReview_To_authenticationk8sio_TokenReview,
+ Convert_authenticationk8sio_TokenReview_To_v1beta1_TokenReview,
+ Convert_v1beta1_TokenReviewSpec_To_authenticationk8sio_TokenReviewSpec,
+ Convert_authenticationk8sio_TokenReviewSpec_To_v1beta1_TokenReviewSpec,
+ Convert_v1beta1_TokenReviewStatus_To_authenticationk8sio_TokenReviewStatus,
+ Convert_authenticationk8sio_TokenReviewStatus_To_v1beta1_TokenReviewStatus,
+ Convert_v1beta1_UserInfo_To_authenticationk8sio_UserInfo,
+ Convert_authenticationk8sio_UserInfo_To_v1beta1_UserInfo,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1beta1_TokenReview_To_authenticationk8sio_TokenReview(in *TokenReview, out *authentication_k8s_io.TokenReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_TokenReviewSpec_To_authenticationk8sio_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_TokenReviewStatus_To_authenticationk8sio_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_TokenReview_To_authenticationk8sio_TokenReview(in *TokenReview, out *authentication_k8s_io.TokenReview, s conversion.Scope) error {
+ return autoConvert_v1beta1_TokenReview_To_authenticationk8sio_TokenReview(in, out, s)
+}
+
+func autoConvert_authenticationk8sio_TokenReview_To_v1beta1_TokenReview(in *authentication_k8s_io.TokenReview, out *TokenReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_authenticationk8sio_TokenReviewSpec_To_v1beta1_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_authenticationk8sio_TokenReviewStatus_To_v1beta1_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_authenticationk8sio_TokenReview_To_v1beta1_TokenReview(in *authentication_k8s_io.TokenReview, out *TokenReview, s conversion.Scope) error {
+ return autoConvert_authenticationk8sio_TokenReview_To_v1beta1_TokenReview(in, out, s)
+}
+
+func autoConvert_v1beta1_TokenReviewSpec_To_authenticationk8sio_TokenReviewSpec(in *TokenReviewSpec, out *authentication_k8s_io.TokenReviewSpec, s conversion.Scope) error {
+ out.Token = in.Token
+ return nil
+}
+
+func Convert_v1beta1_TokenReviewSpec_To_authenticationk8sio_TokenReviewSpec(in *TokenReviewSpec, out *authentication_k8s_io.TokenReviewSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_TokenReviewSpec_To_authenticationk8sio_TokenReviewSpec(in, out, s)
+}
+
+func autoConvert_authenticationk8sio_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in *authentication_k8s_io.TokenReviewSpec, out *TokenReviewSpec, s conversion.Scope) error {
+ out.Token = in.Token
+ return nil
+}
+
+func Convert_authenticationk8sio_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in *authentication_k8s_io.TokenReviewSpec, out *TokenReviewSpec, s conversion.Scope) error {
+ return autoConvert_authenticationk8sio_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_TokenReviewStatus_To_authenticationk8sio_TokenReviewStatus(in *TokenReviewStatus, out *authentication_k8s_io.TokenReviewStatus, s conversion.Scope) error {
+ out.Authenticated = in.Authenticated
+ if err := Convert_v1beta1_UserInfo_To_authenticationk8sio_UserInfo(&in.User, &out.User, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_TokenReviewStatus_To_authenticationk8sio_TokenReviewStatus(in *TokenReviewStatus, out *authentication_k8s_io.TokenReviewStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_TokenReviewStatus_To_authenticationk8sio_TokenReviewStatus(in, out, s)
+}
+
+func autoConvert_authenticationk8sio_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in *authentication_k8s_io.TokenReviewStatus, out *TokenReviewStatus, s conversion.Scope) error {
+ out.Authenticated = in.Authenticated
+ if err := Convert_authenticationk8sio_UserInfo_To_v1beta1_UserInfo(&in.User, &out.User, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_authenticationk8sio_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in *authentication_k8s_io.TokenReviewStatus, out *TokenReviewStatus, s conversion.Scope) error {
+ return autoConvert_authenticationk8sio_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_UserInfo_To_authenticationk8sio_UserInfo(in *UserInfo, out *authentication_k8s_io.UserInfo, s conversion.Scope) error {
+ out.Username = in.Username
+ out.UID = in.UID
+ out.Groups = in.Groups
+ out.Extra = in.Extra
+ return nil
+}
+
+func Convert_v1beta1_UserInfo_To_authenticationk8sio_UserInfo(in *UserInfo, out *authentication_k8s_io.UserInfo, s conversion.Scope) error {
+ return autoConvert_v1beta1_UserInfo_To_authenticationk8sio_UserInfo(in, out, s)
+}
+
+func autoConvert_authenticationk8sio_UserInfo_To_v1beta1_UserInfo(in *authentication_k8s_io.UserInfo, out *UserInfo, s conversion.Scope) error {
+ out.Username = in.Username
+ out.UID = in.UID
+ out.Groups = in.Groups
+ out.Extra = in.Extra
+ return nil
+}
+
+func Convert_authenticationk8sio_UserInfo_To_v1beta1_UserInfo(in *authentication_k8s_io.UserInfo, out *UserInfo, s conversion.Scope) error {
+ return autoConvert_authenticationk8sio_UserInfo_To_v1beta1_UserInfo(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..e44dfc86bf3946e45d699f0557af29afea8a0cd6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/deep_copy_generated.go
@@ -0,0 +1,91 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1beta1_TokenReview,
+ DeepCopy_v1beta1_TokenReviewSpec,
+ DeepCopy_v1beta1_TokenReviewStatus,
+ DeepCopy_v1beta1_UserInfo,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1beta1_TokenReview(in TokenReview, out *TokenReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_TokenReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_TokenReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_TokenReviewSpec(in TokenReviewSpec, out *TokenReviewSpec, c *conversion.Cloner) error {
+ out.Token = in.Token
+ return nil
+}
+
+func DeepCopy_v1beta1_TokenReviewStatus(in TokenReviewStatus, out *TokenReviewStatus, c *conversion.Cloner) error {
+ out.Authenticated = in.Authenticated
+ if err := DeepCopy_v1beta1_UserInfo(in.User, &out.User, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_UserInfo(in UserInfo, out *UserInfo, c *conversion.Cloner) error {
+ out.Username = in.Username
+ out.UID = in.UID
+ if in.Groups != nil {
+ in, out := in.Groups, &out.Groups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Groups = nil
+ }
+ if in.Extra != nil {
+ in, out := in.Extra, &out.Extra
+ *out = make(map[string][]string)
+ for key, val := range in {
+ if newVal, err := c.DeepCopy(val); err != nil {
+ return err
+ } else {
+ (*out)[key] = newVal.([]string)
+ }
+ }
+ } else {
+ out.Extra = nil
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..0f3732e36dcb72009ec5fa6f76b56b67779bbd4e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/defaults.go
@@ -0,0 +1,25 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfdb87c53d848bec83a37e7fca7492be7790d03e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1beta1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..e183299c0b5fdfab442307f09c41d50b6b3733dc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/register.go
@@ -0,0 +1,44 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "authentication.k8s.io"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1beta1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ // Add the API to Scheme.
+ addKnownTypes(scheme)
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &TokenReview{},
+ )
+}
+
+func (obj *TokenReview) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..62d287ff57a4d281ebdfb7a1c9a48233843dd5a2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.generated.go
@@ -0,0 +1,1321 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v1beta1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ "reflect"
+ "runtime"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg1_unversioned.TypeMeta
+ _ = v0
+ }
+}
+
+func (x *TokenReview) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4 := &x.Spec
+ yy4.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.Spec
+ yy6.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Status
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Status
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReview) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = TokenReviewSpec{}
+ } else {
+ yyv4 := &x.Spec
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = TokenReviewStatus{}
+ } else {
+ yyv5 := &x.Status
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = TokenReviewSpec{}
+ } else {
+ yyv9 := &x.Spec
+ yyv9.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = TokenReviewStatus{}
+ } else {
+ yyv10 := &x.Status
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *TokenReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [1]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Token != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(1)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Token))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("token"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Token))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReviewSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "token":
+ if r.TryDecodeAsNil() {
+ x.Token = ""
+ } else {
+ x.Token = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Token = ""
+ } else {
+ x.Token = string(r.DecodeString())
+ }
+ for {
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj5-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *TokenReviewStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Authenticated != false
+ yyq2[1] = true
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Authenticated))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("authenticated"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Authenticated))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy7 := &x.User
+ yy7.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("user"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.User
+ yy9.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *TokenReviewStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *TokenReviewStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "authenticated":
+ if r.TryDecodeAsNil() {
+ x.Authenticated = false
+ } else {
+ x.Authenticated = bool(r.DecodeBool())
+ }
+ case "user":
+ if r.TryDecodeAsNil() {
+ x.User = UserInfo{}
+ } else {
+ yyv5 := &x.User
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *TokenReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Authenticated = false
+ } else {
+ x.Authenticated = bool(r.DecodeBool())
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.User = UserInfo{}
+ } else {
+ yyv8 := &x.User
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *UserInfo) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Username != ""
+ yyq2[1] = x.UID != ""
+ yyq2[2] = len(x.Groups) != 0
+ yyq2[3] = len(x.Extra) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Username))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("username"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Username))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.Groups == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Groups, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("groups"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Groups == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Groups, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("extra"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *UserInfo) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *UserInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "username":
+ if r.TryDecodeAsNil() {
+ x.Username = ""
+ } else {
+ x.Username = string(r.DecodeString())
+ }
+ case "uid":
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = string(r.DecodeString())
+ }
+ case "groups":
+ if r.TryDecodeAsNil() {
+ x.Groups = nil
+ } else {
+ yyv6 := &x.Groups
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ case "extra":
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv8 := &x.Extra
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv8), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *UserInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Username = ""
+ } else {
+ x.Username = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.UID = ""
+ } else {
+ x.UID = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Groups = nil
+ } else {
+ yyv13 := &x.Groups
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv13, false, d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv15 := &x.Extra
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv15), d)
+ }
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeMapStart(len(v))
+ for yyk1, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyk1))
+ }
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyv1 == nil {
+ r.EncodeNil()
+ } else {
+ yym3 := z.EncBinary()
+ _ = yym3
+ if false {
+ } else {
+ z.F.EncSliceStringV(yyv1, false, e)
+ }
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyl1 := r.ReadMapStart()
+ yybh1 := z.DecBasicHandle()
+ if yyv1 == nil {
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyv1 = make(map[string][]string, yyrl1)
+ *v = yyv1
+ }
+ var yymk1 string
+ var yymv1 []string
+ var yymg1 bool
+ if yybh1.MapValueReset {
+ yymg1 = true
+ }
+ if yyl1 > 0 {
+ for yyj1 := 0; yyj1 < yyl1; yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv3 := &yymv1
+ yym4 := z.DecBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv3, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } else if yyl1 < 0 {
+ for yyj1 := 0; !r.CheckBreak(); yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv6 := &yymv1
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } // else len==0: TODO: Should we clear map entries?
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) encSlicestring(v []string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyv1))
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicestring(v *[]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 string
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..fc136877a9efe531bb55d574065c626ae3b899be
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authentication.k8s.io/v1beta1/types.go
@@ -0,0 +1,63 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+)
+
+// 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.
+type TokenReview struct {
+ unversioned.TypeMeta `json:",inline"`
+
+ // Spec holds information about the request being evaluated
+ Spec TokenReviewSpec `json:"spec"`
+
+ // Status is filled in by the server and indicates whether the request can be authenticated.
+ Status TokenReviewStatus `json:"status,omitempty"`
+}
+
+// TokenReviewSpec is a description of the token authentication request.
+type TokenReviewSpec struct {
+ // Token is the opaque bearer token.
+ Token string `json:"token,omitempty"`
+}
+
+// TokenReviewStatus is the result of the token authentication request.
+type TokenReviewStatus struct {
+ // Authenticated indicates that the token was associated with a known user.
+ Authenticated bool `json:"authenticated,omitempty"`
+ // User is the UserInfo associated with the provided token.
+ User UserInfo `json:"user,omitempty"`
+}
+
+// UserInfo holds the information about the user needed to implement the
+// user.Info interface.
+type UserInfo struct {
+ // The name that uniquely identifies this user among all active users.
+ Username string `json:"username,omitempty"`
+ // 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.
+ UID string `json:"uid,omitempty"`
+ // The names of groups this user is a part of.
+ Groups []string `json:"groups,omitempty"`
+ // Any additional information provided by the authenticator.
+ Extra map[string][]string `json:"extra,omitempty"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc40fb33ea3d342eb5c75bceed9242fefd988d63
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/deep_copy_generated.go
@@ -0,0 +1,170 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package authorization
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_authorization_LocalSubjectAccessReview,
+ DeepCopy_authorization_NonResourceAttributes,
+ DeepCopy_authorization_ResourceAttributes,
+ DeepCopy_authorization_SelfSubjectAccessReview,
+ DeepCopy_authorization_SelfSubjectAccessReviewSpec,
+ DeepCopy_authorization_SubjectAccessReview,
+ DeepCopy_authorization_SubjectAccessReviewSpec,
+ DeepCopy_authorization_SubjectAccessReviewStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_authorization_LocalSubjectAccessReview(in LocalSubjectAccessReview, out *LocalSubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_authorization_NonResourceAttributes(in NonResourceAttributes, out *NonResourceAttributes, c *conversion.Cloner) error {
+ out.Path = in.Path
+ out.Verb = in.Verb
+ return nil
+}
+
+func DeepCopy_authorization_ResourceAttributes(in ResourceAttributes, out *ResourceAttributes, c *conversion.Cloner) error {
+ out.Namespace = in.Namespace
+ out.Verb = in.Verb
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Resource = in.Resource
+ out.Subresource = in.Subresource
+ out.Name = in.Name
+ return nil
+}
+
+func DeepCopy_authorization_SelfSubjectAccessReview(in SelfSubjectAccessReview, out *SelfSubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SelfSubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_authorization_SelfSubjectAccessReviewSpec(in SelfSubjectAccessReviewSpec, out *SelfSubjectAccessReviewSpec, c *conversion.Cloner) error {
+ if in.ResourceAttributes != nil {
+ in, out := in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := DeepCopy_authorization_ResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := DeepCopy_authorization_NonResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ return nil
+}
+
+func DeepCopy_authorization_SubjectAccessReview(in SubjectAccessReview, out *SubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_authorization_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_authorization_SubjectAccessReviewSpec(in SubjectAccessReviewSpec, out *SubjectAccessReviewSpec, c *conversion.Cloner) error {
+ if in.ResourceAttributes != nil {
+ in, out := in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := DeepCopy_authorization_ResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := DeepCopy_authorization_NonResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ out.User = in.User
+ if in.Groups != nil {
+ in, out := in.Groups, &out.Groups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Groups = nil
+ }
+ if in.Extra != nil {
+ in, out := in.Extra, &out.Extra
+ *out = make(map[string][]string)
+ for key, val := range in {
+ if newVal, err := c.DeepCopy(val); err != nil {
+ return err
+ } else {
+ (*out)[key] = newVal.([]string)
+ }
+ }
+ } else {
+ out.Extra = nil
+ }
+ return nil
+}
+
+func DeepCopy_authorization_SubjectAccessReviewStatus(in SubjectAccessReviewStatus, out *SubjectAccessReviewStatus, c *conversion.Cloner) error {
+ out.Allowed = in.Allowed
+ out.Reason = in.Reason
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/install/install.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/install/install.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/register.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/register.go
similarity index 84%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/register.go
index b286526131a5851e3cffb9cb91073f062153c139..fdb6c4f4bdee9a8ce5bd324369d82298d77e7903 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/register.go
@@ -48,7 +48,3 @@ func addKnownTypes(scheme *runtime.Scheme) {
&LocalSubjectAccessReview{},
)
}
-
-func (obj *LocalSubjectAccessReview) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SubjectAccessReview) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *SelfSubjectAccessReview) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go
index 9f00bf014d775f76cc02c11e6d53a7706ce4beaf..1c071376cac47ac592140dd7783fd52e2535edc9 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -1551,14 +1551,14 @@ func (x *SubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(5)
} else {
- yynn2 = 4
+ yynn2 = 5
for _, b := range yyq2 {
if b {
yynn2++
@@ -1647,6 +1647,33 @@ func (x *SubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("Extra"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -1748,6 +1775,18 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.F.DecSliceStringX(yyv7, false, d)
}
}
+ case "Extra":
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv9 := &x.Extra
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv9), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -1759,16 +1798,16 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1783,13 +1822,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
}
x.ResourceAttributes.CodecDecodeSelf(d)
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1804,13 +1843,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
}
x.NonResourceAttributes.CodecDecodeSelf(d)
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1820,13 +1859,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
} else {
x.User = string(r.DecodeString())
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1834,26 +1873,48 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.Groups = nil
} else {
- yyv13 := &x.Groups
- yym14 := z.DecBinary()
- _ = yym14
+ yyv15 := &x.Groups
+ yym16 := z.DecBinary()
+ _ = yym16
if false {
} else {
- z.F.DecSliceStringX(yyv13, false, d)
+ z.F.DecSliceStringX(yyv15, false, d)
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv17 := &x.Extra
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv17), d)
}
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj11-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -2279,3 +2340,231 @@ func (x *SubjectAccessReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+
+func (x codecSelfer1234) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeMapStart(len(v))
+ for yyk1, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyk1))
+ }
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyv1 == nil {
+ r.EncodeNil()
+ } else {
+ yym3 := z.EncBinary()
+ _ = yym3
+ if false {
+ } else {
+ z.F.EncSliceStringV(yyv1, false, e)
+ }
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyl1 := r.ReadMapStart()
+ yybh1 := z.DecBasicHandle()
+ if yyv1 == nil {
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyv1 = make(map[string][]string, yyrl1)
+ *v = yyv1
+ }
+ var yymk1 string
+ var yymv1 []string
+ var yymg1 bool
+ if yybh1.MapValueReset {
+ yymg1 = true
+ }
+ if yyl1 > 0 {
+ for yyj1 := 0; yyj1 < yyl1; yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv3 := &yymv1
+ yym4 := z.DecBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv3, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } else if yyl1 < 0 {
+ for yyj1 := 0; !r.CheckBreak(); yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv6 := &yymv1
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } // else len==0: TODO: Should we clear map entries?
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) encSlicestring(v []string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyv1))
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicestring(v *[]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 string
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/types.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/types.go
index 5feb0e5468d3de530039f66db1d4b5557091b06d..8cfdfbe9775f6ae53d8d2a53fc386d8e6e1751de 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/types.go
@@ -101,6 +101,9 @@ type SubjectAccessReviewSpec struct {
User string
// Groups is the groups you're testing for.
Groups []string
+ // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer
+ // it needs a reflection here.
+ Extra map[string][]string
}
// SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAttributes
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion.go
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..a475c0fd0a73b7e93bfd4d626aeae21616507aef
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/conversion_generated.go
@@ -0,0 +1,333 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ authorization "k8s.io/kubernetes/pkg/apis/authorization"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview,
+ Convert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview,
+ Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes,
+ Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes,
+ Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes,
+ Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes,
+ Convert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview,
+ Convert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview,
+ Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec,
+ Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec,
+ Convert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview,
+ Convert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview,
+ Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec,
+ Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec,
+ Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus,
+ Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in, out, s)
+}
+
+func autoConvert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *LocalSubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *LocalSubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in, out, s)
+}
+
+func autoConvert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
+ out.Path = in.Path
+ out.Verb = in.Verb
+ return nil
+}
+
+func Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
+ return autoConvert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in, out, s)
+}
+
+func autoConvert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *NonResourceAttributes, s conversion.Scope) error {
+ out.Path = in.Path
+ out.Verb = in.Verb
+ return nil
+}
+
+func Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *NonResourceAttributes, s conversion.Scope) error {
+ return autoConvert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in, out, s)
+}
+
+func autoConvert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in *ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
+ out.Namespace = in.Namespace
+ out.Verb = in.Verb
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Resource = in.Resource
+ out.Subresource = in.Subresource
+ out.Name = in.Name
+ return nil
+}
+
+func Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in *ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
+ return autoConvert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in, out, s)
+}
+
+func autoConvert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in *authorization.ResourceAttributes, out *ResourceAttributes, s conversion.Scope) error {
+ out.Namespace = in.Namespace
+ out.Verb = in.Verb
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Resource = in.Resource
+ out.Subresource = in.Subresource
+ out.Name = in.Name
+ return nil
+}
+
+func Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in *authorization.ResourceAttributes, out *ResourceAttributes, s conversion.Scope) error {
+ return autoConvert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in, out, s)
+}
+
+func autoConvert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in, out, s)
+}
+
+func autoConvert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *SelfSubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *SelfSubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in, out, s)
+}
+
+func autoConvert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
+ if in.ResourceAttributes != nil {
+ in, out := &in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(authorization.ResourceAttributes)
+ if err := Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(authorization.NonResourceAttributes)
+ if err := Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in, out, s)
+}
+
+func autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *SelfSubjectAccessReviewSpec, s conversion.Scope) error {
+ if in.ResourceAttributes != nil {
+ in, out := &in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ return nil
+}
+
+func Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *SelfSubjectAccessReviewSpec, s conversion.Scope) error {
+ return autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in, out, s)
+}
+
+func autoConvert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *SubjectAccessReview, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *SubjectAccessReview, s conversion.Scope) error {
+ return autoConvert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in, out, s)
+}
+
+func autoConvert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
+ if in.ResourceAttributes != nil {
+ in, out := &in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(authorization.ResourceAttributes)
+ if err := Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(authorization.NonResourceAttributes)
+ if err := Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ out.User = in.User
+ out.Groups = in.Groups
+ out.Extra = in.Extra
+ return nil
+}
+
+func Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in, out, s)
+}
+
+func autoConvert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *SubjectAccessReviewSpec, s conversion.Scope) error {
+ if in.ResourceAttributes != nil {
+ in, out := &in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ out.User = in.User
+ out.Groups = in.Groups
+ out.Extra = in.Extra
+ return nil
+}
+
+func Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *SubjectAccessReviewSpec, s conversion.Scope) error {
+ return autoConvert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
+ out.Allowed = in.Allowed
+ out.Reason = in.Reason
+ return nil
+}
+
+func Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in, out, s)
+}
+
+func autoConvert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *SubjectAccessReviewStatus, s conversion.Scope) error {
+ out.Allowed = in.Allowed
+ out.Reason = in.Reason
+ return nil
+}
+
+func Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *SubjectAccessReviewStatus, s conversion.Scope) error {
+ return autoConvert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..94a35650cb459f14761f09d5ed79dd13ce97f065
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/deep_copy_generated.go
@@ -0,0 +1,170 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1beta1_LocalSubjectAccessReview,
+ DeepCopy_v1beta1_NonResourceAttributes,
+ DeepCopy_v1beta1_ResourceAttributes,
+ DeepCopy_v1beta1_SelfSubjectAccessReview,
+ DeepCopy_v1beta1_SelfSubjectAccessReviewSpec,
+ DeepCopy_v1beta1_SubjectAccessReview,
+ DeepCopy_v1beta1_SubjectAccessReviewSpec,
+ DeepCopy_v1beta1_SubjectAccessReviewStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1beta1_LocalSubjectAccessReview(in LocalSubjectAccessReview, out *LocalSubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NonResourceAttributes(in NonResourceAttributes, out *NonResourceAttributes, c *conversion.Cloner) error {
+ out.Path = in.Path
+ out.Verb = in.Verb
+ return nil
+}
+
+func DeepCopy_v1beta1_ResourceAttributes(in ResourceAttributes, out *ResourceAttributes, c *conversion.Cloner) error {
+ out.Namespace = in.Namespace
+ out.Verb = in.Verb
+ out.Group = in.Group
+ out.Version = in.Version
+ out.Resource = in.Resource
+ out.Subresource = in.Subresource
+ out.Name = in.Name
+ return nil
+}
+
+func DeepCopy_v1beta1_SelfSubjectAccessReview(in SelfSubjectAccessReview, out *SelfSubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SelfSubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_SelfSubjectAccessReviewSpec(in SelfSubjectAccessReviewSpec, out *SelfSubjectAccessReviewSpec, c *conversion.Cloner) error {
+ if in.ResourceAttributes != nil {
+ in, out := in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := DeepCopy_v1beta1_ResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := DeepCopy_v1beta1_NonResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_SubjectAccessReview(in SubjectAccessReview, out *SubjectAccessReview, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SubjectAccessReviewSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SubjectAccessReviewStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_SubjectAccessReviewSpec(in SubjectAccessReviewSpec, out *SubjectAccessReviewSpec, c *conversion.Cloner) error {
+ if in.ResourceAttributes != nil {
+ in, out := in.ResourceAttributes, &out.ResourceAttributes
+ *out = new(ResourceAttributes)
+ if err := DeepCopy_v1beta1_ResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.ResourceAttributes = nil
+ }
+ if in.NonResourceAttributes != nil {
+ in, out := in.NonResourceAttributes, &out.NonResourceAttributes
+ *out = new(NonResourceAttributes)
+ if err := DeepCopy_v1beta1_NonResourceAttributes(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NonResourceAttributes = nil
+ }
+ out.User = in.User
+ if in.Groups != nil {
+ in, out := in.Groups, &out.Groups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Groups = nil
+ }
+ if in.Extra != nil {
+ in, out := in.Extra, &out.Extra
+ *out = make(map[string][]string)
+ for key, val := range in {
+ if newVal, err := c.DeepCopy(val); err != nil {
+ return err
+ } else {
+ (*out)[key] = newVal.([]string)
+ }
+ }
+ } else {
+ out.Extra = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_SubjectAccessReviewStatus(in SubjectAccessReviewStatus, out *SubjectAccessReviewStatus, c *conversion.Cloner) error {
+ out.Allowed = in.Allowed
+ out.Reason = in.Reason
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/defaults.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/defaults.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/defaults.go
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfdb87c53d848bec83a37e7fca7492be7790d03e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1beta1
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/register.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/register.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go
similarity index 89%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go
index 906fcb57788cc1a023e438fcdfe1f0eeca1bec17..3b5e4fbe9322dbb31a44c89a4fe89fa2f361ab6f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -1635,16 +1635,17 @@ func (x *SubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.ResourceAttributes != nil
yyq2[1] = x.NonResourceAttributes != nil
yyq2[2] = x.User != ""
yyq2[3] = len(x.Groups) != 0
+ yyq2[4] = len(x.Extra) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(5)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -1759,6 +1760,39 @@ func (x *SubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("extra"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Extra == nil {
+ r.EncodeNil()
+ } else {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
+ }
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -1860,6 +1894,18 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.F.DecSliceStringX(yyv7, false, d)
}
}
+ case "extra":
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv9 := &x.Extra
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv9), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -1871,16 +1917,16 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1895,13 +1941,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
}
x.ResourceAttributes.CodecDecodeSelf(d)
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1916,13 +1962,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
}
x.NonResourceAttributes.CodecDecodeSelf(d)
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1932,13 +1978,13 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
} else {
x.User = string(r.DecodeString())
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1946,26 +1992,48 @@ func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.Groups = nil
} else {
- yyv13 := &x.Groups
- yym14 := z.DecBinary()
- _ = yym14
+ yyv15 := &x.Groups
+ yym16 := z.DecBinary()
+ _ = yym16
if false {
} else {
- z.F.DecSliceStringX(yyv13, false, d)
+ z.F.DecSliceStringX(yyv15, false, d)
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Extra = nil
+ } else {
+ yyv17 := &x.Extra
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ h.decMapstringSlicestring((*map[string][]string)(yyv17), d)
}
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb11 = r.CheckBreak()
}
- if yyb9 {
+ if yyb11 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj11-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -2412,3 +2480,231 @@ func (x *SubjectAccessReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+
+func (x codecSelfer1234) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeMapStart(len(v))
+ for yyk1, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyk1))
+ }
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyv1 == nil {
+ r.EncodeNil()
+ } else {
+ yym3 := z.EncBinary()
+ _ = yym3
+ if false {
+ } else {
+ z.F.EncSliceStringV(yyv1, false, e)
+ }
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyl1 := r.ReadMapStart()
+ yybh1 := z.DecBasicHandle()
+ if yyv1 == nil {
+ yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
+ yyv1 = make(map[string][]string, yyrl1)
+ *v = yyv1
+ }
+ var yymk1 string
+ var yymv1 []string
+ var yymg1 bool
+ if yybh1.MapValueReset {
+ yymg1 = true
+ }
+ if yyl1 > 0 {
+ for yyj1 := 0; yyj1 < yyl1; yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv3 := &yymv1
+ yym4 := z.DecBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv3, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } else if yyl1 < 0 {
+ for yyj1 := 0; !r.CheckBreak(); yyj1++ {
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ if r.TryDecodeAsNil() {
+ yymk1 = ""
+ } else {
+ yymk1 = string(r.DecodeString())
+ }
+
+ if yymg1 {
+ yymv1 = yyv1[yymk1]
+ } else {
+ yymv1 = nil
+ }
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ if r.TryDecodeAsNil() {
+ yymv1 = nil
+ } else {
+ yyv6 := &yymv1
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+
+ if yyv1 != nil {
+ yyv1[yymk1] = yymv1
+ }
+ }
+ } // else len==0: TODO: Should we clear map entries?
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x codecSelfer1234) encSlicestring(v []string, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym2 := z.EncBinary()
+ _ = yym2
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(yyv1))
+ }
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicestring(v *[]string, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ } else {
+ yyv1 = make([]string, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, "")
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, "") // var yyz1 string
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ""
+ } else {
+ yyv1[yyj1] = string(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []string{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go
index 0a8cb69a74ad5e650208ebf8f438359fde8655f8..27078e9fc0e6966a8eb4d43787edc369f90ca075 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types.go
@@ -100,6 +100,9 @@ type SubjectAccessReviewSpec struct {
User string `json:"user,omitempty"`
// Groups is the groups you're testing for.
Groups []string `json:"group,omitempty"`
+ // Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer
+ // it needs a reflection here.
+ Extra map[string][]string `json:"extra,omitempty"`
}
// SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go
index d9910ef144eab34e91d623a592a60193caf50a7c..d4c337db797e65b192840bd618a09cfbb492d8e4 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/authorization/v1beta1/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -98,6 +98,7 @@ var map_SubjectAccessReviewSpec = map[string]string{
"nonResourceAttributes": "NonResourceAttributes describes information for a non-resource access request",
"user": "User is the user you're testing for. If you specify \"User\" but not \"Group\", then is it interpreted as \"What if User were not a member of any groups",
"group": "Groups is the groups you're testing for.",
+ "extra": "Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here.",
}
func (SubjectAccessReviewSpec) SwaggerDoc() map[string]string {
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..d78bad7cbc39940659cf8f74fe2a74e760a2c802
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/deep_copy_generated.go
@@ -0,0 +1,165 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package autoscaling
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_autoscaling_CrossVersionObjectReference,
+ DeepCopy_autoscaling_HorizontalPodAutoscaler,
+ DeepCopy_autoscaling_HorizontalPodAutoscalerList,
+ DeepCopy_autoscaling_HorizontalPodAutoscalerSpec,
+ DeepCopy_autoscaling_HorizontalPodAutoscalerStatus,
+ DeepCopy_autoscaling_Scale,
+ DeepCopy_autoscaling_ScaleSpec,
+ DeepCopy_autoscaling_ScaleStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_autoscaling_CrossVersionObjectReference(in CrossVersionObjectReference, out *CrossVersionObjectReference, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ return nil
+}
+
+func DeepCopy_autoscaling_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_autoscaling_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_autoscaling_HorizontalPodAutoscalerStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_autoscaling_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]HorizontalPodAutoscaler, len(in))
+ for i := range in {
+ if err := DeepCopy_autoscaling_HorizontalPodAutoscaler(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_autoscaling_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
+ if err := DeepCopy_autoscaling_CrossVersionObjectReference(in.ScaleTargetRef, &out.ScaleTargetRef, c); err != nil {
+ return err
+ }
+ if in.MinReplicas != nil {
+ in, out := in.MinReplicas, &out.MinReplicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.MinReplicas = nil
+ }
+ out.MaxReplicas = in.MaxReplicas
+ if in.TargetCPUUtilizationPercentage != nil {
+ in, out := in.TargetCPUUtilizationPercentage, &out.TargetCPUUtilizationPercentage
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.TargetCPUUtilizationPercentage = nil
+ }
+ return nil
+}
+
+func DeepCopy_autoscaling_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
+ if in.ObservedGeneration != nil {
+ in, out := in.ObservedGeneration, &out.ObservedGeneration
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ObservedGeneration = nil
+ }
+ if in.LastScaleTime != nil {
+ in, out := in.LastScaleTime, &out.LastScaleTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LastScaleTime = nil
+ }
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ if in.CurrentCPUUtilizationPercentage != nil {
+ in, out := in.CurrentCPUUtilizationPercentage, &out.CurrentCPUUtilizationPercentage
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.CurrentCPUUtilizationPercentage = nil
+ }
+ return nil
+}
+
+func DeepCopy_autoscaling_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_autoscaling_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_autoscaling_ScaleStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_autoscaling_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func DeepCopy_autoscaling_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ out.Selector = in.Selector
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/install/install.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/install/install.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/register.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/register.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/register.go
index dfc86f24d2c720fdbeab55258f451f82ff17b681..6a4fb747be8eb7d61a26b5e35e87d71e25c1b47d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/register.go
@@ -19,7 +19,6 @@ package autoscaling
import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/runtime"
)
@@ -48,10 +47,8 @@ func AddToScheme(scheme *runtime.Scheme) {
func addKnownTypes(scheme *runtime.Scheme) {
scheme.AddKnownTypes(SchemeGroupVersion,
&Scale{},
- &extensions.HorizontalPodAutoscaler{},
- &extensions.HorizontalPodAutoscalerList{},
+ &HorizontalPodAutoscaler{},
+ &HorizontalPodAutoscalerList{},
&api.ListOptions{},
)
}
-
-func (obj *Scale) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..fdd05919003cb87c98568c4413f348378895e225
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.generated.go
@@ -0,0 +1,2659 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package autoscaling
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_api "k8s.io/kubernetes/pkg/api"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_api.ObjectMeta
+ var v1 pkg1_unversioned.TypeMeta
+ var v2 pkg3_types.UID
+ var v3 time.Time
+ _, _, _, _ = v0, v1, v2, v3
+ }
+}
+
+func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Scale) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = ScaleSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ScaleStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = ScaleSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ScaleStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScaleSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [1]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Replicas != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(1)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScaleSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScaleSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScaleSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
+ } else {
+ yyb5 = r.CheckBreak()
+ }
+ if yyb5 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj5-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScaleStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.Selector != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Selector))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Selector))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScaleStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "replicas":
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ x.Selector = ""
+ } else {
+ x.Selector = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Replicas = 0
+ } else {
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Selector = ""
+ } else {
+ x.Selector = string(r.DecodeString())
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *CrossVersionObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *CrossVersionObjectReference) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *CrossVersionObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *CrossVersionObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.MinReplicas != nil
+ yyq2[3] = x.TargetCPUUtilizationPercentage != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4 := &x.ScaleTargetRef
+ yy4.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("scaleTargetRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ScaleTargetRef
+ yy6.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.MinReplicas == nil {
+ r.EncodeNil()
+ } else {
+ yy9 := *x.MinReplicas
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(yy9))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.MinReplicas == nil {
+ r.EncodeNil()
+ } else {
+ yy11 := *x.MinReplicas
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeInt(int64(yy11))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeInt(int64(x.MaxReplicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeInt(int64(x.MaxReplicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.TargetCPUUtilizationPercentage == nil {
+ r.EncodeNil()
+ } else {
+ yy17 := *x.TargetCPUUtilizationPercentage
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeInt(int64(yy17))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("targetCPUUtilizationPercentage"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.TargetCPUUtilizationPercentage == nil {
+ r.EncodeNil()
+ } else {
+ yy19 := *x.TargetCPUUtilizationPercentage
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeInt(int64(yy19))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "scaleTargetRef":
+ if r.TryDecodeAsNil() {
+ x.ScaleTargetRef = CrossVersionObjectReference{}
+ } else {
+ yyv4 := &x.ScaleTargetRef
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "minReplicas":
+ if r.TryDecodeAsNil() {
+ if x.MinReplicas != nil {
+ x.MinReplicas = nil
+ }
+ } else {
+ if x.MinReplicas == nil {
+ x.MinReplicas = new(int32)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ *((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "maxReplicas":
+ if r.TryDecodeAsNil() {
+ x.MaxReplicas = 0
+ } else {
+ x.MaxReplicas = int32(r.DecodeInt(32))
+ }
+ case "targetCPUUtilizationPercentage":
+ if r.TryDecodeAsNil() {
+ if x.TargetCPUUtilizationPercentage != nil {
+ x.TargetCPUUtilizationPercentage = nil
+ }
+ } else {
+ if x.TargetCPUUtilizationPercentage == nil {
+ x.TargetCPUUtilizationPercentage = new(int32)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*int32)(x.TargetCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ScaleTargetRef = CrossVersionObjectReference{}
+ } else {
+ yyv11 := &x.ScaleTargetRef
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.MinReplicas != nil {
+ x.MinReplicas = nil
+ }
+ } else {
+ if x.MinReplicas == nil {
+ x.MinReplicas = new(int32)
+ }
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ *((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MaxReplicas = 0
+ } else {
+ x.MaxReplicas = int32(r.DecodeInt(32))
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.TargetCPUUtilizationPercentage != nil {
+ x.TargetCPUUtilizationPercentage = nil
+ }
+ } else {
+ if x.TargetCPUUtilizationPercentage == nil {
+ x.TargetCPUUtilizationPercentage = new(int32)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*int32)(x.TargetCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
+ }
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.ObservedGeneration != nil
+ yyq2[1] = x.LastScaleTime != nil
+ yyq2[4] = x.CurrentCPUUtilizationPercentage != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.ObservedGeneration
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ObservedGeneration == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.ObservedGeneration
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.LastScaleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
+ } else if yym9 {
+ z.EncBinaryMarshal(x.LastScaleTime)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScaleTime)
+ } else {
+ z.EncFallback(x.LastScaleTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LastScaleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
+ } else if yym10 {
+ z.EncBinaryMarshal(x.LastScaleTime)
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScaleTime)
+ } else {
+ z.EncFallback(x.LastScaleTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentReplicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentReplicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredReplicas))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredReplicas))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.CurrentCPUUtilizationPercentage == nil {
+ r.EncodeNil()
+ } else {
+ yy18 := *x.CurrentCPUUtilizationPercentage
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeInt(int64(yy18))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.CurrentCPUUtilizationPercentage == nil {
+ r.EncodeNil()
+ } else {
+ yy20 := *x.CurrentCPUUtilizationPercentage
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeInt(int64(yy20))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "observedGeneration":
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "lastScaleTime":
+ if r.TryDecodeAsNil() {
+ if x.LastScaleTime != nil {
+ x.LastScaleTime = nil
+ }
+ } else {
+ if x.LastScaleTime == nil {
+ x.LastScaleTime = new(pkg1_unversioned.Time)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(x.LastScaleTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScaleTime)
+ } else {
+ z.DecFallback(x.LastScaleTime, false)
+ }
+ }
+ case "currentReplicas":
+ if r.TryDecodeAsNil() {
+ x.CurrentReplicas = 0
+ } else {
+ x.CurrentReplicas = int32(r.DecodeInt(32))
+ }
+ case "desiredReplicas":
+ if r.TryDecodeAsNil() {
+ x.DesiredReplicas = 0
+ } else {
+ x.DesiredReplicas = int32(r.DecodeInt(32))
+ }
+ case "currentCPUUtilizationPercentage":
+ if r.TryDecodeAsNil() {
+ if x.CurrentCPUUtilizationPercentage != nil {
+ x.CurrentCPUUtilizationPercentage = nil
+ }
+ } else {
+ if x.CurrentCPUUtilizationPercentage == nil {
+ x.CurrentCPUUtilizationPercentage = new(int32)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else {
+ *((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ObservedGeneration != nil {
+ x.ObservedGeneration = nil
+ }
+ } else {
+ if x.ObservedGeneration == nil {
+ x.ObservedGeneration = new(int64)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.LastScaleTime != nil {
+ x.LastScaleTime = nil
+ }
+ } else {
+ if x.LastScaleTime == nil {
+ x.LastScaleTime = new(pkg1_unversioned.Time)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
+ } else if yym16 {
+ z.DecBinaryUnmarshal(x.LastScaleTime)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScaleTime)
+ } else {
+ z.DecFallback(x.LastScaleTime, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.CurrentReplicas = 0
+ } else {
+ x.CurrentReplicas = int32(r.DecodeInt(32))
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DesiredReplicas = 0
+ } else {
+ x.DesiredReplicas = int32(r.DecodeInt(32))
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.CurrentCPUUtilizationPercentage != nil {
+ x.CurrentCPUUtilizationPercentage = nil
+ }
+ } else {
+ if x.CurrentCPUUtilizationPercentage == nil {
+ x.CurrentCPUUtilizationPercentage = new(int32)
+ }
+ yym20 := z.DecBinary()
+ _ = yym20
+ if false {
+ } else {
+ *((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
+ }
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = HorizontalPodAutoscalerSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = HorizontalPodAutoscalerStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = HorizontalPodAutoscalerSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = HorizontalPodAutoscalerStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutoscaler, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutoscaler, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []HorizontalPodAutoscaler{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 344)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ }
+ } else {
+ yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, HorizontalPodAutoscaler{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, HorizontalPodAutoscaler{}) // var yyz1 HorizontalPodAutoscaler
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []HorizontalPodAutoscaler{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.go
index 20b96728d22ac654266ea8caf2e3f314be9687fc..caafcde308b4fd8957ade3ef6d17a85ffaa8da4c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/types.go
@@ -14,21 +14,52 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package v1
+package autoscaling
import (
+ "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/api/v1"
)
+// Scale represents a scaling request for a resource.
+type Scale struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ Spec ScaleSpec `json:"spec,omitempty"`
+
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ Status ScaleStatus `json:"status,omitempty"`
+}
+
+// ScaleSpec describes the attributes of a scale subresource.
+type ScaleSpec struct {
+ // desired number of instances for the scaled object.
+ Replicas int32 `json:"replicas,omitempty"`
+}
+
+// ScaleStatus represents the current status of a scale subresource.
+type ScaleStatus struct {
+ // actual number of observed instances of the scaled object.
+ Replicas int32 `json:"replicas"`
+
+ // 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: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector string `json:"selector,omitempty"`
+}
+
// CrossVersionObjectReference contains enough information to let you identify the referred resource.
type CrossVersionObjectReference struct {
- // Kind of the referent; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds"
- Kind string `json:"kind"`
- // Name of the referent; More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name"`
+ // Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds"
+ Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`
+ // Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name" protobuf:"bytes,2,opt,name=name"`
// API version of the referent
- APIVersion string `json:"apiVersion,omitempty"`
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"`
}
// specification of a horizontal pod autoscaler.
@@ -38,7 +69,7 @@ type HorizontalPodAutoscalerSpec struct {
ScaleTargetRef CrossVersionObjectReference `json:"scaleTargetRef"`
// lower limit for the number of pods that can be set by the autoscaler, default 1.
MinReplicas *int32 `json:"minReplicas,omitempty"`
- // upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
+ // upper limit for the number of pods that can be set by the autoscaler. It cannot be smaller than MinReplicas.
MaxReplicas int32 `json:"maxReplicas"`
// 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.
@@ -65,13 +96,14 @@ type HorizontalPodAutoscalerStatus struct {
CurrentCPUUtilizationPercentage *int32 `json:"currentCPUUtilizationPercentage,omitempty"`
}
+// +genclient=true
+
// configuration of a horizontal pod autoscaler.
type HorizontalPodAutoscaler struct {
unversioned.TypeMeta `json:",inline"`
- // Standard object metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ api.ObjectMeta `json:"metadata,omitempty"`
- // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
+ // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty"`
// current information about the autoscaler.
@@ -81,40 +113,8 @@ type HorizontalPodAutoscaler struct {
// list of horizontal pod autoscaler objects.
type HorizontalPodAutoscalerList struct {
unversioned.TypeMeta `json:",inline"`
- // Standard list metadata.
unversioned.ListMeta `json:"metadata,omitempty"`
// list of horizontal pod autoscaler objects.
Items []HorizontalPodAutoscaler `json:"items"`
}
-
-// Scale represents a scaling request for a resource.
-type Scale struct {
- unversioned.TypeMeta `json:",inline"`
- // Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.
- v1.ObjectMeta `json:"metadata,omitempty"`
-
- // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
- Spec ScaleSpec `json:"spec,omitempty"`
-
- // current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.
- Status ScaleStatus `json:"status,omitempty"`
-}
-
-// ScaleSpec describes the attributes of a scale subresource.
-type ScaleSpec struct {
- // desired number of instances for the scaled object.
- Replicas int32 `json:"replicas,omitempty"`
-}
-
-// ScaleStatus represents the current status of a scale subresource.
-type ScaleStatus struct {
- // actual number of observed instances of the scaled object.
- Replicas int32 `json:"replicas"`
-
- // 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://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector string `json:"selector,omitempty"`
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..11ca6a056d8af2cf03fd88beb5c53c7bfadde21f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/conversion_generated.go
@@ -0,0 +1,300 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference,
+ Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference,
+ Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler,
+ Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler,
+ Convert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList,
+ Convert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList,
+ Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec,
+ Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec,
+ Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus,
+ Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus,
+ Convert_v1_Scale_To_autoscaling_Scale,
+ Convert_autoscaling_Scale_To_v1_Scale,
+ Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec,
+ Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec,
+ Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus,
+ Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ return nil
+}
+
+func Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
+ return autoConvert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in, out, s)
+}
+
+func autoConvert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *CrossVersionObjectReference, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ return nil
+}
+
+func Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *CrossVersionObjectReference, s conversion.Scope) error {
+ return autoConvert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in, out, s)
+}
+
+func autoConvert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
+ SetDefaults_HorizontalPodAutoscaler(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
+ return autoConvert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in, out, s)
+}
+
+func autoConvert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
+ for i := range *in {
+ if err := Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
+ return autoConvert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]HorizontalPodAutoscaler, len(*in))
+ for i := range *in {
+ if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in, out, s)
+}
+
+func autoConvert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ if err := Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
+ return err
+ }
+ out.MinReplicas = in.MinReplicas
+ out.MaxReplicas = in.MaxReplicas
+ out.TargetCPUUtilizationPercentage = in.TargetCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ return autoConvert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ if err := Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
+ return err
+ }
+ out.MinReplicas = in.MinReplicas
+ out.MaxReplicas = in.MaxReplicas
+ out.TargetCPUUtilizationPercentage = in.TargetCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in, out, s)
+}
+
+func autoConvert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.LastScaleTime = in.LastScaleTime
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ out.CurrentCPUUtilizationPercentage = in.CurrentCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ return autoConvert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.LastScaleTime = in.LastScaleTime
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ out.CurrentCPUUtilizationPercentage = in.CurrentCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in, out, s)
+}
+
+func autoConvert_v1_Scale_To_autoscaling_Scale(in *Scale, out *autoscaling.Scale, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_Scale_To_autoscaling_Scale(in *Scale, out *autoscaling.Scale, s conversion.Scope) error {
+ return autoConvert_v1_Scale_To_autoscaling_Scale(in, out, s)
+}
+
+func autoConvert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *Scale, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *Scale, s conversion.Scope) error {
+ return autoConvert_autoscaling_Scale_To_v1_Scale(in, out, s)
+}
+
+func autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
+ return autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
+}
+
+func autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
+ return autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in, out, s)
+}
+
+func autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ out.Selector = in.Selector
+ return nil
+}
+
+func Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
+ return autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in, out, s)
+}
+
+func autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ out.Selector = in.Selector
+ return nil
+}
+
+func Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
+ return autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..6932ba63810637adacb46204b9480a9e7936dde2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/deep_copy_generated.go
@@ -0,0 +1,166 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ api_v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1_CrossVersionObjectReference,
+ DeepCopy_v1_HorizontalPodAutoscaler,
+ DeepCopy_v1_HorizontalPodAutoscalerList,
+ DeepCopy_v1_HorizontalPodAutoscalerSpec,
+ DeepCopy_v1_HorizontalPodAutoscalerStatus,
+ DeepCopy_v1_Scale,
+ DeepCopy_v1_ScaleSpec,
+ DeepCopy_v1_ScaleStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1_CrossVersionObjectReference(in CrossVersionObjectReference, out *CrossVersionObjectReference, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ return nil
+}
+
+func DeepCopy_v1_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api_v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_HorizontalPodAutoscalerStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]HorizontalPodAutoscaler, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_HorizontalPodAutoscaler(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
+ if err := DeepCopy_v1_CrossVersionObjectReference(in.ScaleTargetRef, &out.ScaleTargetRef, c); err != nil {
+ return err
+ }
+ if in.MinReplicas != nil {
+ in, out := in.MinReplicas, &out.MinReplicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.MinReplicas = nil
+ }
+ out.MaxReplicas = in.MaxReplicas
+ if in.TargetCPUUtilizationPercentage != nil {
+ in, out := in.TargetCPUUtilizationPercentage, &out.TargetCPUUtilizationPercentage
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.TargetCPUUtilizationPercentage = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
+ if in.ObservedGeneration != nil {
+ in, out := in.ObservedGeneration, &out.ObservedGeneration
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ObservedGeneration = nil
+ }
+ if in.LastScaleTime != nil {
+ in, out := in.LastScaleTime, &out.LastScaleTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LastScaleTime = nil
+ }
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ if in.CurrentCPUUtilizationPercentage != nil {
+ in, out := in.CurrentCPUUtilizationPercentage, &out.CurrentCPUUtilizationPercentage
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.CurrentCPUUtilizationPercentage = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api_v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_ScaleStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func DeepCopy_v1_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ out.Selector = in.Selector
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..3fb24c46b7861ab8657c4256c6b337ca0a802bee
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/defaults.go
@@ -0,0 +1,34 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_HorizontalPodAutoscaler,
+ )
+}
+
+func SetDefaults_HorizontalPodAutoscaler(obj *HorizontalPodAutoscaler) {
+ if obj.Spec.MinReplicas == nil {
+ minReplicas := int32(1)
+ obj.Spec.MinReplicas = &minReplicas
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c67cc3a94c4988aa1eb9b145ecdcbd0a15b051d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..e90dd5d62c7fa7637ef59cf55103a5298fdcdad0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.pb.go
@@ -0,0 +1,1612 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.proto
+
+ It has these top-level messages:
+ CrossVersionObjectReference
+ HorizontalPodAutoscaler
+ HorizontalPodAutoscalerList
+ HorizontalPodAutoscalerSpec
+ HorizontalPodAutoscalerStatus
+ Scale
+ ScaleSpec
+ ScaleStatus
+*/
+package v1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *CrossVersionObjectReference) Reset() { *m = CrossVersionObjectReference{} }
+func (m *CrossVersionObjectReference) String() string { return proto.CompactTextString(m) }
+func (*CrossVersionObjectReference) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscaler) Reset() { *m = HorizontalPodAutoscaler{} }
+func (m *HorizontalPodAutoscaler) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscaler) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerList) Reset() { *m = HorizontalPodAutoscalerList{} }
+func (m *HorizontalPodAutoscalerList) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerList) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerSpec) Reset() { *m = HorizontalPodAutoscalerSpec{} }
+func (m *HorizontalPodAutoscalerSpec) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerSpec) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerStatus) Reset() { *m = HorizontalPodAutoscalerStatus{} }
+func (m *HorizontalPodAutoscalerStatus) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerStatus) ProtoMessage() {}
+
+func (m *Scale) Reset() { *m = Scale{} }
+func (m *Scale) String() string { return proto.CompactTextString(m) }
+func (*Scale) ProtoMessage() {}
+
+func (m *ScaleSpec) Reset() { *m = ScaleSpec{} }
+func (m *ScaleSpec) String() string { return proto.CompactTextString(m) }
+func (*ScaleSpec) ProtoMessage() {}
+
+func (m *ScaleStatus) Reset() { *m = ScaleStatus{} }
+func (m *ScaleStatus) String() string { return proto.CompactTextString(m) }
+func (*ScaleStatus) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*CrossVersionObjectReference)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.CrossVersionObjectReference")
+ proto.RegisterType((*HorizontalPodAutoscaler)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.HorizontalPodAutoscaler")
+ proto.RegisterType((*HorizontalPodAutoscalerList)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.HorizontalPodAutoscalerList")
+ proto.RegisterType((*HorizontalPodAutoscalerSpec)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.HorizontalPodAutoscalerSpec")
+ proto.RegisterType((*HorizontalPodAutoscalerStatus)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.HorizontalPodAutoscalerStatus")
+ proto.RegisterType((*Scale)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.Scale")
+ proto.RegisterType((*ScaleSpec)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.ScaleSpec")
+ proto.RegisterType((*ScaleStatus)(nil), "k8s.io.kubernetes.pkg.apis.autoscaling.v1.ScaleStatus")
+}
+func (m *CrossVersionObjectReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CrossVersionObjectReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscaler) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscaler) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n4, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ScaleTargetRef.Size()))
+ n5, err := m.ScaleTargetRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ if m.MinReplicas != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.MinReplicas))
+ }
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MaxReplicas))
+ if m.TargetCPUUtilizationPercentage != nil {
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.TargetCPUUtilizationPercentage))
+ }
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ObservedGeneration))
+ }
+ if m.LastScaleTime != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastScaleTime.Size()))
+ n6, err := m.LastScaleTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ }
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CurrentReplicas))
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DesiredReplicas))
+ if m.CurrentCPUUtilizationPercentage != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.CurrentCPUUtilizationPercentage))
+ }
+ return i, nil
+}
+
+func (m *Scale) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Scale) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n7, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n8, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n9, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ return i, nil
+}
+
+func (m *ScaleSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScaleSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ return i, nil
+}
+
+func (m *ScaleStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScaleStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Selector)))
+ i += copy(data[i:], m.Selector)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *CrossVersionObjectReference) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *HorizontalPodAutoscaler) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *HorizontalPodAutoscalerList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *HorizontalPodAutoscalerSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ScaleTargetRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.MinReplicas != nil {
+ n += 1 + sovGenerated(uint64(*m.MinReplicas))
+ }
+ n += 1 + sovGenerated(uint64(m.MaxReplicas))
+ if m.TargetCPUUtilizationPercentage != nil {
+ n += 1 + sovGenerated(uint64(*m.TargetCPUUtilizationPercentage))
+ }
+ return n
+}
+
+func (m *HorizontalPodAutoscalerStatus) Size() (n int) {
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
+ }
+ if m.LastScaleTime != nil {
+ l = m.LastScaleTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.CurrentReplicas))
+ n += 1 + sovGenerated(uint64(m.DesiredReplicas))
+ if m.CurrentCPUUtilizationPercentage != nil {
+ n += 1 + sovGenerated(uint64(*m.CurrentCPUUtilizationPercentage))
+ }
+ return n
+}
+
+func (m *Scale) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ScaleSpec) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ return n
+}
+
+func (m *ScaleStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ l = len(m.Selector)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *CrossVersionObjectReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CrossVersionObjectReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CrossVersionObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscaler) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscaler: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, HorizontalPodAutoscaler{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ScaleTargetRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ScaleTargetRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MinReplicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.MinReplicas = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxReplicas", wireType)
+ }
+ m.MaxReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.MaxReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetCPUUtilizationPercentage", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TargetCPUUtilizationPercentage = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ObservedGeneration = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastScaleTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.LastScaleTime == nil {
+ m.LastScaleTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.LastScaleTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
+ }
+ m.CurrentReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.CurrentReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DesiredReplicas", wireType)
+ }
+ m.DesiredReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.DesiredReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentCPUUtilizationPercentage", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CurrentCPUUtilizationPercentage = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Scale) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Scale: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScaleSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScaleStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Selector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..b41980743b3f4a0b1d0783ee23e5255448ff0772
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/generated.proto
@@ -0,0 +1,131 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.autoscaling.v1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1";
+
+// CrossVersionObjectReference contains enough information to let you identify the referred resource.
+message CrossVersionObjectReference {
+ // Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds"
+ optional string kind = 1;
+
+ // Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 2;
+
+ // API version of the referent
+ optional string apiVersion = 3;
+}
+
+// configuration of a horizontal pod autoscaler.
+message HorizontalPodAutoscaler {
+ // Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ optional HorizontalPodAutoscalerSpec spec = 2;
+
+ // current information about the autoscaler.
+ optional HorizontalPodAutoscalerStatus status = 3;
+}
+
+// list of horizontal pod autoscaler objects.
+message HorizontalPodAutoscalerList {
+ // Standard list metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // list of horizontal pod autoscaler objects.
+ repeated HorizontalPodAutoscaler items = 2;
+}
+
+// specification of a horizontal pod autoscaler.
+message HorizontalPodAutoscalerSpec {
+ // 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.
+ optional CrossVersionObjectReference scaleTargetRef = 1;
+
+ // lower limit for the number of pods that can be set by the autoscaler, default 1.
+ optional int32 minReplicas = 2;
+
+ // upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
+ optional int32 maxReplicas = 3;
+
+ // 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.
+ optional int32 targetCPUUtilizationPercentage = 4;
+}
+
+// current status of a horizontal pod autoscaler
+message HorizontalPodAutoscalerStatus {
+ // most recent generation observed by this autoscaler.
+ optional int64 observedGeneration = 1;
+
+ // last time the HorizontalPodAutoscaler scaled the number of pods;
+ // used by the autoscaler to control how often the number of pods is changed.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastScaleTime = 2;
+
+ // current number of replicas of pods managed by this autoscaler.
+ optional int32 currentReplicas = 3;
+
+ // desired number of replicas of pods managed by this autoscaler.
+ optional int32 desiredReplicas = 4;
+
+ // 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.
+ optional int32 currentCPUUtilizationPercentage = 5;
+}
+
+// Scale represents a scaling request for a resource.
+message Scale {
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ optional ScaleSpec spec = 2;
+
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ optional ScaleStatus status = 3;
+}
+
+// ScaleSpec describes the attributes of a scale subresource.
+message ScaleSpec {
+ // desired number of instances for the scaled object.
+ optional int32 replicas = 1;
+}
+
+// ScaleStatus represents the current status of a scale subresource.
+message ScaleStatus {
+ // actual number of observed instances of the scaled object.
+ optional int32 replicas = 1;
+
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional string selector = 2;
+}
+
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go
similarity index 79%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go
index 5af7611c57fd9c007b02b4c0194bcca58609c9f8..fed2cdf48cfff890c6c76e378c6ed169dc84cd48 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/register.go
@@ -20,6 +20,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
)
// GroupName is the group name use in this package
@@ -31,7 +32,6 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
func AddToScheme(scheme *runtime.Scheme) {
addKnownTypes(scheme)
addDefaultingFuncs(scheme)
- addConversionFuncs(scheme)
}
// Adds the list of known types to api.Scheme.
@@ -41,9 +41,7 @@ func addKnownTypes(scheme *runtime.Scheme) {
&HorizontalPodAutoscalerList{},
&Scale{},
&v1.ListOptions{},
+ &v1.DeleteOptions{},
)
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
}
-
-func (obj *HorizontalPodAutoscaler) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *HorizontalPodAutoscalerList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Scale) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go
index 1e5a195c22eed0fe7cf939c02f0761e39e1026c0..d8401bb8bccb9f4b27b2e5ebcfe95f47826e6c95 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -2578,7 +2578,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 344)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..7acb5272088689410ec46cbfa42617cf1b6805b2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types.go
@@ -0,0 +1,122 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+)
+
+// CrossVersionObjectReference contains enough information to let you identify the referred resource.
+type CrossVersionObjectReference struct {
+ // Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds"
+ Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`
+ // Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name" protobuf:"bytes,2,opt,name=name"`
+ // API version of the referent
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"`
+}
+
+// specification of a horizontal pod autoscaler.
+type HorizontalPodAutoscalerSpec struct {
+ // 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.
+ ScaleTargetRef CrossVersionObjectReference `json:"scaleTargetRef" protobuf:"bytes,1,opt,name=scaleTargetRef"`
+ // lower limit for the number of pods that can be set by the autoscaler, default 1.
+ MinReplicas *int32 `json:"minReplicas,omitempty" protobuf:"varint,2,opt,name=minReplicas"`
+ // upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
+ MaxReplicas int32 `json:"maxReplicas" protobuf:"varint,3,opt,name=maxReplicas"`
+ // 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.
+ TargetCPUUtilizationPercentage *int32 `json:"targetCPUUtilizationPercentage,omitempty" protobuf:"varint,4,opt,name=targetCPUUtilizationPercentage"`
+}
+
+// current status of a horizontal pod autoscaler
+type HorizontalPodAutoscalerStatus struct {
+ // most recent generation observed by this autoscaler.
+ ObservedGeneration *int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"`
+
+ // last time the HorizontalPodAutoscaler scaled the number of pods;
+ // used by the autoscaler to control how often the number of pods is changed.
+ LastScaleTime *unversioned.Time `json:"lastScaleTime,omitempty" protobuf:"bytes,2,opt,name=lastScaleTime"`
+
+ // current number of replicas of pods managed by this autoscaler.
+ CurrentReplicas int32 `json:"currentReplicas" protobuf:"varint,3,opt,name=currentReplicas"`
+
+ // desired number of replicas of pods managed by this autoscaler.
+ DesiredReplicas int32 `json:"desiredReplicas" protobuf:"varint,4,opt,name=desiredReplicas"`
+
+ // 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.
+ CurrentCPUUtilizationPercentage *int32 `json:"currentCPUUtilizationPercentage,omitempty" protobuf:"varint,5,opt,name=currentCPUUtilizationPercentage"`
+}
+
+// +genclient=true
+
+// configuration of a horizontal pod autoscaler.
+type HorizontalPodAutoscaler struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+
+ // current information about the autoscaler.
+ Status HorizontalPodAutoscalerStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// list of horizontal pod autoscaler objects.
+type HorizontalPodAutoscalerList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata.
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // list of horizontal pod autoscaler objects.
+ Items []HorizontalPodAutoscaler `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// Scale represents a scaling request for a resource.
+type Scale struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ Spec ScaleSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ Status ScaleStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// ScaleSpec describes the attributes of a scale subresource.
+type ScaleSpec struct {
+ // desired number of instances for the scaled object.
+ Replicas int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
+}
+
+// ScaleStatus represents the current status of a scale subresource.
+type ScaleStatus struct {
+ // actual number of observed instances of the scaled object.
+ Replicas int32 `json:"replicas" protobuf:"varint,1,opt,name=replicas"`
+
+ // 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://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector string `json:"selector,omitempty" protobuf:"bytes,2,opt,name=selector"`
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go
index 537dafba48978e883557b0c1d9aa23bf9cb59880..904e36a6a930e08067bf4ba201db1ebc14b1d03c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/autoscaling/v1/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,8 +29,8 @@ package v1
// AUTO-GENERATED FUNCTIONS START HERE
var map_CrossVersionObjectReference = map[string]string{
"": "CrossVersionObjectReference contains enough information to let you identify the referred resource.",
- "kind": "Kind of the referent; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds\"",
- "name": "Name of the referent; More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
+ "kind": "Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds\"",
+ "name": "Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
"apiVersion": "API version of the referent",
}
@@ -40,8 +40,8 @@ func (CrossVersionObjectReference) SwaggerDoc() map[string]string {
var map_HorizontalPodAutoscaler = map[string]string{
"": "configuration of a horizontal pod autoscaler.",
- "metadata": "Standard object metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "behaviour of autoscaler. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.",
+ "metadata": "Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.",
"status": "current information about the autoscaler.",
}
@@ -86,9 +86,9 @@ func (HorizontalPodAutoscalerStatus) SwaggerDoc() map[string]string {
var map_Scale = map[string]string{
"": "Scale represents a scaling request for a resource.",
- "metadata": "Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.",
- "spec": "defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.",
- "status": "current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.",
+ "metadata": "Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.",
+ "spec": "defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.",
+ "status": "current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.",
}
func (Scale) SwaggerDoc() map[string]string {
@@ -107,7 +107,7 @@ func (ScaleSpec) SwaggerDoc() map[string]string {
var map_ScaleStatus = map[string]string{
"": "ScaleStatus represents the current status of a scale subresource.",
"replicas": "actual number of observed instances of the scaled object.",
- "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://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
+ "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://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
}
func (ScaleStatus) SwaggerDoc() map[string]string {
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..6e08ec410914e20b77e2530a73829c3e3c3f5c55
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/deep_copy_generated.go
@@ -0,0 +1,284 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package batch
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_batch_Job,
+ DeepCopy_batch_JobCondition,
+ DeepCopy_batch_JobList,
+ DeepCopy_batch_JobSpec,
+ DeepCopy_batch_JobStatus,
+ DeepCopy_batch_JobTemplate,
+ DeepCopy_batch_JobTemplateSpec,
+ DeepCopy_batch_ScheduledJob,
+ DeepCopy_batch_ScheduledJobList,
+ DeepCopy_batch_ScheduledJobSpec,
+ DeepCopy_batch_ScheduledJobStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_batch_Job(in Job, out *Job, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_JobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_batch_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Job, len(in))
+ for i := range in {
+ if err := DeepCopy_batch_Job(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_batch_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
+ if in.Parallelism != nil {
+ in, out := in.Parallelism, &out.Parallelism
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Parallelism = nil
+ }
+ if in.Completions != nil {
+ in, out := in.Completions, &out.Completions
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Completions = nil
+ }
+ if in.ActiveDeadlineSeconds != nil {
+ in, out := in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ActiveDeadlineSeconds = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ in, out := in.ManualSelector, &out.ManualSelector
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.ManualSelector = nil
+ }
+ if err := api.DeepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_batch_JobCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.StartTime != nil {
+ in, out := in.StartTime, &out.StartTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.StartTime = nil
+ }
+ if in.CompletionTime != nil {
+ in, out := in.CompletionTime, &out.CompletionTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CompletionTime = nil
+ }
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func DeepCopy_batch_JobTemplate(in JobTemplate, out *JobTemplate, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_JobTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_JobTemplateSpec(in JobTemplateSpec, out *JobTemplateSpec, c *conversion.Cloner) error {
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_ScheduledJob(in ScheduledJob, out *ScheduledJob, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_ScheduledJobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_batch_ScheduledJobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_ScheduledJobList(in ScheduledJobList, out *ScheduledJobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ScheduledJob, len(in))
+ for i := range in {
+ if err := DeepCopy_batch_ScheduledJob(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_batch_ScheduledJobSpec(in ScheduledJobSpec, out *ScheduledJobSpec, c *conversion.Cloner) error {
+ out.Schedule = in.Schedule
+ if in.StartingDeadlineSeconds != nil {
+ in, out := in.StartingDeadlineSeconds, &out.StartingDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.StartingDeadlineSeconds = nil
+ }
+ out.ConcurrencyPolicy = in.ConcurrencyPolicy
+ if in.Suspend != nil {
+ in, out := in.Suspend, &out.Suspend
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.Suspend = nil
+ }
+ if err := DeepCopy_batch_JobTemplateSpec(in.JobTemplate, &out.JobTemplate, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_batch_ScheduledJobStatus(in ScheduledJobStatus, out *ScheduledJobStatus, c *conversion.Cloner) error {
+ if in.Active != nil {
+ in, out := in.Active, &out.Active
+ *out = make([]api.ObjectReference, len(in))
+ for i := range in {
+ if err := api.DeepCopy_api_ObjectReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Active = nil
+ }
+ if in.LastScheduleTime != nil {
+ in, out := in.LastScheduleTime, &out.LastScheduleTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LastScheduleTime = nil
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/install/install.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/install/install.go
index 830020a93768628268080d18fb69f9132db54df5..9d1a88603b8fddc03ba50253c87c873ae9fdea86 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/install/install.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/install/install.go
@@ -30,6 +30,7 @@ import (
"k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/batch/v1"
+ "k8s.io/kubernetes/pkg/apis/batch/v2alpha1"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets"
)
@@ -39,7 +40,7 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/batch"
var accessor = meta.NewAccessor()
// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
+var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion, v2alpha1.SchemeGroupVersion}
func init() {
registered.RegisterVersions(availableVersions)
@@ -106,6 +107,11 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
ObjectConvertor: api.Scheme,
MetadataAccessor: accessor,
}, nil
+ case v2alpha1.SchemeGroupVersion:
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: accessor,
+ }, nil
default:
g, _ := registered.Group(batch.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
@@ -124,6 +130,8 @@ func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
switch v {
case v1.SchemeGroupVersion:
v1.AddToScheme(api.Scheme)
+ case v2alpha1.SchemeGroupVersion:
+ v2alpha1.AddToScheme(api.Scheme)
}
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/register.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/register.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/register.go
index a302fe7514b8ebe54c17a92aff554e72a90de56e..cafa3fd8985b843884f56f5e3574efa4748a4849 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/register.go
@@ -19,7 +19,6 @@ package batch
import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/runtime"
)
@@ -47,8 +46,11 @@ func AddToScheme(scheme *runtime.Scheme) {
// Adds the list of known types to api.Scheme.
func addKnownTypes(scheme *runtime.Scheme) {
scheme.AddKnownTypes(SchemeGroupVersion,
- &extensions.Job{},
- &extensions.JobList{},
+ &Job{},
+ &JobList{},
+ &JobTemplate{},
+ &ScheduledJob{},
+ &ScheduledJobList{},
&api.ListOptions{},
)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..14c44a0f828b217597b50cf83347423d8d8c3b25
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/types.generated.go
@@ -0,0 +1,4671 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package batch
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_api "k8s.io/kubernetes/pkg/api"
+ pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_api.ObjectMeta
+ var v1 pkg4_resource.Quantity
+ var v2 pkg1_unversioned.TypeMeta
+ var v3 pkg3_types.UID
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
+ }
+}
+
+func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = JobStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = JobStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceJob(([]Job)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceJob(([]Job)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceJob((*[]Job)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceJob((*[]Job)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobTemplate) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Template
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Template
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobTemplate) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = JobTemplateSpec{}
+ } else {
+ yyv5 := &x.Template
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv9 := &x.ObjectMeta
+ yyv9.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = JobTemplateSpec{}
+ } else {
+ yyv10 := &x.Template
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobTemplateSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobTemplateSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv7 := &x.ObjectMeta
+ yyv7.CodecDecodeSelf(d)
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv8 := &x.Spec
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Parallelism != nil
+ yyq2[1] = x.Completions != nil
+ yyq2[2] = x.ActiveDeadlineSeconds != nil
+ yyq2[3] = x.Selector != nil
+ yyq2[4] = x.ManualSelector != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Parallelism == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.Parallelism
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Parallelism == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.Parallelism
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Completions == nil {
+ r.EncodeNil()
+ } else {
+ yy9 := *x.Completions
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(yy9))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("completions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Completions == nil {
+ r.EncodeNil()
+ } else {
+ yy11 := *x.Completions
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeInt(int64(yy11))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.ActiveDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy14 := *x.ActiveDeadlineSeconds
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeInt(int64(yy14))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ActiveDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy16 := *x.ActiveDeadlineSeconds
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeInt(int64(yy16))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.ManualSelector == nil {
+ r.EncodeNil()
+ } else {
+ yy22 := *x.ManualSelector
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeBool(bool(yy22))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("manualSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ManualSelector == nil {
+ r.EncodeNil()
+ } else {
+ yy24 := *x.ManualSelector
+ yym25 := z.EncBinary()
+ _ = yym25
+ if false {
+ } else {
+ r.EncodeBool(bool(yy24))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy27 := &x.Template
+ yy27.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy29 := &x.Template
+ yy29.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "parallelism":
+ if r.TryDecodeAsNil() {
+ if x.Parallelism != nil {
+ x.Parallelism = nil
+ }
+ } else {
+ if x.Parallelism == nil {
+ x.Parallelism = new(int32)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "completions":
+ if r.TryDecodeAsNil() {
+ if x.Completions != nil {
+ x.Completions = nil
+ }
+ } else {
+ if x.Completions == nil {
+ x.Completions = new(int32)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ *((*int32)(x.Completions)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "activeDeadlineSeconds":
+ if r.TryDecodeAsNil() {
+ if x.ActiveDeadlineSeconds != nil {
+ x.ActiveDeadlineSeconds = nil
+ }
+ } else {
+ if x.ActiveDeadlineSeconds == nil {
+ x.ActiveDeadlineSeconds = new(int64)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ case "manualSelector":
+ if r.TryDecodeAsNil() {
+ if x.ManualSelector != nil {
+ x.ManualSelector = nil
+ }
+ } else {
+ if x.ManualSelector == nil {
+ x.ManualSelector = new(bool)
+ }
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ *((*bool)(x.ManualSelector)) = r.DecodeBool()
+ }
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_api.PodTemplateSpec{}
+ } else {
+ yyv14 := &x.Template
+ yyv14.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj15 int
+ var yyb15 bool
+ var yyhl15 bool = l >= 0
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Parallelism != nil {
+ x.Parallelism = nil
+ }
+ } else {
+ if x.Parallelism == nil {
+ x.Parallelism = new(int32)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else {
+ *((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Completions != nil {
+ x.Completions = nil
+ }
+ } else {
+ if x.Completions == nil {
+ x.Completions = new(int32)
+ }
+ yym19 := z.DecBinary()
+ _ = yym19
+ if false {
+ } else {
+ *((*int32)(x.Completions)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ActiveDeadlineSeconds != nil {
+ x.ActiveDeadlineSeconds = nil
+ }
+ } else {
+ if x.ActiveDeadlineSeconds == nil {
+ x.ActiveDeadlineSeconds = new(int64)
+ }
+ yym21 := z.DecBinary()
+ _ = yym21
+ if false {
+ } else {
+ *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym23 := z.DecBinary()
+ _ = yym23
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ManualSelector != nil {
+ x.ManualSelector = nil
+ }
+ } else {
+ if x.ManualSelector == nil {
+ x.ManualSelector = new(bool)
+ }
+ yym25 := z.DecBinary()
+ _ = yym25
+ if false {
+ } else {
+ *((*bool)(x.ManualSelector)) = r.DecodeBool()
+ }
+ }
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_api.PodTemplateSpec{}
+ } else {
+ yyv26 := &x.Template
+ yyv26.CodecDecodeSelf(d)
+ }
+ for {
+ yyj15++
+ if yyhl15 {
+ yyb15 = yyj15 > l
+ } else {
+ yyb15 = r.CheckBreak()
+ }
+ if yyb15 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj15-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Conditions) != 0
+ yyq2[1] = x.StartTime != nil
+ yyq2[2] = x.CompletionTime != nil
+ yyq2[3] = x.Active != 0
+ yyq2[4] = x.Succeeded != 0
+ yyq2[5] = x.Failed != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("conditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.StartTime == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.StartTime) {
+ } else if yym7 {
+ z.EncBinaryMarshal(x.StartTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.StartTime)
+ } else {
+ z.EncFallback(x.StartTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("startTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.StartTime == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.StartTime) {
+ } else if yym8 {
+ z.EncBinaryMarshal(x.StartTime)
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.StartTime)
+ } else {
+ z.EncFallback(x.StartTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.CompletionTime == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
+ } else if yym10 {
+ z.EncBinaryMarshal(x.CompletionTime)
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.CompletionTime)
+ } else {
+ z.EncFallback(x.CompletionTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.CompletionTime == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
+ } else if yym11 {
+ z.EncBinaryMarshal(x.CompletionTime)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.CompletionTime)
+ } else {
+ z.EncFallback(x.CompletionTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Active))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("active"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Active))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Succeeded))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Succeeded))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Failed))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("failed"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Failed))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "conditions":
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv4 := &x.Conditions
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceJobCondition((*[]JobCondition)(yyv4), d)
+ }
+ }
+ case "startTime":
+ if r.TryDecodeAsNil() {
+ if x.StartTime != nil {
+ x.StartTime = nil
+ }
+ } else {
+ if x.StartTime == nil {
+ x.StartTime = new(pkg1_unversioned.Time)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.StartTime) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(x.StartTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.StartTime)
+ } else {
+ z.DecFallback(x.StartTime, false)
+ }
+ }
+ case "completionTime":
+ if r.TryDecodeAsNil() {
+ if x.CompletionTime != nil {
+ x.CompletionTime = nil
+ }
+ } else {
+ if x.CompletionTime == nil {
+ x.CompletionTime = new(pkg1_unversioned.Time)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(x.CompletionTime)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.CompletionTime)
+ } else {
+ z.DecFallback(x.CompletionTime, false)
+ }
+ }
+ case "active":
+ if r.TryDecodeAsNil() {
+ x.Active = 0
+ } else {
+ x.Active = int32(r.DecodeInt(32))
+ }
+ case "succeeded":
+ if r.TryDecodeAsNil() {
+ x.Succeeded = 0
+ } else {
+ x.Succeeded = int32(r.DecodeInt(32))
+ }
+ case "failed":
+ if r.TryDecodeAsNil() {
+ x.Failed = 0
+ } else {
+ x.Failed = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj13 int
+ var yyb13 bool
+ var yyhl13 bool = l >= 0
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv14 := &x.Conditions
+ yym15 := z.DecBinary()
+ _ = yym15
+ if false {
+ } else {
+ h.decSliceJobCondition((*[]JobCondition)(yyv14), d)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.StartTime != nil {
+ x.StartTime = nil
+ }
+ } else {
+ if x.StartTime == nil {
+ x.StartTime = new(pkg1_unversioned.Time)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.StartTime) {
+ } else if yym17 {
+ z.DecBinaryUnmarshal(x.StartTime)
+ } else if !yym17 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.StartTime)
+ } else {
+ z.DecFallback(x.StartTime, false)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.CompletionTime != nil {
+ x.CompletionTime = nil
+ }
+ } else {
+ if x.CompletionTime == nil {
+ x.CompletionTime = new(pkg1_unversioned.Time)
+ }
+ yym19 := z.DecBinary()
+ _ = yym19
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
+ } else if yym19 {
+ z.DecBinaryUnmarshal(x.CompletionTime)
+ } else if !yym19 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.CompletionTime)
+ } else {
+ z.DecFallback(x.CompletionTime, false)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Active = 0
+ } else {
+ x.Active = int32(r.DecodeInt(32))
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Succeeded = 0
+ } else {
+ x.Succeeded = int32(r.DecodeInt(32))
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Failed = 0
+ } else {
+ x.Failed = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj13-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *JobConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = true
+ yyq2[3] = true
+ yyq2[4] = x.Reason != ""
+ yyq2[5] = x.Message != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Type.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Type.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yysf7 := &x.Status
+ yysf7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yysf8 := &x.Status
+ yysf8.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy10 := &x.LastProbeTime
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if yym11 {
+ z.EncBinaryMarshal(yy10)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
+ } else {
+ z.EncFallback(yy10)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.LastProbeTime
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if yym13 {
+ z.EncBinaryMarshal(yy12)
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
+ } else {
+ z.EncFallback(yy12)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yy15 := &x.LastTransitionTime
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy15) {
+ } else if yym16 {
+ z.EncBinaryMarshal(yy15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy15)
+ } else {
+ z.EncFallback(yy15)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy17 := &x.LastTransitionTime
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy17) {
+ } else if yym18 {
+ z.EncBinaryMarshal(yy17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy17)
+ } else {
+ z.EncFallback(yy17)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("message"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym24 := z.EncBinary()
+ _ = yym24
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "type":
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = JobConditionType(r.DecodeString())
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg2_api.ConditionStatus(r.DecodeString())
+ }
+ case "lastProbeTime":
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg1_unversioned.Time{}
+ } else {
+ yyv6 := &x.LastProbeTime
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(yyv6)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
+ }
+ case "lastTransitionTime":
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg1_unversioned.Time{}
+ } else {
+ yyv8 := &x.LastTransitionTime
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv8) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(yyv8)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv8)
+ } else {
+ z.DecFallback(yyv8, false)
+ }
+ }
+ case "reason":
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ case "message":
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = JobConditionType(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg2_api.ConditionStatus(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg1_unversioned.Time{}
+ } else {
+ yyv15 := &x.LastProbeTime
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv15) {
+ } else if yym16 {
+ z.DecBinaryUnmarshal(yyv15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv15)
+ } else {
+ z.DecFallback(yyv15, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg1_unversioned.Time{}
+ } else {
+ yyv17 := &x.LastTransitionTime
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv17) {
+ } else if yym18 {
+ z.DecBinaryUnmarshal(yyv17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv17)
+ } else {
+ z.DecFallback(yyv17, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJob) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJob) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJob) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = ScheduledJobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ScheduledJobStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJob) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = ScheduledJobSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ScheduledJobStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJobList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceScheduledJob(([]ScheduledJob)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceScheduledJob(([]ScheduledJob)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceScheduledJob((*[]ScheduledJob)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceScheduledJob((*[]ScheduledJob)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.StartingDeadlineSeconds != nil
+ yyq2[2] = x.ConcurrencyPolicy != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 3
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Schedule))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("schedule"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Schedule))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.StartingDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy7 := *x.StartingDeadlineSeconds
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(yy7))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("startingDeadlineSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.StartingDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy9 := *x.StartingDeadlineSeconds
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(yy9))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ x.ConcurrencyPolicy.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("concurrencyPolicy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.ConcurrencyPolicy.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Suspend == nil {
+ r.EncodeNil()
+ } else {
+ yy15 := *x.Suspend
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeBool(bool(yy15))
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("suspend"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Suspend == nil {
+ r.EncodeNil()
+ } else {
+ yy17 := *x.Suspend
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeBool(bool(yy17))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy20 := &x.JobTemplate
+ yy20.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("jobTemplate"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy22 := &x.JobTemplate
+ yy22.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "schedule":
+ if r.TryDecodeAsNil() {
+ x.Schedule = ""
+ } else {
+ x.Schedule = string(r.DecodeString())
+ }
+ case "startingDeadlineSeconds":
+ if r.TryDecodeAsNil() {
+ if x.StartingDeadlineSeconds != nil {
+ x.StartingDeadlineSeconds = nil
+ }
+ } else {
+ if x.StartingDeadlineSeconds == nil {
+ x.StartingDeadlineSeconds = new(int64)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ *((*int64)(x.StartingDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "concurrencyPolicy":
+ if r.TryDecodeAsNil() {
+ x.ConcurrencyPolicy = ""
+ } else {
+ x.ConcurrencyPolicy = ConcurrencyPolicy(r.DecodeString())
+ }
+ case "suspend":
+ if r.TryDecodeAsNil() {
+ if x.Suspend != nil {
+ x.Suspend = nil
+ }
+ } else {
+ if x.Suspend == nil {
+ x.Suspend = new(bool)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*bool)(x.Suspend)) = r.DecodeBool()
+ }
+ }
+ case "jobTemplate":
+ if r.TryDecodeAsNil() {
+ x.JobTemplate = JobTemplateSpec{}
+ } else {
+ yyv10 := &x.JobTemplate
+ yyv10.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Schedule = ""
+ } else {
+ x.Schedule = string(r.DecodeString())
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.StartingDeadlineSeconds != nil {
+ x.StartingDeadlineSeconds = nil
+ }
+ } else {
+ if x.StartingDeadlineSeconds == nil {
+ x.StartingDeadlineSeconds = new(int64)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ *((*int64)(x.StartingDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ConcurrencyPolicy = ""
+ } else {
+ x.ConcurrencyPolicy = ConcurrencyPolicy(r.DecodeString())
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Suspend != nil {
+ x.Suspend = nil
+ }
+ } else {
+ if x.Suspend == nil {
+ x.Suspend = new(bool)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else {
+ *((*bool)(x.Suspend)) = r.DecodeBool()
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.JobTemplate = JobTemplateSpec{}
+ } else {
+ yyv18 := &x.JobTemplate
+ yyv18.CodecDecodeSelf(d)
+ }
+ for {
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj11-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x ConcurrencyPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *ConcurrencyPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *ScheduledJobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Active) != 0
+ yyq2[1] = x.LastScheduleTime != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Active == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceapi_ObjectReference(([]pkg2_api.ObjectReference)(x.Active), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("active"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Active == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceapi_ObjectReference(([]pkg2_api.ObjectReference)(x.Active), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.LastScheduleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScheduleTime) {
+ } else if yym7 {
+ z.EncBinaryMarshal(x.LastScheduleTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScheduleTime)
+ } else {
+ z.EncFallback(x.LastScheduleTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastScheduleTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LastScheduleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScheduleTime) {
+ } else if yym8 {
+ z.EncBinaryMarshal(x.LastScheduleTime)
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScheduleTime)
+ } else {
+ z.EncFallback(x.LastScheduleTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "active":
+ if r.TryDecodeAsNil() {
+ x.Active = nil
+ } else {
+ yyv4 := &x.Active
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceapi_ObjectReference((*[]pkg2_api.ObjectReference)(yyv4), d)
+ }
+ }
+ case "lastScheduleTime":
+ if r.TryDecodeAsNil() {
+ if x.LastScheduleTime != nil {
+ x.LastScheduleTime = nil
+ }
+ } else {
+ if x.LastScheduleTime == nil {
+ x.LastScheduleTime = new(pkg1_unversioned.Time)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScheduleTime) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(x.LastScheduleTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScheduleTime)
+ } else {
+ z.DecFallback(x.LastScheduleTime, false)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Active = nil
+ } else {
+ yyv9 := &x.Active
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceapi_ObjectReference((*[]pkg2_api.ObjectReference)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.LastScheduleTime != nil {
+ x.LastScheduleTime = nil
+ }
+ } else {
+ if x.LastScheduleTime == nil {
+ x.LastScheduleTime = new(pkg1_unversioned.Time)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScheduleTime) {
+ } else if yym12 {
+ z.DecBinaryUnmarshal(x.LastScheduleTime)
+ } else if !yym12 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScheduleTime)
+ } else {
+ z.DecFallback(x.LastScheduleTime, false)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Job{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 768)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Job, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Job, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Job{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Job{}) // var yyz1 Job
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Job{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []JobCondition{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]JobCondition, yyrl1)
+ }
+ } else {
+ yyv1 = make([]JobCondition, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, JobCondition{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, JobCondition{}) // var yyz1 JobCondition
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []JobCondition{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceScheduledJob(v []ScheduledJob, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceScheduledJob(v *[]ScheduledJob, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ScheduledJob{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 1000)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ScheduledJob, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ScheduledJob, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ScheduledJob{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ScheduledJob{}) // var yyz1 ScheduledJob
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ScheduledJob{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceapi_ObjectReference(v []pkg2_api.ObjectReference, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceapi_ObjectReference(v *[]pkg2_api.ObjectReference, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []pkg2_api.ObjectReference{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]pkg2_api.ObjectReference, yyrl1)
+ }
+ } else {
+ yyv1 = make([]pkg2_api.ObjectReference, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.ObjectReference{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, pkg2_api.ObjectReference{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.ObjectReference{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, pkg2_api.ObjectReference{}) // var yyz1 pkg2_api.ObjectReference
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_api.ObjectReference{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []pkg2_api.ObjectReference{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/types.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ad4699148d2cb81927e1d072f34154c6f45a2ec
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/types.go
@@ -0,0 +1,244 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 batch
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+)
+
+// +genclient=true
+
+// Job represents the configuration of a single job.
+type Job struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Spec is a structure defining the expected behavior of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty"`
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status JobStatus `json:"status,omitempty"`
+}
+
+// JobList is a collection of jobs.
+type JobList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty"`
+
+ // Items is the list of Job.
+ Items []Job `json:"items"`
+}
+
+// JobTemplate describes a template for creating copies of a predefined pod.
+type JobTemplate struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Template defines jobs that will be created from this template
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Template JobTemplateSpec `json:"template,omitempty"`
+}
+
+// JobTemplateSpec describes the data a Job should have when created from a template
+type JobTemplateSpec struct {
+ // Standard object's metadata of the jobs created from this template.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Specification of the desired behavior of the job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty"`
+}
+
+// JobSpec describes how the job execution will look like.
+type JobSpec struct {
+
+ // Parallelism 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.
+ Parallelism *int32 `json:"parallelism,omitempty"`
+
+ // Completions 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.
+ Completions *int32 `json:"completions,omitempty"`
+
+ // Optional duration in seconds relative to the startTime that the job may be active
+ // before the system tries to terminate it; value must be positive integer
+ ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`
+
+ // Selector is a label query over pods that should match the pod count.
+ // Normally, the system sets this field for you.
+ Selector *unversioned.LabelSelector `json:"selector,omitempty"`
+
+ // 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.
+ ManualSelector *bool `json:"manualSelector,omitempty"`
+
+ // Template is the object that describes the pod that will be created when
+ // executing a job.
+ Template api.PodTemplateSpec `json:"template"`
+}
+
+// JobStatus represents the current state of a Job.
+type JobStatus struct {
+
+ // Conditions represent the latest available observations of an object's current state.
+ Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+
+ // StartTime represents time when the job was acknowledged by the Job Manager.
+ // It is not guaranteed to be set in happens-before order across separate operations.
+ // It is represented in RFC3339 form and is in UTC.
+ StartTime *unversioned.Time `json:"startTime,omitempty"`
+
+ // CompletionTime 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.
+ CompletionTime *unversioned.Time `json:"completionTime,omitempty"`
+
+ // Active is the number of actively running pods.
+ Active int32 `json:"active,omitempty"`
+
+ // Succeeded is the number of pods which reached Phase Succeeded.
+ Succeeded int32 `json:"succeeded,omitempty"`
+
+ // Failed is the number of pods which reached Phase Failed.
+ Failed int32 `json:"failed,omitempty"`
+}
+
+type JobConditionType string
+
+// These are valid conditions of a job.
+const (
+ // JobComplete means the job has completed its execution.
+ JobComplete JobConditionType = "Complete"
+ // JobFailed means the job has failed its execution.
+ JobFailed JobConditionType = "Failed"
+)
+
+// JobCondition describes current state of a job.
+type JobCondition struct {
+ // Type of job condition, Complete or Failed.
+ Type JobConditionType `json:"type"`
+ // Status of the condition, one of True, False, Unknown.
+ Status api.ConditionStatus `json:"status"`
+ // Last time the condition was checked.
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
+ // Last time the condition transit from one status to another.
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ // (brief) reason for the condition's last transition.
+ Reason string `json:"reason,omitempty"`
+ // Human readable message indicating details about last transition.
+ Message string `json:"message,omitempty"`
+}
+
+// +genclient=true
+
+// ScheduledJob represents the configuration of a single scheduled job.
+type ScheduledJob struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Spec is a structure defining the expected behavior of a job, including the schedule.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ScheduledJobSpec `json:"spec,omitempty"`
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ScheduledJobStatus `json:"status,omitempty"`
+}
+
+// ScheduledJobList is a collection of scheduled jobs.
+type ScheduledJobList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty"`
+
+ // Items is the list of ScheduledJob.
+ Items []ScheduledJob `json:"items"`
+}
+
+// ScheduledJobSpec describes how the job execution will look like and when it will actually run.
+type ScheduledJobSpec struct {
+
+ // Schedule contains the schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.
+ Schedule string `json:"schedule"`
+
+ // 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.
+ StartingDeadlineSeconds *int64 `json:"startingDeadlineSeconds,omitempty"`
+
+ // ConcurrencyPolicy specifies how to treat concurrent executions of a Job.
+ ConcurrencyPolicy ConcurrencyPolicy `json:"concurrencyPolicy,omitempty"`
+
+ // Suspend flag tells the controller to suspend subsequent executions, it does
+ // not apply to already started executions. Defaults to false.
+ Suspend *bool `json:"suspend"`
+
+ // JobTemplate is the object that describes the job that will be created when
+ // executing a ScheduledJob.
+ JobTemplate JobTemplateSpec `json:"jobTemplate"`
+}
+
+// ConcurrencyPolicy describes how the job will be handled.
+// Only one of the following concurrent policies may be specified.
+// If none of the following policies is specified, the default one
+// is AllowConcurrent.
+type ConcurrencyPolicy string
+
+const (
+ // AllowConcurrent allows ScheduledJobs to run concurrently.
+ AllowConcurrent ConcurrencyPolicy = "Allow"
+
+ // ForbidConcurrent forbids concurrent runs, skipping next run if previous
+ // hasn't finished yet.
+ ForbidConcurrent ConcurrencyPolicy = "Forbid"
+
+ // ReplaceConcurrent cancels currently running job and replaces it with a new one.
+ ReplaceConcurrent ConcurrencyPolicy = "Replace"
+)
+
+// ScheduledJobStatus represents the current state of a Job.
+type ScheduledJobStatus struct {
+ // Active holds pointers to currently running jobs.
+ Active []api.ObjectReference `json:"active,omitempty"`
+
+ // LastScheduleTime keeps information of when was the last time the job was successfully scheduled.
+ LastScheduleTime *unversioned.Time `json:"lastScheduleTime,omitempty"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go
new file mode 100644
index 0000000000000000000000000000000000000000..2d163c6e9a8e6607151517d580aac46648c606fe
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion.go
@@ -0,0 +1,106 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/batch"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addConversionFuncs(scheme *runtime.Scheme) {
+ // Add non-generated conversion functions
+ err := scheme.AddConversionFuncs(
+ Convert_batch_JobSpec_To_v1_JobSpec,
+ Convert_v1_JobSpec_To_batch_JobSpec,
+ )
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+
+ err = api.Scheme.AddFieldLabelConversionFunc("batch/v1", "Job",
+ func(label, value string) (string, string, error) {
+ switch label {
+ case "metadata.name", "metadata.namespace", "status.successful":
+ return label, value, nil
+ default:
+ return "", "", fmt.Errorf("field label not supported: %s", label)
+ }
+ })
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func Convert_batch_JobSpec_To_v1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1.LabelSelector
+ if in.Selector != nil {
+ out.Selector = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v1_LabelSelector(in.Selector, out.Selector, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ out.ManualSelector = new(bool)
+ *out.ManualSelector = *in.ManualSelector
+ } else {
+ out.ManualSelector = nil
+ }
+
+ if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ // unable to generate simple pointer conversion for v1.LabelSelector -> unversioned.LabelSelector
+ if in.Selector != nil {
+ out.Selector = new(unversioned.LabelSelector)
+ if err := Convert_v1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ out.ManualSelector = new(bool)
+ *out.ManualSelector = *in.ManualSelector
+ } else {
+ out.ManualSelector = nil
+ }
+
+ if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..4bb13c498d5fbe033280085b1de531ae07b525ca
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/conversion_generated.go
@@ -0,0 +1,330 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ api_v1 "k8s.io/kubernetes/pkg/api/v1"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1_Job_To_batch_Job,
+ Convert_batch_Job_To_v1_Job,
+ Convert_v1_JobCondition_To_batch_JobCondition,
+ Convert_batch_JobCondition_To_v1_JobCondition,
+ Convert_v1_JobList_To_batch_JobList,
+ Convert_batch_JobList_To_v1_JobList,
+ Convert_v1_JobSpec_To_batch_JobSpec,
+ Convert_batch_JobSpec_To_v1_JobSpec,
+ Convert_v1_JobStatus_To_batch_JobStatus,
+ Convert_batch_JobStatus_To_v1_JobStatus,
+ Convert_v1_LabelSelector_To_unversioned_LabelSelector,
+ Convert_unversioned_LabelSelector_To_v1_LabelSelector,
+ Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
+ Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ SetDefaults_Job(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ return autoConvert_v1_Job_To_batch_Job(in, out, s)
+}
+
+func autoConvert_batch_Job_To_v1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobStatus_To_v1_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_Job_To_v1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ return autoConvert_batch_Job_To_v1_Job(in, out, s)
+}
+
+func autoConvert_v1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ out.Type = batch.JobConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ return autoConvert_v1_JobCondition_To_batch_JobCondition(in, out, s)
+}
+
+func autoConvert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ out.Type = JobConditionType(in.Type)
+ out.Status = api_v1.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ return autoConvert_batch_JobCondition_To_v1_JobCondition(in, out, s)
+}
+
+func autoConvert_v1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]batch.Job, len(*in))
+ for i := range *in {
+ if err := Convert_v1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ return autoConvert_v1_JobList_To_batch_JobList(in, out, s)
+}
+
+func autoConvert_batch_JobList_To_v1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Job, len(*in))
+ for i := range *in {
+ if err := Convert_batch_Job_To_v1_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_batch_JobList_To_v1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ return autoConvert_batch_JobList_To_v1_JobList(in, out, s)
+}
+
+func autoConvert_v1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := Convert_v1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.ManualSelector = in.ManualSelector
+ if err := api_v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_batch_JobSpec_To_v1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v1_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.ManualSelector = in.ManualSelector
+ if err := api_v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_v1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]batch.JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1_JobCondition_To_batch_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_v1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ return autoConvert_v1_JobStatus_To_batch_JobStatus(in, out, s)
+}
+
+func autoConvert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_batch_JobCondition_To_v1_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ return autoConvert_batch_JobStatus_To_v1_JobStatus(in, out, s)
+}
+
+func autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]unversioned.LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_v1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ return autoConvert_v1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_unversioned_LabelSelector_To_v1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelector_To_v1_LabelSelector(in, out, s)
+}
+
+func autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = unversioned.LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_v1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelectorRequirement_To_v1_LabelSelectorRequirement(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2a50b4ee1811fd2772ce13ecd6ff4a0dd776a77
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/deep_copy_generated.go
@@ -0,0 +1,211 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ api_v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1_Job,
+ DeepCopy_v1_JobCondition,
+ DeepCopy_v1_JobList,
+ DeepCopy_v1_JobSpec,
+ DeepCopy_v1_JobStatus,
+ DeepCopy_v1_LabelSelector,
+ DeepCopy_v1_LabelSelectorRequirement,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1_Job(in Job, out *Job, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api_v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1_JobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Job, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_Job(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
+ if in.Parallelism != nil {
+ in, out := in.Parallelism, &out.Parallelism
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Parallelism = nil
+ }
+ if in.Completions != nil {
+ in, out := in.Completions, &out.Completions
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Completions = nil
+ }
+ if in.ActiveDeadlineSeconds != nil {
+ in, out := in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ActiveDeadlineSeconds = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ in, out := in.ManualSelector, &out.ManualSelector
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.ManualSelector = nil
+ }
+ if err := api_v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_JobCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.StartTime != nil {
+ in, out := in.StartTime, &out.StartTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.StartTime = nil
+ }
+ if in.CompletionTime != nil {
+ in, out := in.CompletionTime, &out.CompletionTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CompletionTime = nil
+ }
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func DeepCopy_v1_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
+ if in.MatchLabels != nil {
+ in, out := in.MatchLabels, &out.MatchLabels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.MatchLabels = nil
+ }
+ if in.MatchExpressions != nil {
+ in, out := in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(in))
+ for i := range in {
+ if err := DeepCopy_v1_LabelSelectorRequirement(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ if in.Values != nil {
+ in, out := in.Values, &out.Values
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Values = nil
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go
similarity index 59%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go
index 759ab0fb6de36d341f3f555ba7d1aa35690ed89c..81aa90c1d09543e74981259c28264de55d188aaa 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/defaults.go
@@ -22,19 +22,21 @@ import (
func addDefaultingFuncs(scheme *runtime.Scheme) {
scheme.AddDefaultingFuncs(
- func(obj *Job) {
- // For a non-parallel job, you can leave both `.spec.completions` and
- // `.spec.parallelism` unset. When both are unset, both are defaulted to 1.
- if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
- obj.Spec.Completions = new(int32)
- *obj.Spec.Completions = 1
- obj.Spec.Parallelism = new(int32)
- *obj.Spec.Parallelism = 1
- }
- if obj.Spec.Parallelism == nil {
- obj.Spec.Parallelism = new(int32)
- *obj.Spec.Parallelism = 1
- }
- },
+ SetDefaults_Job,
)
}
+
+func SetDefaults_Job(obj *Job) {
+ // For a non-parallel job, you can leave both `.spec.completions` and
+ // `.spec.parallelism` unset. When both are unset, both are defaulted to 1.
+ if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
+ obj.Spec.Completions = new(int32)
+ *obj.Spec.Completions = 1
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+ if obj.Spec.Parallelism == nil {
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c67cc3a94c4988aa1eb9b145ecdcbd0a15b051d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..95646919d8c0b4825b9b8dc21d06bf2a53ff293e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.pb.go
@@ -0,0 +1,1901 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/batch/v1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/batch/v1/generated.proto
+
+ It has these top-level messages:
+ Job
+ JobCondition
+ JobList
+ JobSpec
+ JobStatus
+ LabelSelector
+ LabelSelectorRequirement
+*/
+package v1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *Job) Reset() { *m = Job{} }
+func (m *Job) String() string { return proto.CompactTextString(m) }
+func (*Job) ProtoMessage() {}
+
+func (m *JobCondition) Reset() { *m = JobCondition{} }
+func (m *JobCondition) String() string { return proto.CompactTextString(m) }
+func (*JobCondition) ProtoMessage() {}
+
+func (m *JobList) Reset() { *m = JobList{} }
+func (m *JobList) String() string { return proto.CompactTextString(m) }
+func (*JobList) ProtoMessage() {}
+
+func (m *JobSpec) Reset() { *m = JobSpec{} }
+func (m *JobSpec) String() string { return proto.CompactTextString(m) }
+func (*JobSpec) ProtoMessage() {}
+
+func (m *JobStatus) Reset() { *m = JobStatus{} }
+func (m *JobStatus) String() string { return proto.CompactTextString(m) }
+func (*JobStatus) ProtoMessage() {}
+
+func (m *LabelSelector) Reset() { *m = LabelSelector{} }
+func (m *LabelSelector) String() string { return proto.CompactTextString(m) }
+func (*LabelSelector) ProtoMessage() {}
+
+func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} }
+func (m *LabelSelectorRequirement) String() string { return proto.CompactTextString(m) }
+func (*LabelSelectorRequirement) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*Job)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.Job")
+ proto.RegisterType((*JobCondition)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.JobCondition")
+ proto.RegisterType((*JobList)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.JobList")
+ proto.RegisterType((*JobSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.JobSpec")
+ proto.RegisterType((*JobStatus)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.JobStatus")
+ proto.RegisterType((*LabelSelector)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.LabelSelector")
+ proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.kubernetes.pkg.apis.batch.v1.LabelSelectorRequirement")
+}
+func (m *Job) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Job) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *JobCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
+ n4, err := m.LastProbeTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n5, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *JobList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n6, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *JobSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n7, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ }
+ if m.ManualSelector != nil {
+ data[i] = 0x28
+ i++
+ if *m.ManualSelector {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n8, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ return i, nil
+}
+
+func (m *JobStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.StartTime != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartTime.Size()))
+ n9, err := m.StartTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ }
+ if m.CompletionTime != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CompletionTime.Size()))
+ n10, err := m.CompletionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n10
+ }
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Active))
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Succeeded))
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Failed))
+ return i, nil
+}
+
+func (m *LabelSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k := range m.MatchLabels {
+ data[i] = 0xa
+ i++
+ v := m.MatchLabels[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, msg := range m.MatchExpressions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LabelSelectorRequirement) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelectorRequirement) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *Job) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastProbeTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *JobSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ n += 1 + sovGenerated(uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ n += 1 + sovGenerated(uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ManualSelector != nil {
+ n += 2
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.StartTime != nil {
+ l = m.StartTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.CompletionTime != nil {
+ l = m.CompletionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.Active))
+ n += 1 + sovGenerated(uint64(m.Succeeded))
+ n += 1 + sovGenerated(uint64(m.Failed))
+ return n
+}
+
+func (m *LabelSelector) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k, v := range m.MatchLabels {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, e := range m.MatchExpressions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LabelSelectorRequirement) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Job) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Job: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = JobConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = k8s_io_kubernetes_pkg_api_v1.ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Job{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Parallelism", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Parallelism = &v
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Completions", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Completions = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ActiveDeadlineSeconds = &v
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ManualSelector", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.ManualSelector = &b
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, JobCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.StartTime == nil {
+ m.StartTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.StartTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CompletionTime == nil {
+ m.CompletionTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.CompletionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
+ }
+ m.Active = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Active |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
+ }
+ m.Succeeded = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Succeeded |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
+ }
+ m.Failed = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Failed |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.MatchLabels == nil {
+ m.MatchLabels = make(map[string]string)
+ }
+ m.MatchLabels[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
+ if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelectorRequirement) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = LabelSelectorOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Values = append(m.Values, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..8d50f7f7281f70fae82c974451849b7f0eaf2834
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/generated.proto
@@ -0,0 +1,177 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.batch.v1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1";
+
+// Job represents the configuration of a single job.
+message Job {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec is a structure defining the expected behavior of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobSpec spec = 2;
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobStatus status = 3;
+}
+
+// JobCondition describes current state of a job.
+message JobCondition {
+ // Type of job condition, Complete or Failed.
+ optional string type = 1;
+
+ // Status of the condition, one of True, False, Unknown.
+ optional string status = 2;
+
+ // Last time the condition was checked.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastProbeTime = 3;
+
+ // Last time the condition transit from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // (brief) reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// JobList is a collection of jobs.
+message JobList {
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Job.
+ repeated Job items = 2;
+}
+
+// JobSpec describes how the job execution will look like.
+message JobSpec {
+ // Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 parallelism = 1;
+
+ // Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 completions = 2;
+
+ // Optional duration in seconds relative to the startTime that the job may be active
+ // before the system tries to terminate it; value must be positive integer
+ optional int64 activeDeadlineSeconds = 3;
+
+ // Selector is a label query over pods that should match the pod count.
+ // Normally, the system sets this field for you.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional LabelSelector selector = 4;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ optional bool manualSelector = 5;
+
+ // Template is the object that describes the pod that will be created when
+ // executing a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 6;
+}
+
+// JobStatus represents the current state of a Job.
+message JobStatus {
+ // Conditions represent the latest available observations of an object's current state.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ repeated JobCondition conditions = 1;
+
+ // StartTime represents time when the job was acknowledged by the Job Manager.
+ // It is not guaranteed to be set in happens-before order across separate operations.
+ // It is represented in RFC3339 form and is in UTC.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startTime = 2;
+
+ // CompletionTime 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.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time completionTime = 3;
+
+ // Active is the number of actively running pods.
+ optional int32 active = 4;
+
+ // Succeeded is the number of pods which reached Phase Succeeded.
+ optional int32 succeeded = 5;
+
+ // Failed is the number of pods which reached Phase Failed.
+ optional int32 failed = 6;
+}
+
+// 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.
+message LabelSelector {
+ // 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.
+ map<string, string> matchLabels = 1;
+
+ // matchExpressions is a list of label selector requirements. The requirements are ANDed.
+ repeated LabelSelectorRequirement matchExpressions = 2;
+}
+
+// A label selector requirement is a selector that contains values, a key, and an operator that
+// relates the key and values.
+message LabelSelectorRequirement {
+ // key is the label key that the selector applies to.
+ optional string key = 1;
+
+ // operator represents a key's relationship to a set of values.
+ // Valid operators ard In, NotIn, Exists and DoesNotExist.
+ optional string operator = 2;
+
+ // 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.
+ repeated string values = 3;
+}
+
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/register.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/v1/register.go
index 49f7376a339ee2babdc78598175a489abe0f84f7..d8c087f1bb96f4f6971ad6e7abe3be157f62fb41 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/register.go
@@ -20,6 +20,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
)
// GroupName is the group name use in this package
@@ -40,8 +41,7 @@ func addKnownTypes(scheme *runtime.Scheme) {
&Job{},
&JobList{},
&v1.ListOptions{},
+ &v1.DeleteOptions{},
)
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
}
-
-func (obj *Job) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *JobList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go
index 2c07db2168e81fbbd8d7e8b180e6c0b79b223a1b..58d5f6f54c77e52eba187063a3d32cca899e97b8 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,10 +29,9 @@ import (
pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
pkg3_types "k8s.io/kubernetes/pkg/types"
- pkg6_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
"reflect"
"runtime"
- pkg5_inf "speter.net/go/exp/math/dec/inf"
time "time"
)
@@ -70,10 +69,9 @@ func init() {
var v1 pkg1_unversioned.TypeMeta
var v2 pkg2_v1.ObjectMeta
var v3 pkg3_types.UID
- var v4 pkg6_intstr.IntOrString
- var v5 pkg5_inf.Dec
- var v6 time.Time
- _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
}
}
@@ -2867,7 +2865,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 640)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 792)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.go
similarity index 68%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.go
index 214ffe6d3d51c99331dd6bf74edf3d2a983ee336..35ec05206e1afb0fe0c751d53e8da8eb37867db3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types.go
@@ -21,31 +21,33 @@ import (
"k8s.io/kubernetes/pkg/api/v1"
)
+// +genclient=true
+
// Job represents the configuration of a single job.
type Job struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec is a structure defining the expected behavior of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec JobSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status is a structure describing current status of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status JobStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status JobStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// JobList is a collection of jobs.
type JobList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of Job.
- Items []Job `json:"items"`
+ Items []Job `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// JobSpec describes how the job execution will look like.
@@ -55,25 +57,25 @@ type JobSpec struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Parallelism *int32 `json:"parallelism,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Parallelism *int32 `json:"parallelism,omitempty" protobuf:"varint,1,opt,name=parallelism"`
// Completions 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Completions *int32 `json:"completions,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Completions *int32 `json:"completions,omitempty" protobuf:"varint,2,opt,name=completions"`
// Optional duration in seconds relative to the startTime that the job may be active
// before the system tries to terminate it; value must be positive integer
- ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`
+ ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty" protobuf:"varint,3,opt,name=activeDeadlineSeconds"`
// Selector is a label query over pods that should match the pod count.
// Normally, the system sets this field for you.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector *LabelSelector `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"`
// ManualSelector controls generation of pod labels and pod selectors.
// Leave `manualSelector` unset unless you are certain what you are doing.
@@ -84,40 +86,40 @@ type JobSpec struct {
// 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: http://releases.k8s.io/release-1.2/docs/design/selector-generation.md
- ManualSelector *bool `json:"manualSelector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ ManualSelector *bool `json:"manualSelector,omitempty" protobuf:"varint,5,opt,name=manualSelector"`
// Template is the object that describes the pod that will be created when
// executing a job.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Template v1.PodTemplateSpec `json:"template"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,6,opt,name=template"`
}
// JobStatus represents the current state of a Job.
type JobStatus struct {
// Conditions represent the latest available observations of an object's current state.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
// StartTime represents time when the job was acknowledged by the Job Manager.
// It is not guaranteed to be set in happens-before order across separate operations.
// It is represented in RFC3339 form and is in UTC.
- StartTime *unversioned.Time `json:"startTime,omitempty"`
+ StartTime *unversioned.Time `json:"startTime,omitempty" protobuf:"bytes,2,opt,name=startTime"`
// CompletionTime 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.
- CompletionTime *unversioned.Time `json:"completionTime,omitempty"`
+ CompletionTime *unversioned.Time `json:"completionTime,omitempty" protobuf:"bytes,3,opt,name=completionTime"`
// Active is the number of actively running pods.
- Active int32 `json:"active,omitempty"`
+ Active int32 `json:"active,omitempty" protobuf:"varint,4,opt,name=active"`
// Succeeded is the number of pods which reached Phase Succeeded.
- Succeeded int32 `json:"succeeded,omitempty"`
+ Succeeded int32 `json:"succeeded,omitempty" protobuf:"varint,5,opt,name=succeeded"`
// Failed is the number of pods which reached Phase Failed.
- Failed int32 `json:"failed,omitempty"`
+ Failed int32 `json:"failed,omitempty" protobuf:"varint,6,opt,name=failed"`
}
type JobConditionType string
@@ -133,17 +135,17 @@ const (
// JobCondition describes current state of a job.
type JobCondition struct {
// Type of job condition, Complete or Failed.
- Type JobConditionType `json:"type"`
+ Type JobConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=JobConditionType"`
// Status of the condition, one of True, False, Unknown.
- Status v1.ConditionStatus `json:"status"`
+ Status v1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/kubernetes/pkg/api/v1.ConditionStatus"`
// Last time the condition was checked.
- LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty" protobuf:"bytes,3,opt,name=lastProbeTime"`
// Last time the condition transit from one status to another.
- LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
// (brief) reason for the condition's last transition.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
// Human readable message indicating details about last transition.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
}
// A label selector is a label query over a set of resources. The result of matchLabels and
@@ -153,24 +155,24 @@ type LabelSelector struct {
// 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.
- MatchLabels map[string]string `json:"matchLabels,omitempty"`
+ MatchLabels map[string]string `json:"matchLabels,omitempty" protobuf:"bytes,1,rep,name=matchLabels"`
// matchExpressions is a list of label selector requirements. The requirements are ANDed.
- MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty"`
+ MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,2,rep,name=matchExpressions"`
}
// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type LabelSelectorRequirement struct {
// key is the label key that the selector applies to.
- Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key"`
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
// operator represents a key's relationship to a set of values.
// Valid operators ard In, NotIn, Exists and DoesNotExist.
- Operator LabelSelectorOperator `json:"operator"`
+ Operator LabelSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=LabelSelectorOperator"`
// 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.
- Values []string `json:"values,omitempty"`
+ Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
}
// A label selector operator is the set of operators that can be used in a selector requirement.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go
index 32e278eac4df2c5fe80b2a8a71e279ca52a2bfc9..21c621abfa0a0d214f9390d2d08b28e1fa506de2 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v1/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,9 +29,9 @@ package v1
// AUTO-GENERATED FUNCTIONS START HERE
var map_Job = map[string]string{
"": "Job represents the configuration of a single job.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec is a structure defining the expected behavior of a job. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec is a structure defining the expected behavior of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Job) SwaggerDoc() map[string]string {
@@ -54,7 +54,7 @@ func (JobCondition) SwaggerDoc() map[string]string {
var map_JobList = map[string]string{
"": "JobList is a collection of jobs.",
- "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is the list of Job.",
}
@@ -64,12 +64,12 @@ func (JobList) SwaggerDoc() map[string]string {
var map_JobSpec = map[string]string{
"": "JobSpec describes how the job execution will look like.",
- "parallelism": "Parallelism 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
- "completions": "Completions 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "parallelism": "Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+ "completions": "Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
"activeDeadlineSeconds": "Optional duration in seconds relative to the startTime that the job may be active before the system tries to terminate it; value must be positive integer",
- "selector": "Selector is a label query over pods that should match the pod count. Normally, the system sets this field for you. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "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: http://releases.k8s.io/release-1.2/docs/design/selector-generation.md",
- "template": "Template is the object that describes the pod that will be created when executing a job. More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "selector": "Selector is a label query over pods that should match the pod count. Normally, the system sets this field for you. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "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: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md",
+ "template": "Template is the object that describes the pod that will be created when executing a job. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
}
func (JobSpec) SwaggerDoc() map[string]string {
@@ -78,7 +78,7 @@ func (JobSpec) SwaggerDoc() map[string]string {
var map_JobStatus = map[string]string{
"": "JobStatus represents the current state of a Job.",
- "conditions": "Conditions represent the latest available observations of an object's current state. More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "conditions": "Conditions represent the latest available observations of an object's current state. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
"startTime": "StartTime represents time when the job was acknowledged by the Job Manager. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC.",
"completionTime": "CompletionTime 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.",
"active": "Active is the number of actively running pods.",
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion.go
new file mode 100644
index 0000000000000000000000000000000000000000..4714fda0fb3e8fdc3dabcc623f4becd0e0e4e0cc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion.go
@@ -0,0 +1,116 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v2alpha1
+
+import (
+ "fmt"
+ "reflect"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/batch"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addConversionFuncs(scheme *runtime.Scheme) {
+ // Add non-generated conversion functions
+ err := scheme.AddConversionFuncs(
+ Convert_batch_JobSpec_To_v2alpha1_JobSpec,
+ Convert_v2alpha1_JobSpec_To_batch_JobSpec,
+ )
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+
+ // Add field label conversions for kinds having selectable nothing but ObjectMeta fields.
+ for _, kind := range []string{"Job", "JobTemplate", "ScheduledJob"} {
+ err = api.Scheme.AddFieldLabelConversionFunc("batch/v2alpha1", kind,
+ func(label, value string) (string, string, error) {
+ switch label {
+ case "metadata.name", "metadata.namespace", "status.successful":
+ return label, value, nil
+ default:
+ return "", "", fmt.Errorf("field label not supported: %s", label)
+ }
+ })
+ }
+ if err != nil {
+ // If one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func Convert_batch_JobSpec_To_v2alpha1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
+ if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
+ defaulting.(func(*batch.JobSpec))(in)
+ }
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1.LabelSelector
+ if in.Selector != nil {
+ out.Selector = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in.Selector, out.Selector, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ out.ManualSelector = new(bool)
+ *out.ManualSelector = *in.ManualSelector
+ } else {
+ out.ManualSelector = nil
+ }
+
+ if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
+ if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
+ defaulting.(func(*JobSpec))(in)
+ }
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ // unable to generate simple pointer conversion for unversioned.LabelSelector -> v1.LabelSelector
+ if in.Selector != nil {
+ out.Selector = new(unversioned.LabelSelector)
+ if err := Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in.Selector, out.Selector, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ out.ManualSelector = new(bool)
+ *out.ManualSelector = *in.ManualSelector
+ } else {
+ out.ManualSelector = nil
+ }
+
+ if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..c411875e37f4093ac691040a2a55ccff8ae6ba6f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/conversion_generated.go
@@ -0,0 +1,573 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v2alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v2alpha1_Job_To_batch_Job,
+ Convert_batch_Job_To_v2alpha1_Job,
+ Convert_v2alpha1_JobCondition_To_batch_JobCondition,
+ Convert_batch_JobCondition_To_v2alpha1_JobCondition,
+ Convert_v2alpha1_JobList_To_batch_JobList,
+ Convert_batch_JobList_To_v2alpha1_JobList,
+ Convert_v2alpha1_JobSpec_To_batch_JobSpec,
+ Convert_batch_JobSpec_To_v2alpha1_JobSpec,
+ Convert_v2alpha1_JobStatus_To_batch_JobStatus,
+ Convert_batch_JobStatus_To_v2alpha1_JobStatus,
+ Convert_v2alpha1_JobTemplate_To_batch_JobTemplate,
+ Convert_batch_JobTemplate_To_v2alpha1_JobTemplate,
+ Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec,
+ Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec,
+ Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector,
+ Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector,
+ Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
+ Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement,
+ Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob,
+ Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob,
+ Convert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList,
+ Convert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList,
+ Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec,
+ Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec,
+ Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus,
+ Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v2alpha1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ SetDefaults_Job(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ return autoConvert_v2alpha1_Job_To_batch_Job(in, out, s)
+}
+
+func autoConvert_batch_Job_To_v2alpha1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobSpec_To_v2alpha1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobStatus_To_v2alpha1_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_Job_To_v2alpha1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ return autoConvert_batch_Job_To_v2alpha1_Job(in, out, s)
+}
+
+func autoConvert_v2alpha1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ out.Type = batch.JobConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v2alpha1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ return autoConvert_v2alpha1_JobCondition_To_batch_JobCondition(in, out, s)
+}
+
+func autoConvert_batch_JobCondition_To_v2alpha1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ out.Type = JobConditionType(in.Type)
+ out.Status = v1.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_batch_JobCondition_To_v2alpha1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ return autoConvert_batch_JobCondition_To_v2alpha1_JobCondition(in, out, s)
+}
+
+func autoConvert_v2alpha1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]batch.Job, len(*in))
+ for i := range *in {
+ if err := Convert_v2alpha1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v2alpha1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ return autoConvert_v2alpha1_JobList_To_batch_JobList(in, out, s)
+}
+
+func autoConvert_batch_JobList_To_v2alpha1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Job, len(*in))
+ for i := range *in {
+ if err := Convert_batch_Job_To_v2alpha1_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_batch_JobList_To_v2alpha1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ return autoConvert_batch_JobList_To_v2alpha1_JobList(in, out, s)
+}
+
+func autoConvert_v2alpha1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.ManualSelector = in.ManualSelector
+ if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_batch_JobSpec_To_v2alpha1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.ManualSelector = in.ManualSelector
+ if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func autoConvert_v2alpha1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]batch.JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v2alpha1_JobCondition_To_batch_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_v2alpha1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ return autoConvert_v2alpha1_JobStatus_To_batch_JobStatus(in, out, s)
+}
+
+func autoConvert_batch_JobStatus_To_v2alpha1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_batch_JobCondition_To_v2alpha1_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_batch_JobStatus_To_v2alpha1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ return autoConvert_batch_JobStatus_To_v2alpha1_JobStatus(in, out, s)
+}
+
+func autoConvert_v2alpha1_JobTemplate_To_batch_JobTemplate(in *JobTemplate, out *batch.JobTemplate, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_JobTemplate_To_batch_JobTemplate(in *JobTemplate, out *batch.JobTemplate, s conversion.Scope) error {
+ return autoConvert_v2alpha1_JobTemplate_To_batch_JobTemplate(in, out, s)
+}
+
+func autoConvert_batch_JobTemplate_To_v2alpha1_JobTemplate(in *batch.JobTemplate, out *JobTemplate, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_JobTemplate_To_v2alpha1_JobTemplate(in *batch.JobTemplate, out *JobTemplate, s conversion.Scope) error {
+ return autoConvert_batch_JobTemplate_To_v2alpha1_JobTemplate(in, out, s)
+}
+
+func autoConvert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in *JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in *JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
+ return autoConvert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(in, out, s)
+}
+
+func autoConvert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in *batch.JobTemplateSpec, out *JobTemplateSpec, s conversion.Scope) error {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobSpec_To_v2alpha1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in *batch.JobTemplateSpec, out *JobTemplateSpec, s conversion.Scope) error {
+ return autoConvert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(in, out, s)
+}
+
+func autoConvert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]unversioned.LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ return autoConvert_v2alpha1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelector_To_v2alpha1_LabelSelector(in, out, s)
+}
+
+func autoConvert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = unversioned.LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_v2alpha1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequirement(in, out, s)
+}
+
+func autoConvert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in *ScheduledJob, out *batch.ScheduledJob, s conversion.Scope) error {
+ SetDefaults_ScheduledJob(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in *ScheduledJob, out *batch.ScheduledJob, s conversion.Scope) error {
+ return autoConvert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in, out, s)
+}
+
+func autoConvert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in *batch.ScheduledJob, out *ScheduledJob, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in *batch.ScheduledJob, out *ScheduledJob, s conversion.Scope) error {
+ return autoConvert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(in, out, s)
+}
+
+func autoConvert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in *ScheduledJobList, out *batch.ScheduledJobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]batch.ScheduledJob, len(*in))
+ for i := range *in {
+ if err := Convert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in *ScheduledJobList, out *batch.ScheduledJobList, s conversion.Scope) error {
+ return autoConvert_v2alpha1_ScheduledJobList_To_batch_ScheduledJobList(in, out, s)
+}
+
+func autoConvert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in *batch.ScheduledJobList, out *ScheduledJobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ScheduledJob, len(*in))
+ for i := range *in {
+ if err := Convert_batch_ScheduledJob_To_v2alpha1_ScheduledJob(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in *batch.ScheduledJobList, out *ScheduledJobList, s conversion.Scope) error {
+ return autoConvert_batch_ScheduledJobList_To_v2alpha1_ScheduledJobList(in, out, s)
+}
+
+func autoConvert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in *ScheduledJobSpec, out *batch.ScheduledJobSpec, s conversion.Scope) error {
+ out.Schedule = in.Schedule
+ out.StartingDeadlineSeconds = in.StartingDeadlineSeconds
+ out.ConcurrencyPolicy = batch.ConcurrencyPolicy(in.ConcurrencyPolicy)
+ out.Suspend = in.Suspend
+ if err := Convert_v2alpha1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in *ScheduledJobSpec, out *batch.ScheduledJobSpec, s conversion.Scope) error {
+ return autoConvert_v2alpha1_ScheduledJobSpec_To_batch_ScheduledJobSpec(in, out, s)
+}
+
+func autoConvert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in *batch.ScheduledJobSpec, out *ScheduledJobSpec, s conversion.Scope) error {
+ out.Schedule = in.Schedule
+ out.StartingDeadlineSeconds = in.StartingDeadlineSeconds
+ out.ConcurrencyPolicy = ConcurrencyPolicy(in.ConcurrencyPolicy)
+ out.Suspend = in.Suspend
+ if err := Convert_batch_JobTemplateSpec_To_v2alpha1_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in *batch.ScheduledJobSpec, out *ScheduledJobSpec, s conversion.Scope) error {
+ return autoConvert_batch_ScheduledJobSpec_To_v2alpha1_ScheduledJobSpec(in, out, s)
+}
+
+func autoConvert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in *ScheduledJobStatus, out *batch.ScheduledJobStatus, s conversion.Scope) error {
+ if in.Active != nil {
+ in, out := &in.Active, &out.Active
+ *out = make([]api.ObjectReference, len(*in))
+ for i := range *in {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Active = nil
+ }
+ out.LastScheduleTime = in.LastScheduleTime
+ return nil
+}
+
+func Convert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in *ScheduledJobStatus, out *batch.ScheduledJobStatus, s conversion.Scope) error {
+ return autoConvert_v2alpha1_ScheduledJobStatus_To_batch_ScheduledJobStatus(in, out, s)
+}
+
+func autoConvert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in *batch.ScheduledJobStatus, out *ScheduledJobStatus, s conversion.Scope) error {
+ if in.Active != nil {
+ in, out := &in.Active, &out.Active
+ *out = make([]v1.ObjectReference, len(*in))
+ for i := range *in {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&(*in)[i], &(*out)[i], 0); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Active = nil
+ }
+ out.LastScheduleTime = in.LastScheduleTime
+ return nil
+}
+
+func Convert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in *batch.ScheduledJobStatus, out *ScheduledJobStatus, s conversion.Scope) error {
+ return autoConvert_batch_ScheduledJobStatus_To_v2alpha1_ScheduledJobStatus(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..92cb71ea080c508dcc8db3fd72d1fcee2347b227
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/deep_copy_generated.go
@@ -0,0 +1,324 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v2alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v2alpha1_Job,
+ DeepCopy_v2alpha1_JobCondition,
+ DeepCopy_v2alpha1_JobList,
+ DeepCopy_v2alpha1_JobSpec,
+ DeepCopy_v2alpha1_JobStatus,
+ DeepCopy_v2alpha1_JobTemplate,
+ DeepCopy_v2alpha1_JobTemplateSpec,
+ DeepCopy_v2alpha1_LabelSelector,
+ DeepCopy_v2alpha1_LabelSelectorRequirement,
+ DeepCopy_v2alpha1_ScheduledJob,
+ DeepCopy_v2alpha1_ScheduledJobList,
+ DeepCopy_v2alpha1_ScheduledJobSpec,
+ DeepCopy_v2alpha1_ScheduledJobStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v2alpha1_Job(in Job, out *Job, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_JobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Job, len(in))
+ for i := range in {
+ if err := DeepCopy_v2alpha1_Job(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
+ if in.Parallelism != nil {
+ in, out := in.Parallelism, &out.Parallelism
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Parallelism = nil
+ }
+ if in.Completions != nil {
+ in, out := in.Completions, &out.Completions
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Completions = nil
+ }
+ if in.ActiveDeadlineSeconds != nil {
+ in, out := in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ActiveDeadlineSeconds = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v2alpha1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.ManualSelector != nil {
+ in, out := in.ManualSelector, &out.ManualSelector
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.ManualSelector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v2alpha1_JobCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.StartTime != nil {
+ in, out := in.StartTime, &out.StartTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.StartTime = nil
+ }
+ if in.CompletionTime != nil {
+ in, out := in.CompletionTime, &out.CompletionTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CompletionTime = nil
+ }
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobTemplate(in JobTemplate, out *JobTemplate, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_JobTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_JobTemplateSpec(in JobTemplateSpec, out *JobTemplateSpec, c *conversion.Cloner) error {
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
+ if in.MatchLabels != nil {
+ in, out := in.MatchLabels, &out.MatchLabels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.MatchLabels = nil
+ }
+ if in.MatchExpressions != nil {
+ in, out := in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(in))
+ for i := range in {
+ if err := DeepCopy_v2alpha1_LabelSelectorRequirement(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ if in.Values != nil {
+ in, out := in.Values, &out.Values
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Values = nil
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_ScheduledJob(in ScheduledJob, out *ScheduledJob, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_ScheduledJobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v2alpha1_ScheduledJobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_ScheduledJobList(in ScheduledJobList, out *ScheduledJobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ScheduledJob, len(in))
+ for i := range in {
+ if err := DeepCopy_v2alpha1_ScheduledJob(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_ScheduledJobSpec(in ScheduledJobSpec, out *ScheduledJobSpec, c *conversion.Cloner) error {
+ out.Schedule = in.Schedule
+ if in.StartingDeadlineSeconds != nil {
+ in, out := in.StartingDeadlineSeconds, &out.StartingDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.StartingDeadlineSeconds = nil
+ }
+ out.ConcurrencyPolicy = in.ConcurrencyPolicy
+ if in.Suspend != nil {
+ in, out := in.Suspend, &out.Suspend
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.Suspend = nil
+ }
+ if err := DeepCopy_v2alpha1_JobTemplateSpec(in.JobTemplate, &out.JobTemplate, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v2alpha1_ScheduledJobStatus(in ScheduledJobStatus, out *ScheduledJobStatus, c *conversion.Cloner) error {
+ if in.Active != nil {
+ in, out := in.Active, &out.Active
+ *out = make([]v1.ObjectReference, len(in))
+ for i := range in {
+ if err := v1.DeepCopy_v1_ObjectReference(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Active = nil
+ }
+ if in.LastScheduleTime != nil {
+ in, out := in.LastScheduleTime, &out.LastScheduleTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LastScheduleTime = nil
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..72da797c77f781fde9348f2beecd0bf52aee3778
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/defaults.go
@@ -0,0 +1,49 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v2alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_Job,
+ SetDefaults_ScheduledJob,
+ )
+}
+
+func SetDefaults_Job(obj *Job) {
+ // For a non-parallel job, you can leave both `.spec.completions` and
+ // `.spec.parallelism` unset. When both are unset, both are defaulted to 1.
+ if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
+ obj.Spec.Completions = new(int32)
+ *obj.Spec.Completions = 1
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+ if obj.Spec.Parallelism == nil {
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+}
+
+func SetDefaults_ScheduledJob(obj *ScheduledJob) {
+ if obj.Spec.ConcurrencyPolicy == "" {
+ obj.Spec.ConcurrencyPolicy = AllowConcurrent
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e6b67b5894e6c1d13db064971649af9b484f4f6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v2alpha1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..17192c01c4836d8e7d165475fe64f5f5525f637f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.pb.go
@@ -0,0 +1,3018 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v2alpha1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
+
+ It has these top-level messages:
+ Job
+ JobCondition
+ JobList
+ JobSpec
+ JobStatus
+ JobTemplate
+ JobTemplateSpec
+ LabelSelector
+ LabelSelectorRequirement
+ ScheduledJob
+ ScheduledJobList
+ ScheduledJobSpec
+ ScheduledJobStatus
+*/
+package v2alpha1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *Job) Reset() { *m = Job{} }
+func (m *Job) String() string { return proto.CompactTextString(m) }
+func (*Job) ProtoMessage() {}
+
+func (m *JobCondition) Reset() { *m = JobCondition{} }
+func (m *JobCondition) String() string { return proto.CompactTextString(m) }
+func (*JobCondition) ProtoMessage() {}
+
+func (m *JobList) Reset() { *m = JobList{} }
+func (m *JobList) String() string { return proto.CompactTextString(m) }
+func (*JobList) ProtoMessage() {}
+
+func (m *JobSpec) Reset() { *m = JobSpec{} }
+func (m *JobSpec) String() string { return proto.CompactTextString(m) }
+func (*JobSpec) ProtoMessage() {}
+
+func (m *JobStatus) Reset() { *m = JobStatus{} }
+func (m *JobStatus) String() string { return proto.CompactTextString(m) }
+func (*JobStatus) ProtoMessage() {}
+
+func (m *JobTemplate) Reset() { *m = JobTemplate{} }
+func (m *JobTemplate) String() string { return proto.CompactTextString(m) }
+func (*JobTemplate) ProtoMessage() {}
+
+func (m *JobTemplateSpec) Reset() { *m = JobTemplateSpec{} }
+func (m *JobTemplateSpec) String() string { return proto.CompactTextString(m) }
+func (*JobTemplateSpec) ProtoMessage() {}
+
+func (m *LabelSelector) Reset() { *m = LabelSelector{} }
+func (m *LabelSelector) String() string { return proto.CompactTextString(m) }
+func (*LabelSelector) ProtoMessage() {}
+
+func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} }
+func (m *LabelSelectorRequirement) String() string { return proto.CompactTextString(m) }
+func (*LabelSelectorRequirement) ProtoMessage() {}
+
+func (m *ScheduledJob) Reset() { *m = ScheduledJob{} }
+func (m *ScheduledJob) String() string { return proto.CompactTextString(m) }
+func (*ScheduledJob) ProtoMessage() {}
+
+func (m *ScheduledJobList) Reset() { *m = ScheduledJobList{} }
+func (m *ScheduledJobList) String() string { return proto.CompactTextString(m) }
+func (*ScheduledJobList) ProtoMessage() {}
+
+func (m *ScheduledJobSpec) Reset() { *m = ScheduledJobSpec{} }
+func (m *ScheduledJobSpec) String() string { return proto.CompactTextString(m) }
+func (*ScheduledJobSpec) ProtoMessage() {}
+
+func (m *ScheduledJobStatus) Reset() { *m = ScheduledJobStatus{} }
+func (m *ScheduledJobStatus) String() string { return proto.CompactTextString(m) }
+func (*ScheduledJobStatus) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*Job)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.Job")
+ proto.RegisterType((*JobCondition)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobCondition")
+ proto.RegisterType((*JobList)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobList")
+ proto.RegisterType((*JobSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobSpec")
+ proto.RegisterType((*JobStatus)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobStatus")
+ proto.RegisterType((*JobTemplate)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobTemplate")
+ proto.RegisterType((*JobTemplateSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobTemplateSpec")
+ proto.RegisterType((*LabelSelector)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.LabelSelector")
+ proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.LabelSelectorRequirement")
+ proto.RegisterType((*ScheduledJob)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.ScheduledJob")
+ proto.RegisterType((*ScheduledJobList)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.ScheduledJobList")
+ proto.RegisterType((*ScheduledJobSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.ScheduledJobSpec")
+ proto.RegisterType((*ScheduledJobStatus)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.ScheduledJobStatus")
+}
+func (m *Job) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Job) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *JobCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
+ n4, err := m.LastProbeTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n5, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *JobList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n6, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *JobSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n7, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ }
+ if m.ManualSelector != nil {
+ data[i] = 0x28
+ i++
+ if *m.ManualSelector {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n8, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ return i, nil
+}
+
+func (m *JobStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.StartTime != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartTime.Size()))
+ n9, err := m.StartTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ }
+ if m.CompletionTime != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CompletionTime.Size()))
+ n10, err := m.CompletionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n10
+ }
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Active))
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Succeeded))
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Failed))
+ return i, nil
+}
+
+func (m *JobTemplate) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobTemplate) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n11, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n11
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n12, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n12
+ return i, nil
+}
+
+func (m *JobTemplateSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobTemplateSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n13, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n13
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n14, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n14
+ return i, nil
+}
+
+func (m *LabelSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k := range m.MatchLabels {
+ data[i] = 0xa
+ i++
+ v := m.MatchLabels[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, msg := range m.MatchExpressions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LabelSelectorRequirement) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelectorRequirement) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ScheduledJob) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScheduledJob) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n15, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n15
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n16, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n16
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n17, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n17
+ return i, nil
+}
+
+func (m *ScheduledJobList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScheduledJobList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n18, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n18
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ScheduledJobSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScheduledJobSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Schedule)))
+ i += copy(data[i:], m.Schedule)
+ if m.StartingDeadlineSeconds != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.StartingDeadlineSeconds))
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ConcurrencyPolicy)))
+ i += copy(data[i:], m.ConcurrencyPolicy)
+ if m.Suspend != nil {
+ data[i] = 0x20
+ i++
+ if *m.Suspend {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.JobTemplate.Size()))
+ n19, err := m.JobTemplate.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n19
+ return i, nil
+}
+
+func (m *ScheduledJobStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScheduledJobStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Active) > 0 {
+ for _, msg := range m.Active {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.LastScheduleTime != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastScheduleTime.Size()))
+ n20, err := m.LastScheduleTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n20
+ }
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *Job) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastProbeTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *JobSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ n += 1 + sovGenerated(uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ n += 1 + sovGenerated(uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.ManualSelector != nil {
+ n += 2
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.StartTime != nil {
+ l = m.StartTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.CompletionTime != nil {
+ l = m.CompletionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.Active))
+ n += 1 + sovGenerated(uint64(m.Succeeded))
+ n += 1 + sovGenerated(uint64(m.Failed))
+ return n
+}
+
+func (m *JobTemplate) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobTemplateSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *LabelSelector) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k, v := range m.MatchLabels {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, e := range m.MatchExpressions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LabelSelectorRequirement) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ScheduledJob) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ScheduledJobList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ScheduledJobSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Schedule)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.StartingDeadlineSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.StartingDeadlineSeconds))
+ }
+ l = len(m.ConcurrencyPolicy)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Suspend != nil {
+ n += 2
+ }
+ l = m.JobTemplate.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ScheduledJobStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Active) > 0 {
+ for _, e := range m.Active {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.LastScheduleTime != nil {
+ l = m.LastScheduleTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Job) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Job: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = JobConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = k8s_io_kubernetes_pkg_api_v1.ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Job{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Parallelism", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Parallelism = &v
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Completions", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Completions = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ActiveDeadlineSeconds = &v
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ManualSelector", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.ManualSelector = &b
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, JobCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.StartTime == nil {
+ m.StartTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.StartTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CompletionTime == nil {
+ m.CompletionTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.CompletionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
+ }
+ m.Active = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Active |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
+ }
+ m.Succeeded = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Succeeded |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
+ }
+ m.Failed = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Failed |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobTemplate) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobTemplate: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobTemplateSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobTemplateSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.MatchLabels == nil {
+ m.MatchLabels = make(map[string]string)
+ }
+ m.MatchLabels[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
+ if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelectorRequirement) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = LabelSelectorOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Values = append(m.Values, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScheduledJob) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScheduledJob: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScheduledJob: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScheduledJobList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScheduledJobList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScheduledJobList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ScheduledJob{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScheduledJobSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScheduledJobSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScheduledJobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Schedule", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Schedule = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartingDeadlineSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.StartingDeadlineSeconds = &v
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ConcurrencyPolicy", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ConcurrencyPolicy = ConcurrencyPolicy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Suspend", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.Suspend = &b
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field JobTemplate", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.JobTemplate.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScheduledJobStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScheduledJobStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScheduledJobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Active = append(m.Active, k8s_io_kubernetes_pkg_api_v1.ObjectReference{})
+ if err := m.Active[len(m.Active)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastScheduleTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.LastScheduleTime == nil {
+ m.LastScheduleTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.LastScheduleTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5098f5166a9892a5681df53b2726249471d2d7b8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
@@ -0,0 +1,254 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.batch.v2alpha1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v2alpha1";
+
+// Job represents the configuration of a single job.
+message Job {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec is a structure defining the expected behavior of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobSpec spec = 2;
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobStatus status = 3;
+}
+
+// JobCondition describes current state of a job.
+message JobCondition {
+ // Type of job condition, Complete or Failed.
+ optional string type = 1;
+
+ // Status of the condition, one of True, False, Unknown.
+ optional string status = 2;
+
+ // Last time the condition was checked.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastProbeTime = 3;
+
+ // Last time the condition transit from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // (brief) reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// JobList is a collection of jobs.
+message JobList {
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Job.
+ repeated Job items = 2;
+}
+
+// JobSpec describes how the job execution will look like.
+message JobSpec {
+ // Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 parallelism = 1;
+
+ // Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 completions = 2;
+
+ // Optional duration in seconds relative to the startTime that the job may be active
+ // before the system tries to terminate it; value must be positive integer
+ optional int64 activeDeadlineSeconds = 3;
+
+ // Selector is a label query over pods that should match the pod count.
+ // Normally, the system sets this field for you.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional LabelSelector selector = 4;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ optional bool manualSelector = 5;
+
+ // Template is the object that describes the pod that will be created when
+ // executing a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 6;
+}
+
+// JobStatus represents the current state of a Job.
+message JobStatus {
+ // Conditions represent the latest available observations of an object's current state.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ repeated JobCondition conditions = 1;
+
+ // StartTime represents time when the job was acknowledged by the Job Manager.
+ // It is not guaranteed to be set in happens-before order across separate operations.
+ // It is represented in RFC3339 form and is in UTC.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startTime = 2;
+
+ // CompletionTime 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.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time completionTime = 3;
+
+ // Active is the number of actively running pods.
+ optional int32 active = 4;
+
+ // Succeeded is the number of pods which reached Phase Succeeded.
+ optional int32 succeeded = 5;
+
+ // Failed is the number of pods which reached Phase Failed.
+ optional int32 failed = 6;
+}
+
+// JobTemplate describes a template for creating copies of a predefined pod.
+message JobTemplate {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Template defines jobs that will be created from this template
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobTemplateSpec template = 2;
+}
+
+// JobTemplateSpec describes the data a Job should have when created from a template
+message JobTemplateSpec {
+ // Standard object's metadata of the jobs created from this template.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior of the job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobSpec spec = 2;
+}
+
+// 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.
+message LabelSelector {
+ // 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.
+ map<string, string> matchLabels = 1;
+
+ // matchExpressions is a list of label selector requirements. The requirements are ANDed.
+ repeated LabelSelectorRequirement matchExpressions = 2;
+}
+
+// A label selector requirement is a selector that contains values, a key, and an operator that
+// relates the key and values.
+message LabelSelectorRequirement {
+ // key is the label key that the selector applies to.
+ optional string key = 1;
+
+ // operator represents a key's relationship to a set of values.
+ // Valid operators ard In, NotIn, Exists and DoesNotExist.
+ optional string operator = 2;
+
+ // 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.
+ repeated string values = 3;
+}
+
+// ScheduledJob represents the configuration of a single scheduled job.
+message ScheduledJob {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec is a structure defining the expected behavior of a job, including the schedule.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ScheduledJobSpec spec = 2;
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ScheduledJobStatus status = 3;
+}
+
+// ScheduledJobList is a collection of scheduled jobs.
+message ScheduledJobList {
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of ScheduledJob.
+ repeated ScheduledJob items = 2;
+}
+
+// ScheduledJobSpec describes how the job execution will look like and when it will actually run.
+message ScheduledJobSpec {
+ // Schedule contains the schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.
+ optional string schedule = 1;
+
+ // 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.
+ optional int64 startingDeadlineSeconds = 2;
+
+ // ConcurrencyPolicy specifies how to treat concurrent executions of a Job.
+ optional string concurrencyPolicy = 3;
+
+ // Suspend flag tells the controller to suspend subsequent executions, it does
+ // not apply to already started executions. Defaults to false.
+ optional bool suspend = 4;
+
+ // JobTemplate is the object that describes the job that will be created when
+ // executing a ScheduledJob.
+ optional JobTemplateSpec jobTemplate = 5;
+}
+
+// ScheduledJobStatus represents the current state of a Job.
+message ScheduledJobStatus {
+ // Active holds pointers to currently running jobs.
+ repeated k8s.io.kubernetes.pkg.api.v1.ObjectReference active = 1;
+
+ // LastScheduleTime keeps information of when was the last time the job was successfully scheduled.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastScheduleTime = 4;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..00142f018a72f53f3f597215bdcbbfee6a584976
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/register.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v2alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "batch"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v2alpha1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Job{},
+ &JobList{},
+ &JobTemplate{},
+ &ScheduledJob{},
+ &ScheduledJobList{},
+ &v1.ListOptions{},
+ &v1.DeleteOptions{},
+ )
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..341d1d217a1d5cfb0366285e5b442d14335cba58
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.generated.go
@@ -0,0 +1,5310 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v2alpha1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
+ pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
+ pkg3_types "k8s.io/kubernetes/pkg/types"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg4_resource.Quantity
+ var v1 pkg1_unversioned.TypeMeta
+ var v2 pkg2_v1.ObjectMeta
+ var v3 pkg3_types.UID
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
+ }
+}
+
+func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = JobStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = JobStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceJob(([]Job)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceJob(([]Job)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceJob((*[]Job)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceJob((*[]Job)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobTemplate) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Template
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Template
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobTemplate) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = JobTemplateSpec{}
+ } else {
+ yyv5 := &x.Template
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv9 := &x.ObjectMeta
+ yyv9.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = JobTemplateSpec{}
+ } else {
+ yyv10 := &x.Template
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobTemplateSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobTemplateSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv7 := &x.ObjectMeta
+ yyv7.CodecDecodeSelf(d)
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = JobSpec{}
+ } else {
+ yyv8 := &x.Spec
+ yyv8.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Parallelism != nil
+ yyq2[1] = x.Completions != nil
+ yyq2[2] = x.ActiveDeadlineSeconds != nil
+ yyq2[3] = x.Selector != nil
+ yyq2[4] = x.ManualSelector != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Parallelism == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.Parallelism
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(yy4))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Parallelism == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.Parallelism
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(yy6))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Completions == nil {
+ r.EncodeNil()
+ } else {
+ yy9 := *x.Completions
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(yy9))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("completions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Completions == nil {
+ r.EncodeNil()
+ } else {
+ yy11 := *x.Completions
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeInt(int64(yy11))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.ActiveDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy14 := *x.ActiveDeadlineSeconds
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeInt(int64(yy14))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ActiveDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy16 := *x.ActiveDeadlineSeconds
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeInt(int64(yy16))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ x.Selector.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ x.Selector.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.ManualSelector == nil {
+ r.EncodeNil()
+ } else {
+ yy22 := *x.ManualSelector
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeBool(bool(yy22))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("manualSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ManualSelector == nil {
+ r.EncodeNil()
+ } else {
+ yy24 := *x.ManualSelector
+ yym25 := z.EncBinary()
+ _ = yym25
+ if false {
+ } else {
+ r.EncodeBool(bool(yy24))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy27 := &x.Template
+ yy27.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy29 := &x.Template
+ yy29.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "parallelism":
+ if r.TryDecodeAsNil() {
+ if x.Parallelism != nil {
+ x.Parallelism = nil
+ }
+ } else {
+ if x.Parallelism == nil {
+ x.Parallelism = new(int32)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ *((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "completions":
+ if r.TryDecodeAsNil() {
+ if x.Completions != nil {
+ x.Completions = nil
+ }
+ } else {
+ if x.Completions == nil {
+ x.Completions = new(int32)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ *((*int32)(x.Completions)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "activeDeadlineSeconds":
+ if r.TryDecodeAsNil() {
+ if x.ActiveDeadlineSeconds != nil {
+ x.ActiveDeadlineSeconds = nil
+ }
+ } else {
+ if x.ActiveDeadlineSeconds == nil {
+ x.ActiveDeadlineSeconds = new(int64)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(LabelSelector)
+ }
+ x.Selector.CodecDecodeSelf(d)
+ }
+ case "manualSelector":
+ if r.TryDecodeAsNil() {
+ if x.ManualSelector != nil {
+ x.ManualSelector = nil
+ }
+ } else {
+ if x.ManualSelector == nil {
+ x.ManualSelector = new(bool)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ *((*bool)(x.ManualSelector)) = r.DecodeBool()
+ }
+ }
+ case "template":
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_v1.PodTemplateSpec{}
+ } else {
+ yyv13 := &x.Template
+ yyv13.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj14 int
+ var yyb14 bool
+ var yyhl14 bool = l >= 0
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Parallelism != nil {
+ x.Parallelism = nil
+ }
+ } else {
+ if x.Parallelism == nil {
+ x.Parallelism = new(int32)
+ }
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else {
+ *((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Completions != nil {
+ x.Completions = nil
+ }
+ } else {
+ if x.Completions == nil {
+ x.Completions = new(int32)
+ }
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ *((*int32)(x.Completions)) = int32(r.DecodeInt(32))
+ }
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ActiveDeadlineSeconds != nil {
+ x.ActiveDeadlineSeconds = nil
+ }
+ } else {
+ if x.ActiveDeadlineSeconds == nil {
+ x.ActiveDeadlineSeconds = new(int64)
+ }
+ yym20 := z.DecBinary()
+ _ = yym20
+ if false {
+ } else {
+ *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(LabelSelector)
+ }
+ x.Selector.CodecDecodeSelf(d)
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.ManualSelector != nil {
+ x.ManualSelector = nil
+ }
+ } else {
+ if x.ManualSelector == nil {
+ x.ManualSelector = new(bool)
+ }
+ yym23 := z.DecBinary()
+ _ = yym23
+ if false {
+ } else {
+ *((*bool)(x.ManualSelector)) = r.DecodeBool()
+ }
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Template = pkg2_v1.PodTemplateSpec{}
+ } else {
+ yyv24 := &x.Template
+ yyv24.CodecDecodeSelf(d)
+ }
+ for {
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj14-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Conditions) != 0
+ yyq2[1] = x.StartTime != nil
+ yyq2[2] = x.CompletionTime != nil
+ yyq2[3] = x.Active != 0
+ yyq2[4] = x.Succeeded != 0
+ yyq2[5] = x.Failed != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("conditions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Conditions == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.StartTime == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.StartTime) {
+ } else if yym7 {
+ z.EncBinaryMarshal(x.StartTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.StartTime)
+ } else {
+ z.EncFallback(x.StartTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("startTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.StartTime == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.StartTime) {
+ } else if yym8 {
+ z.EncBinaryMarshal(x.StartTime)
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.StartTime)
+ } else {
+ z.EncFallback(x.StartTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.CompletionTime == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
+ } else if yym10 {
+ z.EncBinaryMarshal(x.CompletionTime)
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.CompletionTime)
+ } else {
+ z.EncFallback(x.CompletionTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.CompletionTime == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
+ } else if yym11 {
+ z.EncBinaryMarshal(x.CompletionTime)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.CompletionTime)
+ } else {
+ z.EncFallback(x.CompletionTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Active))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("active"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Active))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Succeeded))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Succeeded))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Failed))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("failed"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Failed))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "conditions":
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv4 := &x.Conditions
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceJobCondition((*[]JobCondition)(yyv4), d)
+ }
+ }
+ case "startTime":
+ if r.TryDecodeAsNil() {
+ if x.StartTime != nil {
+ x.StartTime = nil
+ }
+ } else {
+ if x.StartTime == nil {
+ x.StartTime = new(pkg1_unversioned.Time)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.StartTime) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(x.StartTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.StartTime)
+ } else {
+ z.DecFallback(x.StartTime, false)
+ }
+ }
+ case "completionTime":
+ if r.TryDecodeAsNil() {
+ if x.CompletionTime != nil {
+ x.CompletionTime = nil
+ }
+ } else {
+ if x.CompletionTime == nil {
+ x.CompletionTime = new(pkg1_unversioned.Time)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(x.CompletionTime)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.CompletionTime)
+ } else {
+ z.DecFallback(x.CompletionTime, false)
+ }
+ }
+ case "active":
+ if r.TryDecodeAsNil() {
+ x.Active = 0
+ } else {
+ x.Active = int32(r.DecodeInt(32))
+ }
+ case "succeeded":
+ if r.TryDecodeAsNil() {
+ x.Succeeded = 0
+ } else {
+ x.Succeeded = int32(r.DecodeInt(32))
+ }
+ case "failed":
+ if r.TryDecodeAsNil() {
+ x.Failed = 0
+ } else {
+ x.Failed = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj13 int
+ var yyb13 bool
+ var yyhl13 bool = l >= 0
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Conditions = nil
+ } else {
+ yyv14 := &x.Conditions
+ yym15 := z.DecBinary()
+ _ = yym15
+ if false {
+ } else {
+ h.decSliceJobCondition((*[]JobCondition)(yyv14), d)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.StartTime != nil {
+ x.StartTime = nil
+ }
+ } else {
+ if x.StartTime == nil {
+ x.StartTime = new(pkg1_unversioned.Time)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.StartTime) {
+ } else if yym17 {
+ z.DecBinaryUnmarshal(x.StartTime)
+ } else if !yym17 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.StartTime)
+ } else {
+ z.DecFallback(x.StartTime, false)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.CompletionTime != nil {
+ x.CompletionTime = nil
+ }
+ } else {
+ if x.CompletionTime == nil {
+ x.CompletionTime = new(pkg1_unversioned.Time)
+ }
+ yym19 := z.DecBinary()
+ _ = yym19
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
+ } else if yym19 {
+ z.DecBinaryUnmarshal(x.CompletionTime)
+ } else if !yym19 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.CompletionTime)
+ } else {
+ z.DecFallback(x.CompletionTime, false)
+ }
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Active = 0
+ } else {
+ x.Active = int32(r.DecodeInt(32))
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Succeeded = 0
+ } else {
+ x.Succeeded = int32(r.DecodeInt(32))
+ }
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Failed = 0
+ } else {
+ x.Failed = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj13++
+ if yyhl13 {
+ yyb13 = yyj13 > l
+ } else {
+ yyb13 = r.CheckBreak()
+ }
+ if yyb13 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj13-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *JobConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = true
+ yyq2[3] = true
+ yyq2[4] = x.Reason != ""
+ yyq2[5] = x.Message != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Type.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Type.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yysf7 := &x.Status
+ yysf7.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yysf8 := &x.Status
+ yysf8.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy10 := &x.LastProbeTime
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy10) {
+ } else if yym11 {
+ z.EncBinaryMarshal(yy10)
+ } else if !yym11 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy10)
+ } else {
+ z.EncFallback(yy10)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.LastProbeTime
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy12) {
+ } else if yym13 {
+ z.EncBinaryMarshal(yy12)
+ } else if !yym13 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy12)
+ } else {
+ z.EncFallback(yy12)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yy15 := &x.LastTransitionTime
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy15) {
+ } else if yym16 {
+ z.EncBinaryMarshal(yy15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy15)
+ } else {
+ z.EncFallback(yy15)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy17 := &x.LastTransitionTime
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy17) {
+ } else if yym18 {
+ z.EncBinaryMarshal(yy17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy17)
+ } else {
+ z.EncFallback(yy17)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("message"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym24 := z.EncBinary()
+ _ = yym24
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "type":
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = JobConditionType(r.DecodeString())
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
+ }
+ case "lastProbeTime":
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg1_unversioned.Time{}
+ } else {
+ yyv6 := &x.LastProbeTime
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(yyv6)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
+ }
+ case "lastTransitionTime":
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg1_unversioned.Time{}
+ } else {
+ yyv8 := &x.LastTransitionTime
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv8) {
+ } else if yym9 {
+ z.DecBinaryUnmarshal(yyv8)
+ } else if !yym9 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv8)
+ } else {
+ z.DecFallback(yyv8, false)
+ }
+ }
+ case "reason":
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ case "message":
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj12 int
+ var yyb12 bool
+ var yyhl12 bool = l >= 0
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Type = ""
+ } else {
+ x.Type = JobConditionType(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ""
+ } else {
+ x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastProbeTime = pkg1_unversioned.Time{}
+ } else {
+ yyv15 := &x.LastProbeTime
+ yym16 := z.DecBinary()
+ _ = yym16
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv15) {
+ } else if yym16 {
+ z.DecBinaryUnmarshal(yyv15)
+ } else if !yym16 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv15)
+ } else {
+ z.DecFallback(yyv15, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.LastTransitionTime = pkg1_unversioned.Time{}
+ } else {
+ yyv17 := &x.LastTransitionTime
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv17) {
+ } else if yym18 {
+ z.DecBinaryUnmarshal(yyv17)
+ } else if !yym18 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv17)
+ } else {
+ z.DecFallback(yyv17, false)
+ }
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Reason = ""
+ } else {
+ x.Reason = string(r.DecodeString())
+ }
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Message = ""
+ } else {
+ x.Message = string(r.DecodeString())
+ }
+ for {
+ yyj12++
+ if yyhl12 {
+ yyb12 = yyj12 > l
+ } else {
+ yyb12 = r.CheckBreak()
+ }
+ if yyb12 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj12-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJob) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJob) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJob) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = ScheduledJobSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = ScheduledJobStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJob) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = ScheduledJobSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = ScheduledJobStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJobList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceScheduledJob(([]ScheduledJob)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceScheduledJob(([]ScheduledJob)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceScheduledJob((*[]ScheduledJob)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceScheduledJob((*[]ScheduledJob)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ScheduledJobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.StartingDeadlineSeconds != nil
+ yyq2[2] = x.ConcurrencyPolicy != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 3
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Schedule))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("schedule"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Schedule))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.StartingDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy7 := *x.StartingDeadlineSeconds
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(yy7))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("startingDeadlineSeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.StartingDeadlineSeconds == nil {
+ r.EncodeNil()
+ } else {
+ yy9 := *x.StartingDeadlineSeconds
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(yy9))
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ x.ConcurrencyPolicy.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("concurrencyPolicy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.ConcurrencyPolicy.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Suspend == nil {
+ r.EncodeNil()
+ } else {
+ yy15 := *x.Suspend
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeBool(bool(yy15))
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("suspend"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Suspend == nil {
+ r.EncodeNil()
+ } else {
+ yy17 := *x.Suspend
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeBool(bool(yy17))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy20 := &x.JobTemplate
+ yy20.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("jobTemplate"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy22 := &x.JobTemplate
+ yy22.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "schedule":
+ if r.TryDecodeAsNil() {
+ x.Schedule = ""
+ } else {
+ x.Schedule = string(r.DecodeString())
+ }
+ case "startingDeadlineSeconds":
+ if r.TryDecodeAsNil() {
+ if x.StartingDeadlineSeconds != nil {
+ x.StartingDeadlineSeconds = nil
+ }
+ } else {
+ if x.StartingDeadlineSeconds == nil {
+ x.StartingDeadlineSeconds = new(int64)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ *((*int64)(x.StartingDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ case "concurrencyPolicy":
+ if r.TryDecodeAsNil() {
+ x.ConcurrencyPolicy = ""
+ } else {
+ x.ConcurrencyPolicy = ConcurrencyPolicy(r.DecodeString())
+ }
+ case "suspend":
+ if r.TryDecodeAsNil() {
+ if x.Suspend != nil {
+ x.Suspend = nil
+ }
+ } else {
+ if x.Suspend == nil {
+ x.Suspend = new(bool)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ *((*bool)(x.Suspend)) = r.DecodeBool()
+ }
+ }
+ case "jobTemplate":
+ if r.TryDecodeAsNil() {
+ x.JobTemplate = JobTemplateSpec{}
+ } else {
+ yyv10 := &x.JobTemplate
+ yyv10.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj11 int
+ var yyb11 bool
+ var yyhl11 bool = l >= 0
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Schedule = ""
+ } else {
+ x.Schedule = string(r.DecodeString())
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.StartingDeadlineSeconds != nil {
+ x.StartingDeadlineSeconds = nil
+ }
+ } else {
+ if x.StartingDeadlineSeconds == nil {
+ x.StartingDeadlineSeconds = new(int64)
+ }
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ *((*int64)(x.StartingDeadlineSeconds)) = int64(r.DecodeInt(64))
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ConcurrencyPolicy = ""
+ } else {
+ x.ConcurrencyPolicy = ConcurrencyPolicy(r.DecodeString())
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Suspend != nil {
+ x.Suspend = nil
+ }
+ } else {
+ if x.Suspend == nil {
+ x.Suspend = new(bool)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
+ if false {
+ } else {
+ *((*bool)(x.Suspend)) = r.DecodeBool()
+ }
+ }
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.JobTemplate = JobTemplateSpec{}
+ } else {
+ yyv18 := &x.JobTemplate
+ yyv18.CodecDecodeSelf(d)
+ }
+ for {
+ yyj11++
+ if yyhl11 {
+ yyb11 = yyj11 > l
+ } else {
+ yyb11 = r.CheckBreak()
+ }
+ if yyb11 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj11-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x ConcurrencyPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *ConcurrencyPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *ScheduledJobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Active) != 0
+ yyq2[1] = x.LastScheduleTime != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Active == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSlicev1_ObjectReference(([]pkg2_v1.ObjectReference)(x.Active), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("active"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Active == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSlicev1_ObjectReference(([]pkg2_v1.ObjectReference)(x.Active), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.LastScheduleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScheduleTime) {
+ } else if yym7 {
+ z.EncBinaryMarshal(x.LastScheduleTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScheduleTime)
+ } else {
+ z.EncFallback(x.LastScheduleTime)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastScheduleTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LastScheduleTime == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.LastScheduleTime) {
+ } else if yym8 {
+ z.EncBinaryMarshal(x.LastScheduleTime)
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.LastScheduleTime)
+ } else {
+ z.EncFallback(x.LastScheduleTime)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ScheduledJobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ScheduledJobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "active":
+ if r.TryDecodeAsNil() {
+ x.Active = nil
+ } else {
+ yyv4 := &x.Active
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSlicev1_ObjectReference((*[]pkg2_v1.ObjectReference)(yyv4), d)
+ }
+ }
+ case "lastScheduleTime":
+ if r.TryDecodeAsNil() {
+ if x.LastScheduleTime != nil {
+ x.LastScheduleTime = nil
+ }
+ } else {
+ if x.LastScheduleTime == nil {
+ x.LastScheduleTime = new(pkg1_unversioned.Time)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScheduleTime) {
+ } else if yym7 {
+ z.DecBinaryUnmarshal(x.LastScheduleTime)
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScheduleTime)
+ } else {
+ z.DecFallback(x.LastScheduleTime, false)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ScheduledJobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Active = nil
+ } else {
+ yyv9 := &x.Active
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicev1_ObjectReference((*[]pkg2_v1.ObjectReference)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.LastScheduleTime != nil {
+ x.LastScheduleTime = nil
+ }
+ } else {
+ if x.LastScheduleTime == nil {
+ x.LastScheduleTime = new(pkg1_unversioned.Time)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.LastScheduleTime) {
+ } else if yym12 {
+ z.DecBinaryUnmarshal(x.LastScheduleTime)
+ } else if !yym12 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.LastScheduleTime)
+ } else {
+ z.DecFallback(x.LastScheduleTime, false)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *LabelSelector) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.MatchLabels) != 0
+ yyq2[1] = len(x.MatchExpressions) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.MatchLabels == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.EncMapStringStringV(x.MatchLabels, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.MatchLabels == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.EncMapStringStringV(x.MatchLabels, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.MatchExpressions == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.MatchExpressions == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *LabelSelector) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *LabelSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "matchLabels":
+ if r.TryDecodeAsNil() {
+ x.MatchLabels = nil
+ } else {
+ yyv4 := &x.MatchLabels
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.DecMapStringStringX(yyv4, false, d)
+ }
+ }
+ case "matchExpressions":
+ if r.TryDecodeAsNil() {
+ x.MatchExpressions = nil
+ } else {
+ yyv6 := &x.MatchExpressions
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *LabelSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MatchLabels = nil
+ } else {
+ yyv9 := &x.MatchLabels
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ z.F.DecMapStringStringX(yyv9, false, d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MatchExpressions = nil
+ } else {
+ yyv11 := &x.MatchExpressions
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *LabelSelectorRequirement) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [3]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[2] = len(x.Values) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(3)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("key"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Key))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ x.Operator.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("operator"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Operator.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.Values == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Values, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("values"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Values == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Values, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *LabelSelectorRequirement) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *LabelSelectorRequirement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "key":
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ case "operator":
+ if r.TryDecodeAsNil() {
+ x.Operator = ""
+ } else {
+ x.Operator = LabelSelectorOperator(r.DecodeString())
+ }
+ case "values":
+ if r.TryDecodeAsNil() {
+ x.Values = nil
+ } else {
+ yyv6 := &x.Values
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv6, false, d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *LabelSelectorRequirement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Key = ""
+ } else {
+ x.Key = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Operator = ""
+ } else {
+ x.Operator = LabelSelectorOperator(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Values = nil
+ } else {
+ yyv11 := &x.Values
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv11, false, d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *LabelSelectorOperator) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Job{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 792)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Job, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Job, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Job{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Job{}) // var yyz1 Job
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Job{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Job{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []JobCondition{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]JobCondition, yyrl1)
+ }
+ } else {
+ yyv1 = make([]JobCondition, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, JobCondition{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, JobCondition{}) // var yyz1 JobCondition
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = JobCondition{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []JobCondition{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceScheduledJob(v []ScheduledJob, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceScheduledJob(v *[]ScheduledJob, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ScheduledJob{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 1024)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ScheduledJob, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ScheduledJob, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ScheduledJob{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ScheduledJob{}) // var yyz1 ScheduledJob
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ScheduledJob{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ScheduledJob{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSlicev1_ObjectReference(v []pkg2_v1.ObjectReference, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicev1_ObjectReference(v *[]pkg2_v1.ObjectReference, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []pkg2_v1.ObjectReference{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]pkg2_v1.ObjectReference, yyrl1)
+ }
+ } else {
+ yyv1 = make([]pkg2_v1.ObjectReference, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.ObjectReference{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, pkg2_v1.ObjectReference{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.ObjectReference{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, pkg2_v1.ObjectReference{}) // var yyz1 pkg2_v1.ObjectReference
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = pkg2_v1.ObjectReference{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []pkg2_v1.ObjectReference{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequirement, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequirement, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []LabelSelectorRequirement{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]LabelSelectorRequirement, yyrl1)
+ }
+ } else {
+ yyv1 = make([]LabelSelectorRequirement, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = LabelSelectorRequirement{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, LabelSelectorRequirement{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = LabelSelectorRequirement{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, LabelSelectorRequirement{}) // var yyz1 LabelSelectorRequirement
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = LabelSelectorRequirement{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []LabelSelectorRequirement{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..568f51712360e3a81a3bba0d7bc7b80d5acb9773
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types.go
@@ -0,0 +1,283 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v2alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+)
+
+// Job represents the configuration of a single job.
+type Job struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Spec is a structure defining the expected behavior of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status JobStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// JobList is a collection of jobs.
+type JobList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is the list of Job.
+ Items []Job `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// JobTemplate describes a template for creating copies of a predefined pod.
+type JobTemplate struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Template defines jobs that will be created from this template
+ // http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Template JobTemplateSpec `json:"template,omitempty" protobuf:"bytes,2,opt,name=template"`
+}
+
+// JobTemplateSpec describes the data a Job should have when created from a template
+type JobTemplateSpec struct {
+ // Standard object's metadata of the jobs created from this template.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Specification of the desired behavior of the job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+}
+
+// JobSpec describes how the job execution will look like.
+type JobSpec struct {
+
+ // Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Parallelism *int32 `json:"parallelism,omitempty" protobuf:"varint,1,opt,name=parallelism"`
+
+ // Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Completions *int32 `json:"completions,omitempty" protobuf:"varint,2,opt,name=completions"`
+
+ // Optional duration in seconds relative to the startTime that the job may be active
+ // before the system tries to terminate it; value must be positive integer
+ ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty" protobuf:"varint,3,opt,name=activeDeadlineSeconds"`
+
+ // Selector is a label query over pods that should match the pod count.
+ // Normally, the system sets this field for you.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"`
+
+ // 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: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ ManualSelector *bool `json:"manualSelector,omitempty" protobuf:"varint,5,opt,name=manualSelector"`
+
+ // Template is the object that describes the pod that will be created when
+ // executing a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,6,opt,name=template"`
+}
+
+// JobStatus represents the current state of a Job.
+type JobStatus struct {
+
+ // Conditions represent the latest available observations of an object's current state.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
+
+ // StartTime represents time when the job was acknowledged by the Job Manager.
+ // It is not guaranteed to be set in happens-before order across separate operations.
+ // It is represented in RFC3339 form and is in UTC.
+ StartTime *unversioned.Time `json:"startTime,omitempty" protobuf:"bytes,2,opt,name=startTime"`
+
+ // CompletionTime 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.
+ CompletionTime *unversioned.Time `json:"completionTime,omitempty" protobuf:"bytes,3,opt,name=completionTime"`
+
+ // Active is the number of actively running pods.
+ Active int32 `json:"active,omitempty" protobuf:"varint,4,opt,name=active"`
+
+ // Succeeded is the number of pods which reached Phase Succeeded.
+ Succeeded int32 `json:"succeeded,omitempty" protobuf:"varint,5,opt,name=succeeded"`
+
+ // Failed is the number of pods which reached Phase Failed.
+ Failed int32 `json:"failed,omitempty" protobuf:"varint,6,opt,name=failed"`
+}
+
+type JobConditionType string
+
+// These are valid conditions of a job.
+const (
+ // JobComplete means the job has completed its execution.
+ JobComplete JobConditionType = "Complete"
+ // JobFailed means the job has failed its execution.
+ JobFailed JobConditionType = "Failed"
+)
+
+// JobCondition describes current state of a job.
+type JobCondition struct {
+ // Type of job condition, Complete or Failed.
+ Type JobConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=JobConditionType"`
+ // Status of the condition, one of True, False, Unknown.
+ Status v1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/kubernetes/pkg/api/v1.ConditionStatus"`
+ // Last time the condition was checked.
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty" protobuf:"bytes,3,opt,name=lastProbeTime"`
+ // Last time the condition transit from one status to another.
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
+ // (brief) reason for the condition's last transition.
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
+ // Human readable message indicating details about last transition.
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
+}
+
+// ScheduledJob represents the configuration of a single scheduled job.
+type ScheduledJob struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Spec is a structure defining the expected behavior of a job, including the schedule.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ScheduledJobSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ScheduledJobStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// ScheduledJobList is a collection of scheduled jobs.
+type ScheduledJobList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is the list of ScheduledJob.
+ Items []ScheduledJob `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// ScheduledJobSpec describes how the job execution will look like and when it will actually run.
+type ScheduledJobSpec struct {
+
+ // Schedule contains the schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.
+ Schedule string `json:"schedule" protobuf:"bytes,1,opt,name=schedule"`
+
+ // 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.
+ StartingDeadlineSeconds *int64 `json:"startingDeadlineSeconds,omitempty" protobuf:"varint,2,opt,name=startingDeadlineSeconds"`
+
+ // ConcurrencyPolicy specifies how to treat concurrent executions of a Job.
+ ConcurrencyPolicy ConcurrencyPolicy `json:"concurrencyPolicy,omitempty" protobuf:"bytes,3,opt,name=concurrencyPolicy,casttype=ConcurrencyPolicy"`
+
+ // Suspend flag tells the controller to suspend subsequent executions, it does
+ // not apply to already started executions. Defaults to false.
+ Suspend *bool `json:"suspend" protobuf:"varint,4,opt,name=suspend"`
+
+ // JobTemplate is the object that describes the job that will be created when
+ // executing a ScheduledJob.
+ JobTemplate JobTemplateSpec `json:"jobTemplate" protobuf:"bytes,5,opt,name=jobTemplate"`
+}
+
+// ConcurrencyPolicy describes how the job will be handled.
+// Only one of the following concurrent policies may be specified.
+// If none of the following policies is specified, the default one
+// is AllowConcurrent.
+type ConcurrencyPolicy string
+
+const (
+ // AllowConcurrent allows ScheduledJobs to run concurrently.
+ AllowConcurrent ConcurrencyPolicy = "Allow"
+
+ // ForbidConcurrent forbids concurrent runs, skipping next run if previous
+ // hasn't finished yet.
+ ForbidConcurrent ConcurrencyPolicy = "Forbid"
+
+ // ReplaceConcurrent cancels currently running job and replaces it with a new one.
+ ReplaceConcurrent ConcurrencyPolicy = "Replace"
+)
+
+// ScheduledJobStatus represents the current state of a Job.
+type ScheduledJobStatus struct {
+ // Active holds pointers to currently running jobs.
+ Active []v1.ObjectReference `json:"active,omitempty" protobuf:"bytes,1,rep,name=active"`
+
+ // LastScheduleTime keeps information of when was the last time the job was successfully scheduled.
+ LastScheduleTime *unversioned.Time `json:"lastScheduleTime,omitempty" protobuf:"bytes,4,opt,name=lastScheduleTime"`
+}
+
+// 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.
+type LabelSelector struct {
+ // 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.
+ MatchLabels map[string]string `json:"matchLabels,omitempty" protobuf:"bytes,1,rep,name=matchLabels"`
+ // matchExpressions is a list of label selector requirements. The requirements are ANDed.
+ MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,2,rep,name=matchExpressions"`
+}
+
+// A label selector requirement is a selector that contains values, a key, and an operator that
+// relates the key and values.
+type LabelSelectorRequirement struct {
+ // key is the label key that the selector applies to.
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
+ // operator represents a key's relationship to a set of values.
+ // Valid operators ard In, NotIn, Exists and DoesNotExist.
+ Operator LabelSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=LabelSelectorOperator"`
+ // 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.
+ Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
+}
+
+// A label selector operator is the set of operators that can be used in a selector requirement.
+type LabelSelectorOperator string
+
+const (
+ LabelSelectorOpIn LabelSelectorOperator = "In"
+ LabelSelectorOpNotIn LabelSelectorOperator = "NotIn"
+ LabelSelectorOpExists LabelSelectorOperator = "Exists"
+ LabelSelectorOpDoesNotExist LabelSelectorOperator = "DoesNotExist"
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types_swagger_doc_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..95b86d0de740ee03f5c57966348bcdfb139d17b7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/batch/v2alpha1/types_swagger_doc_generated.go
@@ -0,0 +1,178 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v2alpha1
+
+// This file contains a collection of methods that can be used from go-restful to
+// generate Swagger API documentation for its models. Please read this PR for more
+// information on the implementation: https://github.com/emicklei/go-restful/pull/215
+//
+// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if
+// they are on one line! For multiple line or blocks that you want to ignore use ---.
+// Any context after a --- is ignored.
+//
+// Those methods can be generated by using hack/update-generated-swagger-docs.sh
+
+// AUTO-GENERATED FUNCTIONS START HERE
+var map_Job = map[string]string{
+ "": "Job represents the configuration of a single job.",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec is a structure defining the expected behavior of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+}
+
+func (Job) SwaggerDoc() map[string]string {
+ return map_Job
+}
+
+var map_JobCondition = map[string]string{
+ "": "JobCondition describes current state of a job.",
+ "type": "Type of job condition, Complete or Failed.",
+ "status": "Status of the condition, one of True, False, Unknown.",
+ "lastProbeTime": "Last time the condition was checked.",
+ "lastTransitionTime": "Last time the condition transit from one status to another.",
+ "reason": "(brief) reason for the condition's last transition.",
+ "message": "Human readable message indicating details about last transition.",
+}
+
+func (JobCondition) SwaggerDoc() map[string]string {
+ return map_JobCondition
+}
+
+var map_JobList = map[string]string{
+ "": "JobList is a collection of jobs.",
+ "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "items": "Items is the list of Job.",
+}
+
+func (JobList) SwaggerDoc() map[string]string {
+ return map_JobList
+}
+
+var map_JobSpec = map[string]string{
+ "": "JobSpec describes how the job execution will look like.",
+ "parallelism": "Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+ "completions": "Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+ "activeDeadlineSeconds": "Optional duration in seconds relative to the startTime that the job may be active before the system tries to terminate it; value must be positive integer",
+ "selector": "Selector is a label query over pods that should match the pod count. Normally, the system sets this field for you. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "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: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md",
+ "template": "Template is the object that describes the pod that will be created when executing a job. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+}
+
+func (JobSpec) SwaggerDoc() map[string]string {
+ return map_JobSpec
+}
+
+var map_JobStatus = map[string]string{
+ "": "JobStatus represents the current state of a Job.",
+ "conditions": "Conditions represent the latest available observations of an object's current state. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+ "startTime": "StartTime represents time when the job was acknowledged by the Job Manager. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC.",
+ "completionTime": "CompletionTime 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.",
+ "active": "Active is the number of actively running pods.",
+ "succeeded": "Succeeded is the number of pods which reached Phase Succeeded.",
+ "failed": "Failed is the number of pods which reached Phase Failed.",
+}
+
+func (JobStatus) SwaggerDoc() map[string]string {
+ return map_JobStatus
+}
+
+var map_JobTemplate = map[string]string{
+ "": "JobTemplate describes a template for creating copies of a predefined pod.",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "template": "Template defines jobs that will be created from this template http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+}
+
+func (JobTemplate) SwaggerDoc() map[string]string {
+ return map_JobTemplate
+}
+
+var map_JobTemplateSpec = map[string]string{
+ "": "JobTemplateSpec describes the data a Job should have when created from a template",
+ "metadata": "Standard object's metadata of the jobs created from this template. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Specification of the desired behavior of the job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+}
+
+func (JobTemplateSpec) SwaggerDoc() map[string]string {
+ return map_JobTemplateSpec
+}
+
+var map_LabelSelector = map[string]string{
+ "": "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.",
+ "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.",
+ "matchExpressions": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
+}
+
+func (LabelSelector) SwaggerDoc() map[string]string {
+ return map_LabelSelector
+}
+
+var map_LabelSelectorRequirement = map[string]string{
+ "": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
+ "key": "key is the label key that the selector applies to.",
+ "operator": "operator represents a key's relationship to a set of values. Valid operators ard In, NotIn, Exists and DoesNotExist.",
+ "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.",
+}
+
+func (LabelSelectorRequirement) SwaggerDoc() map[string]string {
+ return map_LabelSelectorRequirement
+}
+
+var map_ScheduledJob = map[string]string{
+ "": "ScheduledJob represents the configuration of a single scheduled job.",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec is a structure defining the expected behavior of a job, including the schedule. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+}
+
+func (ScheduledJob) SwaggerDoc() map[string]string {
+ return map_ScheduledJob
+}
+
+var map_ScheduledJobList = map[string]string{
+ "": "ScheduledJobList is a collection of scheduled jobs.",
+ "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "items": "Items is the list of ScheduledJob.",
+}
+
+func (ScheduledJobList) SwaggerDoc() map[string]string {
+ return map_ScheduledJobList
+}
+
+var map_ScheduledJobSpec = map[string]string{
+ "": "ScheduledJobSpec describes how the job execution will look like and when it will actually run.",
+ "schedule": "Schedule contains the schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.",
+ "startingDeadlineSeconds": "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.",
+ "concurrencyPolicy": "ConcurrencyPolicy specifies how to treat concurrent executions of a Job.",
+ "suspend": "Suspend flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false.",
+ "jobTemplate": "JobTemplate is the object that describes the job that will be created when executing a ScheduledJob.",
+}
+
+func (ScheduledJobSpec) SwaggerDoc() map[string]string {
+ return map_ScheduledJobSpec
+}
+
+var map_ScheduledJobStatus = map[string]string{
+ "": "ScheduledJobStatus represents the current state of a Job.",
+ "active": "Active holds pointers to currently running jobs.",
+ "lastScheduleTime": "LastScheduleTime keeps information of when was the last time the job was successfully scheduled.",
+}
+
+func (ScheduledJobStatus) SwaggerDoc() map[string]string {
+ return map_ScheduledJobStatus
+}
+
+// AUTO-GENERATED FUNCTIONS END HERE
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..c18e2e5c319a0f870007e2e9150dbde4237ddd13
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/deep_copy_generated.go
@@ -0,0 +1,373 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package componentconfig
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_componentconfig_IPVar,
+ DeepCopy_componentconfig_KubeControllerManagerConfiguration,
+ DeepCopy_componentconfig_KubeProxyConfiguration,
+ DeepCopy_componentconfig_KubeSchedulerConfiguration,
+ DeepCopy_componentconfig_KubeletConfiguration,
+ DeepCopy_componentconfig_LeaderElectionConfiguration,
+ DeepCopy_componentconfig_PersistentVolumeRecyclerConfiguration,
+ DeepCopy_componentconfig_PortRangeVar,
+ DeepCopy_componentconfig_VolumeConfiguration,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_componentconfig_IPVar(in IPVar, out *IPVar, c *conversion.Cloner) error {
+ if in.Val != nil {
+ in, out := in.Val, &out.Val
+ *out = new(string)
+ **out = *in
+ } else {
+ out.Val = nil
+ }
+ return nil
+}
+
+func DeepCopy_componentconfig_KubeControllerManagerConfiguration(in KubeControllerManagerConfiguration, out *KubeControllerManagerConfiguration, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Port = in.Port
+ out.Address = in.Address
+ out.CloudProvider = in.CloudProvider
+ out.CloudConfigFile = in.CloudConfigFile
+ out.ConcurrentEndpointSyncs = in.ConcurrentEndpointSyncs
+ out.ConcurrentRSSyncs = in.ConcurrentRSSyncs
+ out.ConcurrentRCSyncs = in.ConcurrentRCSyncs
+ out.ConcurrentResourceQuotaSyncs = in.ConcurrentResourceQuotaSyncs
+ out.ConcurrentDeploymentSyncs = in.ConcurrentDeploymentSyncs
+ out.ConcurrentDaemonSetSyncs = in.ConcurrentDaemonSetSyncs
+ out.ConcurrentJobSyncs = in.ConcurrentJobSyncs
+ out.ConcurrentNamespaceSyncs = in.ConcurrentNamespaceSyncs
+ out.LookupCacheSizeForRC = in.LookupCacheSizeForRC
+ out.LookupCacheSizeForRS = in.LookupCacheSizeForRS
+ out.LookupCacheSizeForDaemonSet = in.LookupCacheSizeForDaemonSet
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ServiceSyncPeriod, &out.ServiceSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NodeSyncPeriod, &out.NodeSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ResourceQuotaSyncPeriod, &out.ResourceQuotaSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NamespaceSyncPeriod, &out.NamespaceSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.PVClaimBinderSyncPeriod, &out.PVClaimBinderSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.MinResyncPeriod, &out.MinResyncPeriod, c); err != nil {
+ return err
+ }
+ out.TerminatedPodGCThreshold = in.TerminatedPodGCThreshold
+ if err := unversioned.DeepCopy_unversioned_Duration(in.HorizontalPodAutoscalerSyncPeriod, &out.HorizontalPodAutoscalerSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.DeploymentControllerSyncPeriod, &out.DeploymentControllerSyncPeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.PodEvictionTimeout, &out.PodEvictionTimeout, c); err != nil {
+ return err
+ }
+ out.DeletingPodsQps = in.DeletingPodsQps
+ out.DeletingPodsBurst = in.DeletingPodsBurst
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NodeMonitorGracePeriod, &out.NodeMonitorGracePeriod, c); err != nil {
+ return err
+ }
+ out.RegisterRetryCount = in.RegisterRetryCount
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NodeStartupGracePeriod, &out.NodeStartupGracePeriod, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NodeMonitorPeriod, &out.NodeMonitorPeriod, c); err != nil {
+ return err
+ }
+ out.ServiceAccountKeyFile = in.ServiceAccountKeyFile
+ out.EnableProfiling = in.EnableProfiling
+ out.ClusterName = in.ClusterName
+ out.ClusterCIDR = in.ClusterCIDR
+ out.ServiceCIDR = in.ServiceCIDR
+ out.NodeCIDRMaskSize = in.NodeCIDRMaskSize
+ out.AllocateNodeCIDRs = in.AllocateNodeCIDRs
+ out.ConfigureCloudRoutes = in.ConfigureCloudRoutes
+ out.RootCAFile = in.RootCAFile
+ out.ContentType = in.ContentType
+ out.KubeAPIQPS = in.KubeAPIQPS
+ out.KubeAPIBurst = in.KubeAPIBurst
+ if err := DeepCopy_componentconfig_LeaderElectionConfiguration(in.LeaderElection, &out.LeaderElection, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_componentconfig_VolumeConfiguration(in.VolumeConfiguration, &out.VolumeConfiguration, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ControllerStartInterval, &out.ControllerStartInterval, c); err != nil {
+ return err
+ }
+ out.EnableGarbageCollector = in.EnableGarbageCollector
+ return nil
+}
+
+func DeepCopy_componentconfig_KubeProxyConfiguration(in KubeProxyConfiguration, out *KubeProxyConfiguration, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.BindAddress = in.BindAddress
+ out.ClusterCIDR = in.ClusterCIDR
+ out.HealthzBindAddress = in.HealthzBindAddress
+ out.HealthzPort = in.HealthzPort
+ out.HostnameOverride = in.HostnameOverride
+ if in.IPTablesMasqueradeBit != nil {
+ in, out := in.IPTablesMasqueradeBit, &out.IPTablesMasqueradeBit
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.IPTablesMasqueradeBit = nil
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.IPTablesSyncPeriod, &out.IPTablesSyncPeriod, c); err != nil {
+ return err
+ }
+ out.KubeconfigPath = in.KubeconfigPath
+ out.MasqueradeAll = in.MasqueradeAll
+ out.Master = in.Master
+ if in.OOMScoreAdj != nil {
+ in, out := in.OOMScoreAdj, &out.OOMScoreAdj
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.OOMScoreAdj = nil
+ }
+ out.Mode = in.Mode
+ out.PortRange = in.PortRange
+ out.ResourceContainer = in.ResourceContainer
+ if err := unversioned.DeepCopy_unversioned_Duration(in.UDPIdleTimeout, &out.UDPIdleTimeout, c); err != nil {
+ return err
+ }
+ out.ConntrackMax = in.ConntrackMax
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ConntrackTCPEstablishedTimeout, &out.ConntrackTCPEstablishedTimeout, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_componentconfig_KubeSchedulerConfiguration(in KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Port = in.Port
+ out.Address = in.Address
+ out.AlgorithmProvider = in.AlgorithmProvider
+ out.PolicyConfigFile = in.PolicyConfigFile
+ out.EnableProfiling = in.EnableProfiling
+ out.ContentType = in.ContentType
+ out.KubeAPIQPS = in.KubeAPIQPS
+ out.KubeAPIBurst = in.KubeAPIBurst
+ out.SchedulerName = in.SchedulerName
+ out.HardPodAffinitySymmetricWeight = in.HardPodAffinitySymmetricWeight
+ out.FailureDomains = in.FailureDomains
+ if err := DeepCopy_componentconfig_LeaderElectionConfiguration(in.LeaderElection, &out.LeaderElection, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_componentconfig_KubeletConfiguration(in KubeletConfiguration, out *KubeletConfiguration, c *conversion.Cloner) error {
+ out.Config = in.Config
+ if err := unversioned.DeepCopy_unversioned_Duration(in.SyncFrequency, &out.SyncFrequency, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.FileCheckFrequency, &out.FileCheckFrequency, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.HTTPCheckFrequency, &out.HTTPCheckFrequency, c); err != nil {
+ return err
+ }
+ out.ManifestURL = in.ManifestURL
+ out.ManifestURLHeader = in.ManifestURLHeader
+ out.EnableServer = in.EnableServer
+ out.Address = in.Address
+ out.Port = in.Port
+ out.ReadOnlyPort = in.ReadOnlyPort
+ out.TLSCertFile = in.TLSCertFile
+ out.TLSPrivateKeyFile = in.TLSPrivateKeyFile
+ out.CertDirectory = in.CertDirectory
+ out.HostnameOverride = in.HostnameOverride
+ out.PodInfraContainerImage = in.PodInfraContainerImage
+ out.DockerEndpoint = in.DockerEndpoint
+ out.RootDirectory = in.RootDirectory
+ out.SeccompProfileRoot = in.SeccompProfileRoot
+ out.AllowPrivileged = in.AllowPrivileged
+ out.HostNetworkSources = in.HostNetworkSources
+ out.HostPIDSources = in.HostPIDSources
+ out.HostIPCSources = in.HostIPCSources
+ out.RegistryPullQPS = in.RegistryPullQPS
+ out.RegistryBurst = in.RegistryBurst
+ out.EventRecordQPS = in.EventRecordQPS
+ out.EventBurst = in.EventBurst
+ out.EnableDebuggingHandlers = in.EnableDebuggingHandlers
+ if err := unversioned.DeepCopy_unversioned_Duration(in.MinimumGCAge, &out.MinimumGCAge, c); err != nil {
+ return err
+ }
+ out.MaxPerPodContainerCount = in.MaxPerPodContainerCount
+ out.MaxContainerCount = in.MaxContainerCount
+ out.CAdvisorPort = in.CAdvisorPort
+ out.HealthzPort = in.HealthzPort
+ out.HealthzBindAddress = in.HealthzBindAddress
+ out.OOMScoreAdj = in.OOMScoreAdj
+ out.RegisterNode = in.RegisterNode
+ out.ClusterDomain = in.ClusterDomain
+ out.MasterServiceNamespace = in.MasterServiceNamespace
+ out.ClusterDNS = in.ClusterDNS
+ if err := unversioned.DeepCopy_unversioned_Duration(in.StreamingConnectionIdleTimeout, &out.StreamingConnectionIdleTimeout, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.NodeStatusUpdateFrequency, &out.NodeStatusUpdateFrequency, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ImageMinimumGCAge, &out.ImageMinimumGCAge, c); err != nil {
+ return err
+ }
+ out.ImageGCHighThresholdPercent = in.ImageGCHighThresholdPercent
+ out.ImageGCLowThresholdPercent = in.ImageGCLowThresholdPercent
+ out.LowDiskSpaceThresholdMB = in.LowDiskSpaceThresholdMB
+ if err := unversioned.DeepCopy_unversioned_Duration(in.VolumeStatsAggPeriod, &out.VolumeStatsAggPeriod, c); err != nil {
+ return err
+ }
+ out.NetworkPluginName = in.NetworkPluginName
+ out.NetworkPluginDir = in.NetworkPluginDir
+ out.VolumePluginDir = in.VolumePluginDir
+ out.CloudProvider = in.CloudProvider
+ out.CloudConfigFile = in.CloudConfigFile
+ out.KubeletCgroups = in.KubeletCgroups
+ out.RuntimeCgroups = in.RuntimeCgroups
+ out.SystemCgroups = in.SystemCgroups
+ out.CgroupRoot = in.CgroupRoot
+ out.ContainerRuntime = in.ContainerRuntime
+ if err := unversioned.DeepCopy_unversioned_Duration(in.RuntimeRequestTimeout, &out.RuntimeRequestTimeout, c); err != nil {
+ return err
+ }
+ out.RktPath = in.RktPath
+ out.RktAPIEndpoint = in.RktAPIEndpoint
+ out.RktStage1Image = in.RktStage1Image
+ out.LockFilePath = in.LockFilePath
+ out.ExitOnLockContention = in.ExitOnLockContention
+ out.ConfigureCBR0 = in.ConfigureCBR0
+ out.HairpinMode = in.HairpinMode
+ out.BabysitDaemons = in.BabysitDaemons
+ out.MaxPods = in.MaxPods
+ out.NvidiaGPUs = in.NvidiaGPUs
+ out.DockerExecHandlerName = in.DockerExecHandlerName
+ out.PodCIDR = in.PodCIDR
+ out.ResolverConfig = in.ResolverConfig
+ out.CPUCFSQuota = in.CPUCFSQuota
+ out.Containerized = in.Containerized
+ out.MaxOpenFiles = in.MaxOpenFiles
+ out.ReconcileCIDR = in.ReconcileCIDR
+ out.RegisterSchedulable = in.RegisterSchedulable
+ out.ContentType = in.ContentType
+ out.KubeAPIQPS = in.KubeAPIQPS
+ out.KubeAPIBurst = in.KubeAPIBurst
+ out.SerializeImagePulls = in.SerializeImagePulls
+ out.ExperimentalFlannelOverlay = in.ExperimentalFlannelOverlay
+ if err := unversioned.DeepCopy_unversioned_Duration(in.OutOfDiskTransitionFrequency, &out.OutOfDiskTransitionFrequency, c); err != nil {
+ return err
+ }
+ out.NodeIP = in.NodeIP
+ if in.NodeLabels != nil {
+ in, out := in.NodeLabels, &out.NodeLabels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.NodeLabels = nil
+ }
+ out.NonMasqueradeCIDR = in.NonMasqueradeCIDR
+ out.EnableCustomMetrics = in.EnableCustomMetrics
+ out.EvictionHard = in.EvictionHard
+ out.EvictionSoft = in.EvictionSoft
+ out.EvictionSoftGracePeriod = in.EvictionSoftGracePeriod
+ if err := unversioned.DeepCopy_unversioned_Duration(in.EvictionPressureTransitionPeriod, &out.EvictionPressureTransitionPeriod, c); err != nil {
+ return err
+ }
+ out.EvictionMaxPodGracePeriod = in.EvictionMaxPodGracePeriod
+ out.PodsPerCore = in.PodsPerCore
+ out.EnableControllerAttachDetach = in.EnableControllerAttachDetach
+ return nil
+}
+
+func DeepCopy_componentconfig_LeaderElectionConfiguration(in LeaderElectionConfiguration, out *LeaderElectionConfiguration, c *conversion.Cloner) error {
+ out.LeaderElect = in.LeaderElect
+ if err := unversioned.DeepCopy_unversioned_Duration(in.LeaseDuration, &out.LeaseDuration, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.RenewDeadline, &out.RenewDeadline, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Duration(in.RetryPeriod, &out.RetryPeriod, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_componentconfig_PersistentVolumeRecyclerConfiguration(in PersistentVolumeRecyclerConfiguration, out *PersistentVolumeRecyclerConfiguration, c *conversion.Cloner) error {
+ out.MaximumRetry = in.MaximumRetry
+ out.MinimumTimeoutNFS = in.MinimumTimeoutNFS
+ out.PodTemplateFilePathNFS = in.PodTemplateFilePathNFS
+ out.IncrementTimeoutNFS = in.IncrementTimeoutNFS
+ out.PodTemplateFilePathHostPath = in.PodTemplateFilePathHostPath
+ out.MinimumTimeoutHostPath = in.MinimumTimeoutHostPath
+ out.IncrementTimeoutHostPath = in.IncrementTimeoutHostPath
+ return nil
+}
+
+func DeepCopy_componentconfig_PortRangeVar(in PortRangeVar, out *PortRangeVar, c *conversion.Cloner) error {
+ if in.Val != nil {
+ in, out := in.Val, &out.Val
+ *out = new(string)
+ **out = *in
+ } else {
+ out.Val = nil
+ }
+ return nil
+}
+
+func DeepCopy_componentconfig_VolumeConfiguration(in VolumeConfiguration, out *VolumeConfiguration, c *conversion.Cloner) error {
+ out.EnableHostPathProvisioning = in.EnableHostPathProvisioning
+ out.EnableDynamicProvisioning = in.EnableDynamicProvisioning
+ if err := DeepCopy_componentconfig_PersistentVolumeRecyclerConfiguration(in.PersistentVolumeRecyclerConfiguration, &out.PersistentVolumeRecyclerConfiguration, c); err != nil {
+ return err
+ }
+ out.FlexVolumePluginDir = in.FlexVolumePluginDir
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/helpers.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/helpers.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/helpers.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/helpers.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/install/install.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/install/install.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/register.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/register.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/register.go
index 3604129a651433e1b4ea5245cd7a4b81c009dfa2..0666c5431799b85a1cc713edfa8406c99b7e0a00 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/register.go
@@ -48,6 +48,3 @@ func addKnownTypes(scheme *runtime.Scheme) {
&KubeSchedulerConfiguration{},
)
}
-
-func (obj *KubeProxyConfiguration) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *KubeSchedulerConfiguration) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go
index 28bf8d714d316c7fdb3ba6197dd9d425d0556237..b76ca11f99bd474efc30a6c5dacd0df5e9aa6fba 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -589,7 +589,7 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.HealthzPort = 0
} else {
- x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HealthzPort = int32(r.DecodeInt(32))
}
case "hostnameOverride":
if r.TryDecodeAsNil() {
@@ -604,13 +604,13 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Deco
}
} else {
if x.IPTablesMasqueradeBit == nil {
- x.IPTablesMasqueradeBit = new(int)
+ x.IPTablesMasqueradeBit = new(int32)
}
yym10 := z.DecBinary()
_ = yym10
if false {
} else {
- *((*int)(x.IPTablesMasqueradeBit)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.IPTablesMasqueradeBit)) = int32(r.DecodeInt(32))
}
}
case "iptablesSyncPeriodSeconds":
@@ -653,13 +653,13 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Deco
}
} else {
if x.OOMScoreAdj == nil {
- x.OOMScoreAdj = new(int)
+ x.OOMScoreAdj = new(int32)
}
yym17 := z.DecBinary()
_ = yym17
if false {
} else {
- *((*int)(x.OOMScoreAdj)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.OOMScoreAdj)) = int32(r.DecodeInt(32))
}
}
case "mode":
@@ -699,7 +699,7 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.ConntrackMax = 0
} else {
- x.ConntrackMax = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConntrackMax = int32(r.DecodeInt(32))
}
case "conntrackTCPEstablishedTimeout":
if r.TryDecodeAsNil() {
@@ -804,7 +804,7 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.De
if r.TryDecodeAsNil() {
x.HealthzPort = 0
} else {
- x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HealthzPort = int32(r.DecodeInt(32))
}
yyj28++
if yyhl28 {
@@ -839,13 +839,13 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.De
}
} else {
if x.IPTablesMasqueradeBit == nil {
- x.IPTablesMasqueradeBit = new(int)
+ x.IPTablesMasqueradeBit = new(int32)
}
yym35 := z.DecBinary()
_ = yym35
if false {
} else {
- *((*int)(x.IPTablesMasqueradeBit)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.IPTablesMasqueradeBit)) = int32(r.DecodeInt(32))
}
}
yyj28++
@@ -938,13 +938,13 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.De
}
} else {
if x.OOMScoreAdj == nil {
- x.OOMScoreAdj = new(int)
+ x.OOMScoreAdj = new(int32)
}
yym42 := z.DecBinary()
_ = yym42
if false {
} else {
- *((*int)(x.OOMScoreAdj)) = int(r.DecodeInt(codecSelferBitsize1234))
+ *((*int32)(x.OOMScoreAdj)) = int32(r.DecodeInt(32))
}
}
yyj28++
@@ -1034,7 +1034,7 @@ func (x *KubeProxyConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.De
if r.TryDecodeAsNil() {
x.ConntrackMax = 0
} else {
- x.ConntrackMax = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConntrackMax = int32(r.DecodeInt(32))
}
yyj28++
if yyhl28 {
@@ -1175,24 +1175,31 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [78]bool
+ var yyq2 [91]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[47] = x.CloudProvider != ""
- yyq2[48] = x.CloudConfigFile != ""
- yyq2[49] = x.KubeletCgroups != ""
- yyq2[50] = x.RuntimeCgroups != ""
- yyq2[51] = x.SystemCgroups != ""
- yyq2[52] = x.CgroupRoot != ""
- yyq2[54] = x.RktPath != ""
- yyq2[56] = x.RktStage1Image != ""
- yyq2[73] = true
- yyq2[74] = x.NodeIP != ""
+ yyq2[48] = x.CloudProvider != ""
+ yyq2[49] = x.CloudConfigFile != ""
+ yyq2[50] = x.KubeletCgroups != ""
+ yyq2[51] = x.RuntimeCgroups != ""
+ yyq2[52] = x.SystemCgroups != ""
+ yyq2[53] = x.CgroupRoot != ""
+ yyq2[55] = true
+ yyq2[56] = x.RktPath != ""
+ yyq2[57] = x.RktAPIEndpoint != ""
+ yyq2[58] = x.RktStage1Image != ""
+ yyq2[79] = true
+ yyq2[80] = x.NodeIP != ""
+ yyq2[84] = x.EvictionHard != ""
+ yyq2[85] = x.EvictionSoft != ""
+ yyq2[86] = x.EvictionSoftGracePeriod != ""
+ yyq2[87] = true
+ yyq2[88] = x.EvictionMaxPodGracePeriod != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(78)
+ r.EncodeArrayStart(91)
} else {
- yynn2 = 68
+ yynn2 = 74
for _, b := range yyq2 {
if b {
yynn2++
@@ -1554,17 +1561,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym61
if false {
} else {
- r.EncodeBool(bool(x.AllowPrivileged))
+ r.EncodeString(codecSelferC_UTF81234, string(x.SeccompProfileRoot))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("allowPrivileged"))
+ r.EncodeString(codecSelferC_UTF81234, string("seccompProfileRoot"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym62 := z.EncBinary()
_ = yym62
if false {
} else {
- r.EncodeBool(bool(x.AllowPrivileged))
+ r.EncodeString(codecSelferC_UTF81234, string(x.SeccompProfileRoot))
}
}
if yyr2 || yy2arr2 {
@@ -1573,17 +1580,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym64
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources))
+ r.EncodeBool(bool(x.AllowPrivileged))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostNetworkSources"))
+ r.EncodeString(codecSelferC_UTF81234, string("allowPrivileged"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym65 := z.EncBinary()
_ = yym65
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources))
+ r.EncodeBool(bool(x.AllowPrivileged))
}
}
if yyr2 || yy2arr2 {
@@ -1592,17 +1599,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym67
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostPIDSources"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostNetworkSources"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym68 := z.EncBinary()
_ = yym68
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostNetworkSources))
}
}
if yyr2 || yy2arr2 {
@@ -1611,17 +1618,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym70
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostIPCSources"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostPIDSources"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym71 := z.EncBinary()
_ = yym71
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostPIDSources))
}
}
if yyr2 || yy2arr2 {
@@ -1630,17 +1637,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym73
if false {
} else {
- r.EncodeFloat64(float64(x.RegistryPullQPS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("registryPullQPS"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostIPCSources"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym74 := z.EncBinary()
_ = yym74
if false {
} else {
- r.EncodeFloat64(float64(x.RegistryPullQPS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostIPCSources))
}
}
if yyr2 || yy2arr2 {
@@ -1649,17 +1656,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym76
if false {
} else {
- r.EncodeInt(int64(x.RegistryBurst))
+ r.EncodeFloat64(float64(x.RegistryPullQPS))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("registryBurst"))
+ r.EncodeString(codecSelferC_UTF81234, string("registryPullQPS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym77 := z.EncBinary()
_ = yym77
if false {
} else {
- r.EncodeInt(int64(x.RegistryBurst))
+ r.EncodeFloat64(float64(x.RegistryPullQPS))
}
}
if yyr2 || yy2arr2 {
@@ -1668,17 +1675,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym79
if false {
} else {
- r.EncodeFloat32(float32(x.EventRecordQPS))
+ r.EncodeInt(int64(x.RegistryBurst))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("eventRecordQPS"))
+ r.EncodeString(codecSelferC_UTF81234, string("registryBurst"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym80 := z.EncBinary()
_ = yym80
if false {
} else {
- r.EncodeFloat32(float32(x.EventRecordQPS))
+ r.EncodeInt(int64(x.RegistryBurst))
}
}
if yyr2 || yy2arr2 {
@@ -1687,17 +1694,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym82
if false {
} else {
- r.EncodeInt(int64(x.EventBurst))
+ r.EncodeFloat32(float32(x.EventRecordQPS))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("eventBurst"))
+ r.EncodeString(codecSelferC_UTF81234, string("eventRecordQPS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym83 := z.EncBinary()
_ = yym83
if false {
} else {
- r.EncodeInt(int64(x.EventBurst))
+ r.EncodeFloat32(float32(x.EventRecordQPS))
}
}
if yyr2 || yy2arr2 {
@@ -1706,63 +1713,63 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym85
if false {
} else {
- r.EncodeBool(bool(x.EnableDebuggingHandlers))
+ r.EncodeInt(int64(x.EventBurst))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("enableDebuggingHandlers"))
+ r.EncodeString(codecSelferC_UTF81234, string("eventBurst"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym86 := z.EncBinary()
_ = yym86
if false {
} else {
- r.EncodeBool(bool(x.EnableDebuggingHandlers))
+ r.EncodeInt(int64(x.EventBurst))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy88 := &x.MinimumGCAge
- yym89 := z.EncBinary()
- _ = yym89
+ yym88 := z.EncBinary()
+ _ = yym88
if false {
- } else if z.HasExtensions() && z.EncExt(yy88) {
- } else if !yym89 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy88)
} else {
- z.EncFallback(yy88)
+ r.EncodeBool(bool(x.EnableDebuggingHandlers))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("minimumGCAge"))
+ r.EncodeString(codecSelferC_UTF81234, string("enableDebuggingHandlers"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy90 := &x.MinimumGCAge
- yym91 := z.EncBinary()
- _ = yym91
+ yym89 := z.EncBinary()
+ _ = yym89
if false {
- } else if z.HasExtensions() && z.EncExt(yy90) {
- } else if !yym91 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy90)
} else {
- z.EncFallback(yy90)
+ r.EncodeBool(bool(x.EnableDebuggingHandlers))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym93 := z.EncBinary()
- _ = yym93
+ yy91 := &x.MinimumGCAge
+ yym92 := z.EncBinary()
+ _ = yym92
if false {
+ } else if z.HasExtensions() && z.EncExt(yy91) {
+ } else if !yym92 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy91)
} else {
- r.EncodeInt(int64(x.MaxPerPodContainerCount))
+ z.EncFallback(yy91)
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("maxPerPodContainerCount"))
+ r.EncodeString(codecSelferC_UTF81234, string("minimumGCAge"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy93 := &x.MinimumGCAge
yym94 := z.EncBinary()
_ = yym94
if false {
+ } else if z.HasExtensions() && z.EncExt(yy93) {
+ } else if !yym94 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy93)
} else {
- r.EncodeInt(int64(x.MaxPerPodContainerCount))
+ z.EncFallback(yy93)
}
}
if yyr2 || yy2arr2 {
@@ -1771,17 +1778,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym96
if false {
} else {
- r.EncodeInt(int64(x.MaxContainerCount))
+ r.EncodeInt(int64(x.MaxPerPodContainerCount))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("maxContainerCount"))
+ r.EncodeString(codecSelferC_UTF81234, string("maxPerPodContainerCount"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym97 := z.EncBinary()
_ = yym97
if false {
} else {
- r.EncodeInt(int64(x.MaxContainerCount))
+ r.EncodeInt(int64(x.MaxPerPodContainerCount))
}
}
if yyr2 || yy2arr2 {
@@ -1790,17 +1797,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym99
if false {
} else {
- r.EncodeUint(uint64(x.CAdvisorPort))
+ r.EncodeInt(int64(x.MaxContainerCount))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("cAdvisorPort"))
+ r.EncodeString(codecSelferC_UTF81234, string("maxContainerCount"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym100 := z.EncBinary()
_ = yym100
if false {
} else {
- r.EncodeUint(uint64(x.CAdvisorPort))
+ r.EncodeInt(int64(x.MaxContainerCount))
}
}
if yyr2 || yy2arr2 {
@@ -1809,17 +1816,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym102
if false {
} else {
- r.EncodeInt(int64(x.HealthzPort))
+ r.EncodeUint(uint64(x.CAdvisorPort))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("healthzPort"))
+ r.EncodeString(codecSelferC_UTF81234, string("cAdvisorPort"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym103 := z.EncBinary()
_ = yym103
if false {
} else {
- r.EncodeInt(int64(x.HealthzPort))
+ r.EncodeUint(uint64(x.CAdvisorPort))
}
}
if yyr2 || yy2arr2 {
@@ -1828,17 +1835,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym105
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress))
+ r.EncodeInt(int64(x.HealthzPort))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("healthzBindAddress"))
+ r.EncodeString(codecSelferC_UTF81234, string("healthzPort"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym106 := z.EncBinary()
_ = yym106
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress))
+ r.EncodeInt(int64(x.HealthzPort))
}
}
if yyr2 || yy2arr2 {
@@ -1847,17 +1854,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym108
if false {
} else {
- r.EncodeInt(int64(x.OOMScoreAdj))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("oomScoreAdj"))
+ r.EncodeString(codecSelferC_UTF81234, string("healthzBindAddress"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym109 := z.EncBinary()
_ = yym109
if false {
} else {
- r.EncodeInt(int64(x.OOMScoreAdj))
+ r.EncodeString(codecSelferC_UTF81234, string(x.HealthzBindAddress))
}
}
if yyr2 || yy2arr2 {
@@ -1866,17 +1873,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym111
if false {
} else {
- r.EncodeBool(bool(x.RegisterNode))
+ r.EncodeInt(int64(x.OOMScoreAdj))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("registerNode"))
+ r.EncodeString(codecSelferC_UTF81234, string("oomScoreAdj"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym112 := z.EncBinary()
_ = yym112
if false {
} else {
- r.EncodeBool(bool(x.RegisterNode))
+ r.EncodeInt(int64(x.OOMScoreAdj))
}
}
if yyr2 || yy2arr2 {
@@ -1885,17 +1892,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym114
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain))
+ r.EncodeBool(bool(x.RegisterNode))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("clusterDomain"))
+ r.EncodeString(codecSelferC_UTF81234, string("registerNode"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym115 := z.EncBinary()
_ = yym115
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain))
+ r.EncodeBool(bool(x.RegisterNode))
}
}
if yyr2 || yy2arr2 {
@@ -1904,17 +1911,17 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym117
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("masterServiceNamespace"))
+ r.EncodeString(codecSelferC_UTF81234, string("clusterDomain"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym118 := z.EncBinary()
_ = yym118
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDomain))
}
}
if yyr2 || yy2arr2 {
@@ -1923,49 +1930,55 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym120
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("clusterDNS"))
+ r.EncodeString(codecSelferC_UTF81234, string("masterServiceNamespace"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym121 := z.EncBinary()
_ = yym121
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.MasterServiceNamespace))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy123 := &x.StreamingConnectionIdleTimeout
- yym124 := z.EncBinary()
- _ = yym124
+ yym123 := z.EncBinary()
+ _ = yym123
if false {
- } else if z.HasExtensions() && z.EncExt(yy123) {
- } else if !yym124 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy123)
} else {
- z.EncFallback(yy123)
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("streamingConnectionIdleTimeout"))
+ r.EncodeString(codecSelferC_UTF81234, string("clusterDNS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy125 := &x.StreamingConnectionIdleTimeout
- yym126 := z.EncBinary()
- _ = yym126
+ yym124 := z.EncBinary()
+ _ = yym124
if false {
- } else if z.HasExtensions() && z.EncExt(yy125) {
- } else if !yym126 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy125)
} else {
- z.EncFallback(yy125)
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClusterDNS))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy128 := &x.NodeStatusUpdateFrequency
+ yy126 := &x.StreamingConnectionIdleTimeout
+ yym127 := z.EncBinary()
+ _ = yym127
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy126) {
+ } else if !yym127 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy126)
+ } else {
+ z.EncFallback(yy126)
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("streamingConnectionIdleTimeout"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy128 := &x.StreamingConnectionIdleTimeout
yym129 := z.EncBinary()
_ = yym129
if false {
@@ -1975,24 +1988,24 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
z.EncFallback(yy128)
}
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy131 := &x.NodeStatusUpdateFrequency
+ yym132 := z.EncBinary()
+ _ = yym132
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy131) {
+ } else if !yym132 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy131)
+ } else {
+ z.EncFallback(yy131)
+ }
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nodeStatusUpdateFrequency"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy130 := &x.NodeStatusUpdateFrequency
- yym131 := z.EncBinary()
- _ = yym131
- if false {
- } else if z.HasExtensions() && z.EncExt(yy130) {
- } else if !yym131 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy130)
- } else {
- z.EncFallback(yy130)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy133 := &x.ImageMinimumGCAge
+ yy133 := &x.NodeStatusUpdateFrequency
yym134 := z.EncBinary()
_ = yym134
if false {
@@ -2002,25 +2015,38 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
z.EncFallback(yy133)
}
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy136 := &x.ImageMinimumGCAge
+ yym137 := z.EncBinary()
+ _ = yym137
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy136) {
+ } else if !yym137 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy136)
+ } else {
+ z.EncFallback(yy136)
+ }
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("imageMinimumGCAge"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy135 := &x.ImageMinimumGCAge
- yym136 := z.EncBinary()
- _ = yym136
+ yy138 := &x.ImageMinimumGCAge
+ yym139 := z.EncBinary()
+ _ = yym139
if false {
- } else if z.HasExtensions() && z.EncExt(yy135) {
- } else if !yym136 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy135)
+ } else if z.HasExtensions() && z.EncExt(yy138) {
+ } else if !yym139 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy138)
} else {
- z.EncFallback(yy135)
+ z.EncFallback(yy138)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym138 := z.EncBinary()
- _ = yym138
+ yym141 := z.EncBinary()
+ _ = yym141
if false {
} else {
r.EncodeInt(int64(x.ImageGCHighThresholdPercent))
@@ -2029,8 +2055,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("imageGCHighThresholdPercent"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym139 := z.EncBinary()
- _ = yym139
+ yym142 := z.EncBinary()
+ _ = yym142
if false {
} else {
r.EncodeInt(int64(x.ImageGCHighThresholdPercent))
@@ -2038,8 +2064,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym141 := z.EncBinary()
- _ = yym141
+ yym144 := z.EncBinary()
+ _ = yym144
if false {
} else {
r.EncodeInt(int64(x.ImageGCLowThresholdPercent))
@@ -2048,8 +2074,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("imageGCLowThresholdPercent"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym142 := z.EncBinary()
- _ = yym142
+ yym145 := z.EncBinary()
+ _ = yym145
if false {
} else {
r.EncodeInt(int64(x.ImageGCLowThresholdPercent))
@@ -2057,8 +2083,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym144 := z.EncBinary()
- _ = yym144
+ yym147 := z.EncBinary()
+ _ = yym147
if false {
} else {
r.EncodeInt(int64(x.LowDiskSpaceThresholdMB))
@@ -2067,8 +2093,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("lowDiskSpaceThresholdMB"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym145 := z.EncBinary()
- _ = yym145
+ yym148 := z.EncBinary()
+ _ = yym148
if false {
} else {
r.EncodeInt(int64(x.LowDiskSpaceThresholdMB))
@@ -2076,35 +2102,35 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy147 := &x.VolumeStatsAggPeriod
- yym148 := z.EncBinary()
- _ = yym148
+ yy150 := &x.VolumeStatsAggPeriod
+ yym151 := z.EncBinary()
+ _ = yym151
if false {
- } else if z.HasExtensions() && z.EncExt(yy147) {
- } else if !yym148 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy147)
+ } else if z.HasExtensions() && z.EncExt(yy150) {
+ } else if !yym151 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy150)
} else {
- z.EncFallback(yy147)
+ z.EncFallback(yy150)
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("VolumeStatsAggPeriod"))
+ r.EncodeString(codecSelferC_UTF81234, string("volumeStatsAggPeriod"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy149 := &x.VolumeStatsAggPeriod
- yym150 := z.EncBinary()
- _ = yym150
+ yy152 := &x.VolumeStatsAggPeriod
+ yym153 := z.EncBinary()
+ _ = yym153
if false {
- } else if z.HasExtensions() && z.EncExt(yy149) {
- } else if !yym150 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy149)
+ } else if z.HasExtensions() && z.EncExt(yy152) {
+ } else if !yym153 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy152)
} else {
- z.EncFallback(yy149)
+ z.EncFallback(yy152)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym152 := z.EncBinary()
- _ = yym152
+ yym155 := z.EncBinary()
+ _ = yym155
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginName))
@@ -2113,8 +2139,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("networkPluginName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym153 := z.EncBinary()
- _ = yym153
+ yym156 := z.EncBinary()
+ _ = yym156
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginName))
@@ -2122,8 +2148,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym155 := z.EncBinary()
- _ = yym155
+ yym158 := z.EncBinary()
+ _ = yym158
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginDir))
@@ -2132,8 +2158,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("networkPluginDir"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym156 := z.EncBinary()
- _ = yym156
+ yym159 := z.EncBinary()
+ _ = yym159
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NetworkPluginDir))
@@ -2141,8 +2167,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym158 := z.EncBinary()
- _ = yym158
+ yym161 := z.EncBinary()
+ _ = yym161
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumePluginDir))
@@ -2151,8 +2177,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumePluginDir"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym159 := z.EncBinary()
- _ = yym159
+ yym162 := z.EncBinary()
+ _ = yym162
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.VolumePluginDir))
@@ -2160,9 +2186,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[47] {
- yym161 := z.EncBinary()
- _ = yym161
+ if yyq2[48] {
+ yym164 := z.EncBinary()
+ _ = yym164
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider))
@@ -2171,12 +2197,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[47] {
+ if yyq2[48] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("cloudProvider"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym162 := z.EncBinary()
- _ = yym162
+ yym165 := z.EncBinary()
+ _ = yym165
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider))
@@ -2185,9 +2211,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[48] {
- yym164 := z.EncBinary()
- _ = yym164
+ if yyq2[49] {
+ yym167 := z.EncBinary()
+ _ = yym167
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile))
@@ -2196,12 +2222,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[48] {
+ if yyq2[49] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("cloudConfigFile"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym165 := z.EncBinary()
- _ = yym165
+ yym168 := z.EncBinary()
+ _ = yym168
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile))
@@ -2210,9 +2236,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[49] {
- yym167 := z.EncBinary()
- _ = yym167
+ if yyq2[50] {
+ yym170 := z.EncBinary()
+ _ = yym170
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeletCgroups))
@@ -2221,12 +2247,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[49] {
+ if yyq2[50] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeletCgroups"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym168 := z.EncBinary()
- _ = yym168
+ yym171 := z.EncBinary()
+ _ = yym171
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeletCgroups))
@@ -2235,9 +2261,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[50] {
- yym170 := z.EncBinary()
- _ = yym170
+ if yyq2[51] {
+ yym173 := z.EncBinary()
+ _ = yym173
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RuntimeCgroups))
@@ -2246,12 +2272,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[50] {
+ if yyq2[51] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("runtimeCgroups"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym171 := z.EncBinary()
- _ = yym171
+ yym174 := z.EncBinary()
+ _ = yym174
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RuntimeCgroups))
@@ -2260,9 +2286,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[51] {
- yym173 := z.EncBinary()
- _ = yym173
+ if yyq2[52] {
+ yym176 := z.EncBinary()
+ _ = yym176
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.SystemCgroups))
@@ -2271,12 +2297,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[51] {
+ if yyq2[52] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("systemContainer"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym174 := z.EncBinary()
- _ = yym174
+ yym177 := z.EncBinary()
+ _ = yym177
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.SystemCgroups))
@@ -2285,9 +2311,9 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[52] {
- yym176 := z.EncBinary()
- _ = yym176
+ if yyq2[53] {
+ yym179 := z.EncBinary()
+ _ = yym179
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CgroupRoot))
@@ -2296,12 +2322,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[52] {
+ if yyq2[53] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("cgroupRoot"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym177 := z.EncBinary()
- _ = yym177
+ yym180 := z.EncBinary()
+ _ = yym180
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.CgroupRoot))
@@ -2310,8 +2336,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym179 := z.EncBinary()
- _ = yym179
+ yym182 := z.EncBinary()
+ _ = yym182
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntime))
@@ -2320,8 +2346,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("containerRuntime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym180 := z.EncBinary()
- _ = yym180
+ yym183 := z.EncBinary()
+ _ = yym183
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntime))
@@ -2329,9 +2355,42 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[54] {
- yym182 := z.EncBinary()
- _ = yym182
+ if yyq2[55] {
+ yy185 := &x.RuntimeRequestTimeout
+ yym186 := z.EncBinary()
+ _ = yym186
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy185) {
+ } else if !yym186 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy185)
+ } else {
+ z.EncFallback(yy185)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[55] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("runtimeRequestTimeout"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy187 := &x.RuntimeRequestTimeout
+ yym188 := z.EncBinary()
+ _ = yym188
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy187) {
+ } else if !yym188 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy187)
+ } else {
+ z.EncFallback(yy187)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[56] {
+ yym190 := z.EncBinary()
+ _ = yym190
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RktPath))
@@ -2340,12 +2399,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[54] {
+ if yyq2[56] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("rktPath"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym183 := z.EncBinary()
- _ = yym183
+ yym191 := z.EncBinary()
+ _ = yym191
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RktPath))
@@ -2354,28 +2413,34 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym185 := z.EncBinary()
- _ = yym185
- if false {
+ if yyq2[57] {
+ yym193 := z.EncBinary()
+ _ = yym193
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RktAPIEndpoint))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lockFilePath"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym186 := z.EncBinary()
- _ = yym186
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath))
+ if yyq2[57] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rktAPIEndpoint"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym194 := z.EncBinary()
+ _ = yym194
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.RktAPIEndpoint))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[56] {
- yym188 := z.EncBinary()
- _ = yym188
+ if yyq2[58] {
+ yym196 := z.EncBinary()
+ _ = yym196
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RktStage1Image))
@@ -2384,12 +2449,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[56] {
+ if yyq2[58] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("rktStage1Image"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym189 := z.EncBinary()
- _ = yym189
+ yym197 := z.EncBinary()
+ _ = yym197
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.RktStage1Image))
@@ -2398,8 +2463,46 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym191 := z.EncBinary()
- _ = yym191
+ yym199 := z.EncBinary()
+ _ = yym199
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lockFilePath"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym200 := z.EncBinary()
+ _ = yym200
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.LockFilePath))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym202 := z.EncBinary()
+ _ = yym202
+ if false {
+ } else {
+ r.EncodeBool(bool(x.ExitOnLockContention))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("exitOnLockContention"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym203 := z.EncBinary()
+ _ = yym203
+ if false {
+ } else {
+ r.EncodeBool(bool(x.ExitOnLockContention))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym205 := z.EncBinary()
+ _ = yym205
if false {
} else {
r.EncodeBool(bool(x.ConfigureCBR0))
@@ -2408,8 +2511,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("configureCbr0"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym192 := z.EncBinary()
- _ = yym192
+ yym206 := z.EncBinary()
+ _ = yym206
if false {
} else {
r.EncodeBool(bool(x.ConfigureCBR0))
@@ -2417,8 +2520,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym194 := z.EncBinary()
- _ = yym194
+ yym208 := z.EncBinary()
+ _ = yym208
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.HairpinMode))
@@ -2427,8 +2530,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hairpinMode"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym195 := z.EncBinary()
- _ = yym195
+ yym209 := z.EncBinary()
+ _ = yym209
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.HairpinMode))
@@ -2436,8 +2539,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym197 := z.EncBinary()
- _ = yym197
+ yym211 := z.EncBinary()
+ _ = yym211
if false {
} else {
r.EncodeBool(bool(x.BabysitDaemons))
@@ -2446,8 +2549,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("babysitDaemons"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym198 := z.EncBinary()
- _ = yym198
+ yym212 := z.EncBinary()
+ _ = yym212
if false {
} else {
r.EncodeBool(bool(x.BabysitDaemons))
@@ -2455,8 +2558,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym200 := z.EncBinary()
- _ = yym200
+ yym214 := z.EncBinary()
+ _ = yym214
if false {
} else {
r.EncodeInt(int64(x.MaxPods))
@@ -2465,8 +2568,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("maxPods"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym201 := z.EncBinary()
- _ = yym201
+ yym215 := z.EncBinary()
+ _ = yym215
if false {
} else {
r.EncodeInt(int64(x.MaxPods))
@@ -2474,8 +2577,27 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym203 := z.EncBinary()
- _ = yym203
+ yym217 := z.EncBinary()
+ _ = yym217
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NvidiaGPUs))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("nvidiaGPUs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym218 := z.EncBinary()
+ _ = yym218
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NvidiaGPUs))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym220 := z.EncBinary()
+ _ = yym220
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.DockerExecHandlerName))
@@ -2484,8 +2606,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("dockerExecHandlerName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym204 := z.EncBinary()
- _ = yym204
+ yym221 := z.EncBinary()
+ _ = yym221
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.DockerExecHandlerName))
@@ -2493,8 +2615,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym206 := z.EncBinary()
- _ = yym206
+ yym223 := z.EncBinary()
+ _ = yym223
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR))
@@ -2503,8 +2625,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("podCIDR"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym207 := z.EncBinary()
- _ = yym207
+ yym224 := z.EncBinary()
+ _ = yym224
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR))
@@ -2512,8 +2634,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym209 := z.EncBinary()
- _ = yym209
+ yym226 := z.EncBinary()
+ _ = yym226
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ResolverConfig))
@@ -2522,8 +2644,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("resolvConf"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym210 := z.EncBinary()
- _ = yym210
+ yym227 := z.EncBinary()
+ _ = yym227
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ResolverConfig))
@@ -2531,8 +2653,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym212 := z.EncBinary()
- _ = yym212
+ yym229 := z.EncBinary()
+ _ = yym229
if false {
} else {
r.EncodeBool(bool(x.CPUCFSQuota))
@@ -2541,8 +2663,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("cpuCFSQuota"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym213 := z.EncBinary()
- _ = yym213
+ yym230 := z.EncBinary()
+ _ = yym230
if false {
} else {
r.EncodeBool(bool(x.CPUCFSQuota))
@@ -2550,8 +2672,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym215 := z.EncBinary()
- _ = yym215
+ yym232 := z.EncBinary()
+ _ = yym232
if false {
} else {
r.EncodeBool(bool(x.Containerized))
@@ -2560,8 +2682,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("containerized"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym216 := z.EncBinary()
- _ = yym216
+ yym233 := z.EncBinary()
+ _ = yym233
if false {
} else {
r.EncodeBool(bool(x.Containerized))
@@ -2569,8 +2691,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym218 := z.EncBinary()
- _ = yym218
+ yym235 := z.EncBinary()
+ _ = yym235
if false {
} else {
r.EncodeUint(uint64(x.MaxOpenFiles))
@@ -2579,8 +2701,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("maxOpenFiles"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym219 := z.EncBinary()
- _ = yym219
+ yym236 := z.EncBinary()
+ _ = yym236
if false {
} else {
r.EncodeUint(uint64(x.MaxOpenFiles))
@@ -2588,8 +2710,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym221 := z.EncBinary()
- _ = yym221
+ yym238 := z.EncBinary()
+ _ = yym238
if false {
} else {
r.EncodeBool(bool(x.ReconcileCIDR))
@@ -2598,8 +2720,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("reconcileCIDR"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym222 := z.EncBinary()
- _ = yym222
+ yym239 := z.EncBinary()
+ _ = yym239
if false {
} else {
r.EncodeBool(bool(x.ReconcileCIDR))
@@ -2607,8 +2729,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym224 := z.EncBinary()
- _ = yym224
+ yym241 := z.EncBinary()
+ _ = yym241
if false {
} else {
r.EncodeBool(bool(x.RegisterSchedulable))
@@ -2617,8 +2739,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("registerSchedulable"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym225 := z.EncBinary()
- _ = yym225
+ yym242 := z.EncBinary()
+ _ = yym242
if false {
} else {
r.EncodeBool(bool(x.RegisterSchedulable))
@@ -2626,8 +2748,27 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym227 := z.EncBinary()
- _ = yym227
+ yym244 := z.EncBinary()
+ _ = yym244
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("contentType"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym245 := z.EncBinary()
+ _ = yym245
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym247 := z.EncBinary()
+ _ = yym247
if false {
} else {
r.EncodeFloat32(float32(x.KubeAPIQPS))
@@ -2636,8 +2777,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym228 := z.EncBinary()
- _ = yym228
+ yym248 := z.EncBinary()
+ _ = yym248
if false {
} else {
r.EncodeFloat32(float32(x.KubeAPIQPS))
@@ -2645,8 +2786,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym230 := z.EncBinary()
- _ = yym230
+ yym250 := z.EncBinary()
+ _ = yym250
if false {
} else {
r.EncodeInt(int64(x.KubeAPIBurst))
@@ -2655,8 +2796,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym231 := z.EncBinary()
- _ = yym231
+ yym251 := z.EncBinary()
+ _ = yym251
if false {
} else {
r.EncodeInt(int64(x.KubeAPIBurst))
@@ -2664,8 +2805,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym233 := z.EncBinary()
- _ = yym233
+ yym253 := z.EncBinary()
+ _ = yym253
if false {
} else {
r.EncodeBool(bool(x.SerializeImagePulls))
@@ -2674,8 +2815,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("serializeImagePulls"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym234 := z.EncBinary()
- _ = yym234
+ yym254 := z.EncBinary()
+ _ = yym254
if false {
} else {
r.EncodeBool(bool(x.SerializeImagePulls))
@@ -2683,8 +2824,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym236 := z.EncBinary()
- _ = yym236
+ yym256 := z.EncBinary()
+ _ = yym256
if false {
} else {
r.EncodeBool(bool(x.ExperimentalFlannelOverlay))
@@ -2693,8 +2834,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("experimentalFlannelOverlay"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym237 := z.EncBinary()
- _ = yym237
+ yym257 := z.EncBinary()
+ _ = yym257
if false {
} else {
r.EncodeBool(bool(x.ExperimentalFlannelOverlay))
@@ -2702,42 +2843,42 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[73] {
- yy239 := &x.OutOfDiskTransitionFrequency
- yym240 := z.EncBinary()
- _ = yym240
+ if yyq2[79] {
+ yy259 := &x.OutOfDiskTransitionFrequency
+ yym260 := z.EncBinary()
+ _ = yym260
if false {
- } else if z.HasExtensions() && z.EncExt(yy239) {
- } else if !yym240 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy239)
+ } else if z.HasExtensions() && z.EncExt(yy259) {
+ } else if !yym260 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy259)
} else {
- z.EncFallback(yy239)
+ z.EncFallback(yy259)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2[73] {
+ if yyq2[79] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("outOfDiskTransitionFrequency"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy241 := &x.OutOfDiskTransitionFrequency
- yym242 := z.EncBinary()
- _ = yym242
+ yy261 := &x.OutOfDiskTransitionFrequency
+ yym262 := z.EncBinary()
+ _ = yym262
if false {
- } else if z.HasExtensions() && z.EncExt(yy241) {
- } else if !yym242 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy241)
+ } else if z.HasExtensions() && z.EncExt(yy261) {
+ } else if !yym262 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy261)
} else {
- z.EncFallback(yy241)
+ z.EncFallback(yy261)
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[74] {
- yym244 := z.EncBinary()
- _ = yym244
+ if yyq2[80] {
+ yym264 := z.EncBinary()
+ _ = yym264
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NodeIP))
@@ -2746,12 +2887,12 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[74] {
+ if yyq2[80] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nodeIP"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym245 := z.EncBinary()
- _ = yym245
+ yym265 := z.EncBinary()
+ _ = yym265
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NodeIP))
@@ -2763,8 +2904,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
if x.NodeLabels == nil {
r.EncodeNil()
} else {
- yym247 := z.EncBinary()
- _ = yym247
+ yym267 := z.EncBinary()
+ _ = yym267
if false {
} else {
z.F.EncMapStringStringV(x.NodeLabels, false, e)
@@ -2777,8 +2918,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
if x.NodeLabels == nil {
r.EncodeNil()
} else {
- yym248 := z.EncBinary()
- _ = yym248
+ yym268 := z.EncBinary()
+ _ = yym268
if false {
} else {
z.F.EncMapStringStringV(x.NodeLabels, false, e)
@@ -2787,8 +2928,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym250 := z.EncBinary()
- _ = yym250
+ yym270 := z.EncBinary()
+ _ = yym270
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NonMasqueradeCIDR))
@@ -2797,8 +2938,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nonMasqueradeCIDR"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym251 := z.EncBinary()
- _ = yym251
+ yym271 := z.EncBinary()
+ _ = yym271
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.NonMasqueradeCIDR))
@@ -2806,8 +2947,8 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym253 := z.EncBinary()
- _ = yym253
+ yym273 := z.EncBinary()
+ _ = yym273
if false {
} else {
r.EncodeBool(bool(x.EnableCustomMetrics))
@@ -2816,13 +2957,184 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("enableCustomMetrics"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym254 := z.EncBinary()
- _ = yym254
+ yym274 := z.EncBinary()
+ _ = yym274
if false {
} else {
r.EncodeBool(bool(x.EnableCustomMetrics))
}
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[84] {
+ yym276 := z.EncBinary()
+ _ = yym276
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionHard))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[84] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("evictionHard"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym277 := z.EncBinary()
+ _ = yym277
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionHard))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[85] {
+ yym279 := z.EncBinary()
+ _ = yym279
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionSoft))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[85] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("evictionSoft"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym280 := z.EncBinary()
+ _ = yym280
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionSoft))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[86] {
+ yym282 := z.EncBinary()
+ _ = yym282
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionSoftGracePeriod))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[86] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("evictionSoftGracePeriod"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym283 := z.EncBinary()
+ _ = yym283
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.EvictionSoftGracePeriod))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[87] {
+ yy285 := &x.EvictionPressureTransitionPeriod
+ yym286 := z.EncBinary()
+ _ = yym286
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy285) {
+ } else if !yym286 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy285)
+ } else {
+ z.EncFallback(yy285)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[87] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("evictionPressureTransitionPeriod"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy287 := &x.EvictionPressureTransitionPeriod
+ yym288 := z.EncBinary()
+ _ = yym288
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy287) {
+ } else if !yym288 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy287)
+ } else {
+ z.EncFallback(yy287)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[88] {
+ yym290 := z.EncBinary()
+ _ = yym290
+ if false {
+ } else {
+ r.EncodeInt(int64(x.EvictionMaxPodGracePeriod))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[88] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("evictionMaxPodGracePeriod"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym291 := z.EncBinary()
+ _ = yym291
+ if false {
+ } else {
+ r.EncodeInt(int64(x.EvictionMaxPodGracePeriod))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym293 := z.EncBinary()
+ _ = yym293
+ if false {
+ } else {
+ r.EncodeInt(int64(x.PodsPerCore))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podsPerCore"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym294 := z.EncBinary()
+ _ = yym294
+ if false {
+ } else {
+ r.EncodeInt(int64(x.PodsPerCore))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym296 := z.EncBinary()
+ _ = yym296
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableControllerAttachDetach))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("enableControllerAttachDetach"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym297 := z.EncBinary()
+ _ = yym297
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableControllerAttachDetach))
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -3013,6 +3325,12 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
} else {
x.RootDirectory = string(r.DecodeString())
}
+ case "seccompProfileRoot":
+ if r.TryDecodeAsNil() {
+ x.SeccompProfileRoot = ""
+ } else {
+ x.SeccompProfileRoot = string(r.DecodeString())
+ }
case "allowPrivileged":
if r.TryDecodeAsNil() {
x.AllowPrivileged = false
@@ -3047,7 +3365,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.RegistryBurst = 0
} else {
- x.RegistryBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RegistryBurst = int32(r.DecodeInt(32))
}
case "eventRecordQPS":
if r.TryDecodeAsNil() {
@@ -3059,7 +3377,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.EventBurst = 0
} else {
- x.EventBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.EventBurst = int32(r.DecodeInt(32))
}
case "enableDebuggingHandlers":
if r.TryDecodeAsNil() {
@@ -3071,28 +3389,28 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.MinimumGCAge = pkg1_unversioned.Duration{}
} else {
- yyv33 := &x.MinimumGCAge
- yym34 := z.DecBinary()
- _ = yym34
+ yyv34 := &x.MinimumGCAge
+ yym35 := z.DecBinary()
+ _ = yym35
if false {
- } else if z.HasExtensions() && z.DecExt(yyv33) {
- } else if !yym34 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv33)
+ } else if z.HasExtensions() && z.DecExt(yyv34) {
+ } else if !yym35 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv34)
} else {
- z.DecFallback(yyv33, false)
+ z.DecFallback(yyv34, false)
}
}
case "maxPerPodContainerCount":
if r.TryDecodeAsNil() {
x.MaxPerPodContainerCount = 0
} else {
- x.MaxPerPodContainerCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxPerPodContainerCount = int32(r.DecodeInt(32))
}
case "maxContainerCount":
if r.TryDecodeAsNil() {
x.MaxContainerCount = 0
} else {
- x.MaxContainerCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxContainerCount = int32(r.DecodeInt(32))
}
case "cAdvisorPort":
if r.TryDecodeAsNil() {
@@ -3104,7 +3422,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.HealthzPort = 0
} else {
- x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HealthzPort = int32(r.DecodeInt(32))
}
case "healthzBindAddress":
if r.TryDecodeAsNil() {
@@ -3116,7 +3434,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.OOMScoreAdj = 0
} else {
- x.OOMScoreAdj = int(r.DecodeInt(codecSelferBitsize1234))
+ x.OOMScoreAdj = int32(r.DecodeInt(32))
}
case "registerNode":
if r.TryDecodeAsNil() {
@@ -3146,78 +3464,78 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{}
} else {
- yyv45 := &x.StreamingConnectionIdleTimeout
- yym46 := z.DecBinary()
- _ = yym46
+ yyv46 := &x.StreamingConnectionIdleTimeout
+ yym47 := z.DecBinary()
+ _ = yym47
if false {
- } else if z.HasExtensions() && z.DecExt(yyv45) {
- } else if !yym46 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv45)
+ } else if z.HasExtensions() && z.DecExt(yyv46) {
+ } else if !yym47 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv46)
} else {
- z.DecFallback(yyv45, false)
+ z.DecFallback(yyv46, false)
}
}
case "nodeStatusUpdateFrequency":
if r.TryDecodeAsNil() {
x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{}
} else {
- yyv47 := &x.NodeStatusUpdateFrequency
- yym48 := z.DecBinary()
- _ = yym48
+ yyv48 := &x.NodeStatusUpdateFrequency
+ yym49 := z.DecBinary()
+ _ = yym49
if false {
- } else if z.HasExtensions() && z.DecExt(yyv47) {
- } else if !yym48 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv47)
+ } else if z.HasExtensions() && z.DecExt(yyv48) {
+ } else if !yym49 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv48)
} else {
- z.DecFallback(yyv47, false)
+ z.DecFallback(yyv48, false)
}
}
case "imageMinimumGCAge":
if r.TryDecodeAsNil() {
x.ImageMinimumGCAge = pkg1_unversioned.Duration{}
} else {
- yyv49 := &x.ImageMinimumGCAge
- yym50 := z.DecBinary()
- _ = yym50
+ yyv50 := &x.ImageMinimumGCAge
+ yym51 := z.DecBinary()
+ _ = yym51
if false {
- } else if z.HasExtensions() && z.DecExt(yyv49) {
- } else if !yym50 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv49)
+ } else if z.HasExtensions() && z.DecExt(yyv50) {
+ } else if !yym51 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv50)
} else {
- z.DecFallback(yyv49, false)
+ z.DecFallback(yyv50, false)
}
}
case "imageGCHighThresholdPercent":
if r.TryDecodeAsNil() {
x.ImageGCHighThresholdPercent = 0
} else {
- x.ImageGCHighThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ImageGCHighThresholdPercent = int32(r.DecodeInt(32))
}
case "imageGCLowThresholdPercent":
if r.TryDecodeAsNil() {
x.ImageGCLowThresholdPercent = 0
} else {
- x.ImageGCLowThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ImageGCLowThresholdPercent = int32(r.DecodeInt(32))
}
case "lowDiskSpaceThresholdMB":
if r.TryDecodeAsNil() {
x.LowDiskSpaceThresholdMB = 0
} else {
- x.LowDiskSpaceThresholdMB = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LowDiskSpaceThresholdMB = int32(r.DecodeInt(32))
}
- case "VolumeStatsAggPeriod":
+ case "volumeStatsAggPeriod":
if r.TryDecodeAsNil() {
x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{}
} else {
- yyv54 := &x.VolumeStatsAggPeriod
- yym55 := z.DecBinary()
- _ = yym55
+ yyv55 := &x.VolumeStatsAggPeriod
+ yym56 := z.DecBinary()
+ _ = yym56
if false {
- } else if z.HasExtensions() && z.DecExt(yyv54) {
- } else if !yym55 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv54)
+ } else if z.HasExtensions() && z.DecExt(yyv55) {
+ } else if !yym56 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv55)
} else {
- z.DecFallback(yyv54, false)
+ z.DecFallback(yyv55, false)
}
}
case "networkPluginName":
@@ -3280,17 +3598,32 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
} else {
x.ContainerRuntime = string(r.DecodeString())
}
+ case "runtimeRequestTimeout":
+ if r.TryDecodeAsNil() {
+ x.RuntimeRequestTimeout = pkg1_unversioned.Duration{}
+ } else {
+ yyv67 := &x.RuntimeRequestTimeout
+ yym68 := z.DecBinary()
+ _ = yym68
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv67) {
+ } else if !yym68 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv67)
+ } else {
+ z.DecFallback(yyv67, false)
+ }
+ }
case "rktPath":
if r.TryDecodeAsNil() {
x.RktPath = ""
} else {
x.RktPath = string(r.DecodeString())
}
- case "lockFilePath":
+ case "rktAPIEndpoint":
if r.TryDecodeAsNil() {
- x.LockFilePath = ""
+ x.RktAPIEndpoint = ""
} else {
- x.LockFilePath = string(r.DecodeString())
+ x.RktAPIEndpoint = string(r.DecodeString())
}
case "rktStage1Image":
if r.TryDecodeAsNil() {
@@ -3298,6 +3631,18 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
} else {
x.RktStage1Image = string(r.DecodeString())
}
+ case "lockFilePath":
+ if r.TryDecodeAsNil() {
+ x.LockFilePath = ""
+ } else {
+ x.LockFilePath = string(r.DecodeString())
+ }
+ case "exitOnLockContention":
+ if r.TryDecodeAsNil() {
+ x.ExitOnLockContention = false
+ } else {
+ x.ExitOnLockContention = bool(r.DecodeBool())
+ }
case "configureCbr0":
if r.TryDecodeAsNil() {
x.ConfigureCBR0 = false
@@ -3320,7 +3665,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.MaxPods = 0
} else {
- x.MaxPods = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxPods = int32(r.DecodeInt(32))
+ }
+ case "nvidiaGPUs":
+ if r.TryDecodeAsNil() {
+ x.NvidiaGPUs = 0
+ } else {
+ x.NvidiaGPUs = int32(r.DecodeInt(32))
}
case "dockerExecHandlerName":
if r.TryDecodeAsNil() {
@@ -3370,6 +3721,12 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
} else {
x.RegisterSchedulable = bool(r.DecodeBool())
}
+ case "contentType":
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
case "kubeAPIQPS":
if r.TryDecodeAsNil() {
x.KubeAPIQPS = 0
@@ -3380,7 +3737,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
case "serializeImagePulls":
if r.TryDecodeAsNil() {
@@ -3398,15 +3755,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{}
} else {
- yyv85 := &x.OutOfDiskTransitionFrequency
- yym86 := z.DecBinary()
- _ = yym86
+ yyv92 := &x.OutOfDiskTransitionFrequency
+ yym93 := z.DecBinary()
+ _ = yym93
if false {
- } else if z.HasExtensions() && z.DecExt(yyv85) {
- } else if !yym86 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv85)
+ } else if z.HasExtensions() && z.DecExt(yyv92) {
+ } else if !yym93 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv92)
} else {
- z.DecFallback(yyv85, false)
+ z.DecFallback(yyv92, false)
}
}
case "nodeIP":
@@ -3419,12 +3776,12 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.NodeLabels = nil
} else {
- yyv88 := &x.NodeLabels
- yym89 := z.DecBinary()
- _ = yym89
+ yyv95 := &x.NodeLabels
+ yym96 := z.DecBinary()
+ _ = yym96
if false {
} else {
- z.F.DecMapStringStringX(yyv88, false, d)
+ z.F.DecMapStringStringX(yyv95, false, d)
}
}
case "nonMasqueradeCIDR":
@@ -3439,6 +3796,57 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode
} else {
x.EnableCustomMetrics = bool(r.DecodeBool())
}
+ case "evictionHard":
+ if r.TryDecodeAsNil() {
+ x.EvictionHard = ""
+ } else {
+ x.EvictionHard = string(r.DecodeString())
+ }
+ case "evictionSoft":
+ if r.TryDecodeAsNil() {
+ x.EvictionSoft = ""
+ } else {
+ x.EvictionSoft = string(r.DecodeString())
+ }
+ case "evictionSoftGracePeriod":
+ if r.TryDecodeAsNil() {
+ x.EvictionSoftGracePeriod = ""
+ } else {
+ x.EvictionSoftGracePeriod = string(r.DecodeString())
+ }
+ case "evictionPressureTransitionPeriod":
+ if r.TryDecodeAsNil() {
+ x.EvictionPressureTransitionPeriod = pkg1_unversioned.Duration{}
+ } else {
+ yyv102 := &x.EvictionPressureTransitionPeriod
+ yym103 := z.DecBinary()
+ _ = yym103
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv102) {
+ } else if !yym103 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv102)
+ } else {
+ z.DecFallback(yyv102, false)
+ }
+ }
+ case "evictionMaxPodGracePeriod":
+ if r.TryDecodeAsNil() {
+ x.EvictionMaxPodGracePeriod = 0
+ } else {
+ x.EvictionMaxPodGracePeriod = int32(r.DecodeInt(32))
+ }
+ case "podsPerCore":
+ if r.TryDecodeAsNil() {
+ x.PodsPerCore = 0
+ } else {
+ x.PodsPerCore = int32(r.DecodeInt(32))
+ }
+ case "enableControllerAttachDetach":
+ if r.TryDecodeAsNil() {
+ x.EnableControllerAttachDetach = false
+ } else {
+ x.EnableControllerAttachDetach = bool(r.DecodeBool())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -3450,16 +3858,16 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj92 int
- var yyb92 bool
- var yyhl92 bool = l >= 0
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ var yyj107 int
+ var yyb107 bool
+ var yyhl107 bool = l >= 0
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3469,13 +3877,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Config = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3483,24 +3891,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.SyncFrequency = pkg1_unversioned.Duration{}
} else {
- yyv94 := &x.SyncFrequency
- yym95 := z.DecBinary()
- _ = yym95
+ yyv109 := &x.SyncFrequency
+ yym110 := z.DecBinary()
+ _ = yym110
if false {
- } else if z.HasExtensions() && z.DecExt(yyv94) {
- } else if !yym95 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv94)
+ } else if z.HasExtensions() && z.DecExt(yyv109) {
+ } else if !yym110 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv109)
} else {
- z.DecFallback(yyv94, false)
+ z.DecFallback(yyv109, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3508,24 +3916,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.FileCheckFrequency = pkg1_unversioned.Duration{}
} else {
- yyv96 := &x.FileCheckFrequency
- yym97 := z.DecBinary()
- _ = yym97
+ yyv111 := &x.FileCheckFrequency
+ yym112 := z.DecBinary()
+ _ = yym112
if false {
- } else if z.HasExtensions() && z.DecExt(yyv96) {
- } else if !yym97 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv96)
+ } else if z.HasExtensions() && z.DecExt(yyv111) {
+ } else if !yym112 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv111)
} else {
- z.DecFallback(yyv96, false)
+ z.DecFallback(yyv111, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3533,24 +3941,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.HTTPCheckFrequency = pkg1_unversioned.Duration{}
} else {
- yyv98 := &x.HTTPCheckFrequency
- yym99 := z.DecBinary()
- _ = yym99
+ yyv113 := &x.HTTPCheckFrequency
+ yym114 := z.DecBinary()
+ _ = yym114
if false {
- } else if z.HasExtensions() && z.DecExt(yyv98) {
- } else if !yym99 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv98)
+ } else if z.HasExtensions() && z.DecExt(yyv113) {
+ } else if !yym114 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv113)
} else {
- z.DecFallback(yyv98, false)
+ z.DecFallback(yyv113, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3560,13 +3968,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ManifestURL = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3576,13 +3984,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ManifestURLHeader = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3592,13 +4000,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.EnableServer = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3608,13 +4016,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Address = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3624,13 +4032,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Port = uint(r.DecodeUint(codecSelferBitsize1234))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3640,13 +4048,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ReadOnlyPort = uint(r.DecodeUint(codecSelferBitsize1234))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3656,13 +4064,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.TLSCertFile = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3672,13 +4080,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.TLSPrivateKeyFile = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3688,13 +4096,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CertDirectory = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3704,13 +4112,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HostnameOverride = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3720,13 +4128,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.PodInfraContainerImage = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3736,13 +4144,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.DockerEndpoint = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3752,13 +4160,29 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RootDirectory = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SeccompProfileRoot = ""
+ } else {
+ x.SeccompProfileRoot = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3768,13 +4192,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.AllowPrivileged = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3784,13 +4208,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HostNetworkSources = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3800,13 +4224,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HostPIDSources = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3816,13 +4240,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HostIPCSources = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3832,13 +4256,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RegistryPullQPS = float64(r.DecodeFloat(false))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3846,15 +4270,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.RegistryBurst = 0
} else {
- x.RegistryBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RegistryBurst = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3864,13 +4288,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.EventRecordQPS = float32(r.DecodeFloat(true))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3878,15 +4302,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.EventBurst = 0
} else {
- x.EventBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.EventBurst = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3896,13 +4320,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.EnableDebuggingHandlers = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3910,24 +4334,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.MinimumGCAge = pkg1_unversioned.Duration{}
} else {
- yyv122 := &x.MinimumGCAge
- yym123 := z.DecBinary()
- _ = yym123
+ yyv138 := &x.MinimumGCAge
+ yym139 := z.DecBinary()
+ _ = yym139
if false {
- } else if z.HasExtensions() && z.DecExt(yyv122) {
- } else if !yym123 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv122)
+ } else if z.HasExtensions() && z.DecExt(yyv138) {
+ } else if !yym139 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv138)
} else {
- z.DecFallback(yyv122, false)
+ z.DecFallback(yyv138, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3935,15 +4359,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.MaxPerPodContainerCount = 0
} else {
- x.MaxPerPodContainerCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxPerPodContainerCount = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3951,15 +4375,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.MaxContainerCount = 0
} else {
- x.MaxContainerCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxContainerCount = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3969,13 +4393,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CAdvisorPort = uint(r.DecodeUint(codecSelferBitsize1234))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -3983,15 +4407,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.HealthzPort = 0
} else {
- x.HealthzPort = int(r.DecodeInt(codecSelferBitsize1234))
+ x.HealthzPort = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4001,13 +4425,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HealthzBindAddress = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4015,15 +4439,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.OOMScoreAdj = 0
} else {
- x.OOMScoreAdj = int(r.DecodeInt(codecSelferBitsize1234))
+ x.OOMScoreAdj = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4033,13 +4457,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RegisterNode = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4049,13 +4473,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ClusterDomain = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4065,13 +4489,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.MasterServiceNamespace = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4081,13 +4505,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ClusterDNS = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4095,24 +4519,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{}
} else {
- yyv134 := &x.StreamingConnectionIdleTimeout
- yym135 := z.DecBinary()
- _ = yym135
+ yyv150 := &x.StreamingConnectionIdleTimeout
+ yym151 := z.DecBinary()
+ _ = yym151
if false {
- } else if z.HasExtensions() && z.DecExt(yyv134) {
- } else if !yym135 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv134)
+ } else if z.HasExtensions() && z.DecExt(yyv150) {
+ } else if !yym151 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv150)
} else {
- z.DecFallback(yyv134, false)
+ z.DecFallback(yyv150, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4120,24 +4544,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{}
} else {
- yyv136 := &x.NodeStatusUpdateFrequency
- yym137 := z.DecBinary()
- _ = yym137
+ yyv152 := &x.NodeStatusUpdateFrequency
+ yym153 := z.DecBinary()
+ _ = yym153
if false {
- } else if z.HasExtensions() && z.DecExt(yyv136) {
- } else if !yym137 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv136)
+ } else if z.HasExtensions() && z.DecExt(yyv152) {
+ } else if !yym153 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv152)
} else {
- z.DecFallback(yyv136, false)
+ z.DecFallback(yyv152, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4145,24 +4569,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.ImageMinimumGCAge = pkg1_unversioned.Duration{}
} else {
- yyv138 := &x.ImageMinimumGCAge
- yym139 := z.DecBinary()
- _ = yym139
+ yyv154 := &x.ImageMinimumGCAge
+ yym155 := z.DecBinary()
+ _ = yym155
if false {
- } else if z.HasExtensions() && z.DecExt(yyv138) {
- } else if !yym139 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv138)
+ } else if z.HasExtensions() && z.DecExt(yyv154) {
+ } else if !yym155 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv154)
} else {
- z.DecFallback(yyv138, false)
+ z.DecFallback(yyv154, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4170,15 +4594,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.ImageGCHighThresholdPercent = 0
} else {
- x.ImageGCHighThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ImageGCHighThresholdPercent = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4186,15 +4610,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.ImageGCLowThresholdPercent = 0
} else {
- x.ImageGCLowThresholdPercent = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ImageGCLowThresholdPercent = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4202,15 +4626,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.LowDiskSpaceThresholdMB = 0
} else {
- x.LowDiskSpaceThresholdMB = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LowDiskSpaceThresholdMB = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4218,24 +4642,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{}
} else {
- yyv143 := &x.VolumeStatsAggPeriod
- yym144 := z.DecBinary()
- _ = yym144
+ yyv159 := &x.VolumeStatsAggPeriod
+ yym160 := z.DecBinary()
+ _ = yym160
if false {
- } else if z.HasExtensions() && z.DecExt(yyv143) {
- } else if !yym144 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv143)
+ } else if z.HasExtensions() && z.DecExt(yyv159) {
+ } else if !yym160 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv159)
} else {
- z.DecFallback(yyv143, false)
+ z.DecFallback(yyv159, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4245,13 +4669,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.NetworkPluginName = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4261,13 +4685,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.NetworkPluginDir = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4277,13 +4701,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.VolumePluginDir = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4293,13 +4717,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CloudProvider = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4309,13 +4733,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CloudConfigFile = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4325,13 +4749,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.KubeletCgroups = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4341,13 +4765,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RuntimeCgroups = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4357,13 +4781,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.SystemCgroups = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4373,13 +4797,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CgroupRoot = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4389,13 +4813,38 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ContainerRuntime = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RuntimeRequestTimeout = pkg1_unversioned.Duration{}
+ } else {
+ yyv171 := &x.RuntimeRequestTimeout
+ yym172 := z.DecBinary()
+ _ = yym172
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv171) {
+ } else if !yym172 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv171)
+ } else {
+ z.DecFallback(yyv171, false)
+ }
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4405,13 +4854,45 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RktPath = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RktAPIEndpoint = ""
+ } else {
+ x.RktAPIEndpoint = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RktStage1Image = ""
+ } else {
+ x.RktStage1Image = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4421,29 +4902,29 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.LockFilePath = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.RktStage1Image = ""
+ x.ExitOnLockContention = false
} else {
- x.RktStage1Image = string(r.DecodeString())
+ x.ExitOnLockContention = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4453,13 +4934,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ConfigureCBR0 = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4469,13 +4950,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.HairpinMode = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4485,13 +4966,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.BabysitDaemons = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4499,15 +4980,31 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.MaxPods = 0
} else {
- x.MaxPods = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaxPods = int32(r.DecodeInt(32))
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.NvidiaGPUs = 0
+ } else {
+ x.NvidiaGPUs = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4517,13 +5014,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.DockerExecHandlerName = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4533,13 +5030,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.PodCIDR = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4549,13 +5046,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ResolverConfig = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4565,13 +5062,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.CPUCFSQuota = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4581,13 +5078,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Containerized = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4597,13 +5094,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.MaxOpenFiles = uint64(r.DecodeUint(64))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4613,13 +5110,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ReconcileCIDR = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4629,13 +5126,29 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.RegisterSchedulable = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4645,13 +5158,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.KubeAPIQPS = float32(r.DecodeFloat(true))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4659,15 +5172,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4677,13 +5190,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.SerializeImagePulls = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4693,13 +5206,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.ExperimentalFlannelOverlay = bool(r.DecodeBool())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4707,24 +5220,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{}
} else {
- yyv174 := &x.OutOfDiskTransitionFrequency
- yym175 := z.DecBinary()
- _ = yym175
+ yyv196 := &x.OutOfDiskTransitionFrequency
+ yym197 := z.DecBinary()
+ _ = yym197
if false {
- } else if z.HasExtensions() && z.DecExt(yyv174) {
- } else if !yym175 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv174)
+ } else if z.HasExtensions() && z.DecExt(yyv196) {
+ } else if !yym197 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv196)
} else {
- z.DecFallback(yyv174, false)
+ z.DecFallback(yyv196, false)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4734,13 +5247,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.NodeIP = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4748,21 +5261,21 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.NodeLabels = nil
} else {
- yyv177 := &x.NodeLabels
- yym178 := z.DecBinary()
- _ = yym178
+ yyv199 := &x.NodeLabels
+ yym200 := z.DecBinary()
+ _ = yym200
if false {
} else {
- z.F.DecMapStringStringX(yyv177, false, d)
+ z.F.DecMapStringStringX(yyv199, false, d)
}
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4772,13 +5285,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.NonMasqueradeCIDR = string(r.DecodeString())
}
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4788,18 +5301,139 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.EnableCustomMetrics = bool(r.DecodeBool())
}
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EvictionHard = ""
+ } else {
+ x.EvictionHard = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EvictionSoft = ""
+ } else {
+ x.EvictionSoft = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EvictionSoftGracePeriod = ""
+ } else {
+ x.EvictionSoftGracePeriod = string(r.DecodeString())
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EvictionPressureTransitionPeriod = pkg1_unversioned.Duration{}
+ } else {
+ yyv206 := &x.EvictionPressureTransitionPeriod
+ yym207 := z.DecBinary()
+ _ = yym207
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv206) {
+ } else if !yym207 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv206)
+ } else {
+ z.DecFallback(yyv206, false)
+ }
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EvictionMaxPodGracePeriod = 0
+ } else {
+ x.EvictionMaxPodGracePeriod = int32(r.DecodeInt(32))
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodsPerCore = 0
+ } else {
+ x.PodsPerCore = int32(r.DecodeInt(32))
+ }
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
+ } else {
+ yyb107 = r.CheckBreak()
+ }
+ if yyb107 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EnableControllerAttachDetach = false
+ } else {
+ x.EnableControllerAttachDetach = bool(r.DecodeBool())
+ }
for {
- yyj92++
- if yyhl92 {
- yyb92 = yyj92 > l
+ yyj107++
+ if yyhl107 {
+ yyb107 = yyj107 > l
} else {
- yyb92 = r.CheckBreak()
+ yyb107 = r.CheckBreak()
}
- if yyb92 {
+ if yyb107 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj92-1, "")
+ z.DecStructFieldNotFound(yyj107-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -4818,16 +5452,16 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [11]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[9] = x.Kind != ""
- yyq2[10] = x.APIVersion != ""
+ yyq2[12] = x.Kind != ""
+ yyq2[13] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(11)
+ r.EncodeArrayStart(14)
} else {
- yynn2 = 9
+ yynn2 = 12
for _, b := range yyq2 {
if b {
yynn2++
@@ -4937,17 +5571,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym19
if false {
} else {
- r.EncodeFloat32(float32(x.KubeAPIQPS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS"))
+ r.EncodeString(codecSelferC_UTF81234, string("contentType"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym20 := z.EncBinary()
_ = yym20
if false {
} else {
- r.EncodeFloat32(float32(x.KubeAPIQPS))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
}
}
if yyr2 || yy2arr2 {
@@ -4956,17 +5590,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym22
if false {
} else {
- r.EncodeInt(int64(x.KubeAPIBurst))
+ r.EncodeFloat32(float32(x.KubeAPIQPS))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst"))
+ r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym23 := z.EncBinary()
_ = yym23
if false {
} else {
- r.EncodeInt(int64(x.KubeAPIBurst))
+ r.EncodeFloat32(float32(x.KubeAPIQPS))
}
}
if yyr2 || yy2arr2 {
@@ -4975,35 +5609,92 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym25
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName))
+ r.EncodeInt(int64(x.KubeAPIBurst))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("schedulerName"))
+ r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym26 := z.EncBinary()
_ = yym26
if false {
+ } else {
+ r.EncodeInt(int64(x.KubeAPIBurst))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("schedulerName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy28 := &x.LeaderElection
- yy28.CodecEncodeSelf(e)
+ yym31 := z.EncBinary()
+ _ = yym31
+ if false {
+ } else {
+ r.EncodeInt(int64(x.HardPodAffinitySymmetricWeight))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hardPodAffinitySymmetricWeight"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym32 := z.EncBinary()
+ _ = yym32
+ if false {
+ } else {
+ r.EncodeInt(int64(x.HardPodAffinitySymmetricWeight))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym34 := z.EncBinary()
+ _ = yym34
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FailureDomains))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("failureDomains"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym35 := z.EncBinary()
+ _ = yym35
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FailureDomains))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy37 := &x.LeaderElection
+ yy37.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("leaderElection"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy30 := &x.LeaderElection
- yy30.CodecEncodeSelf(e)
+ yy39 := &x.LeaderElection
+ yy39.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[9] {
- yym33 := z.EncBinary()
- _ = yym33
+ if yyq2[12] {
+ yym42 := z.EncBinary()
+ _ = yym42
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -5012,12 +5703,12 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[9] {
+ if yyq2[12] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym34 := z.EncBinary()
- _ = yym34
+ yym43 := z.EncBinary()
+ _ = yym43
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -5026,9 +5717,9 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[10] {
- yym36 := z.EncBinary()
- _ = yym36
+ if yyq2[13] {
+ yym45 := z.EncBinary()
+ _ = yym45
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -5037,12 +5728,12 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[10] {
+ if yyq2[13] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym37 := z.EncBinary()
- _ = yym37
+ yym46 := z.EncBinary()
+ _ = yym46
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -5114,7 +5805,7 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
case "address":
if r.TryDecodeAsNil() {
@@ -5140,6 +5831,12 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.
} else {
x.EnableProfiling = bool(r.DecodeBool())
}
+ case "contentType":
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
case "kubeAPIQPS":
if r.TryDecodeAsNil() {
x.KubeAPIQPS = 0
@@ -5150,7 +5847,7 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
case "schedulerName":
if r.TryDecodeAsNil() {
@@ -5158,12 +5855,24 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.
} else {
x.SchedulerName = string(r.DecodeString())
}
+ case "hardPodAffinitySymmetricWeight":
+ if r.TryDecodeAsNil() {
+ x.HardPodAffinitySymmetricWeight = 0
+ } else {
+ x.HardPodAffinitySymmetricWeight = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ case "failureDomains":
+ if r.TryDecodeAsNil() {
+ x.FailureDomains = ""
+ } else {
+ x.FailureDomains = string(r.DecodeString())
+ }
case "leaderElection":
if r.TryDecodeAsNil() {
x.LeaderElection = LeaderElectionConfiguration{}
} else {
- yyv12 := &x.LeaderElection
- yyv12.CodecDecodeSelf(d)
+ yyv15 := &x.LeaderElection
+ yyv15.CodecDecodeSelf(d)
}
case "kind":
if r.TryDecodeAsNil() {
@@ -5188,16 +5897,16 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj15 int
- var yyb15 bool
- var yyhl15 bool = l >= 0
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ var yyj18 int
+ var yyb18 bool
+ var yyhl18 bool = l >= 0
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5205,15 +5914,15 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5223,13 +5932,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.Address = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5239,13 +5948,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.AlgorithmProvider = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5255,13 +5964,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.PolicyConfigFile = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5271,13 +5980,29 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.EnableProfiling = bool(r.DecodeBool())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5287,13 +6012,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.KubeAPIQPS = float32(r.DecodeFloat(true))
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5301,15 +6026,15 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5319,13 +6044,45 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.SchedulerName = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.HardPodAffinitySymmetricWeight = 0
+ } else {
+ x.HardPodAffinitySymmetricWeight = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
+ } else {
+ yyb18 = r.CheckBreak()
+ }
+ if yyb18 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.FailureDomains = ""
+ } else {
+ x.FailureDomains = string(r.DecodeString())
+ }
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5333,16 +6090,16 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
if r.TryDecodeAsNil() {
x.LeaderElection = LeaderElectionConfiguration{}
} else {
- yyv24 := &x.LeaderElection
- yyv24.CodecDecodeSelf(d)
+ yyv30 := &x.LeaderElection
+ yyv30.CodecDecodeSelf(d)
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5352,13 +6109,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
} else {
x.Kind = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -5369,17 +6126,17 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197
x.APIVersion = string(r.DecodeString())
}
for {
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj18++
+ if yyhl18 {
+ yyb18 = yyj18 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb18 = r.CheckBreak()
}
- if yyb15 {
+ if yyb18 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj15-1, "")
+ z.DecStructFieldNotFound(yyj18-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -5761,16 +6518,16 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [43]bool
+ var yyq2 [49]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[41] = x.Kind != ""
- yyq2[42] = x.APIVersion != ""
+ yyq2[47] = x.Kind != ""
+ yyq2[48] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(43)
+ r.EncodeArrayStart(49)
} else {
- yynn2 = 41
+ yynn2 = 47
for _, b := range yyq2 {
if b {
yynn2++
@@ -6531,57 +7288,133 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("clusterCIDR"))
+ r.EncodeString(codecSelferC_UTF81234, string("clusterCIDR"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym131 := z.EncBinary()
+ _ = yym131
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym133 := z.EncBinary()
+ _ = yym133
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceCIDR))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serviceCIDR"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym134 := z.EncBinary()
+ _ = yym134
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceCIDR))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym136 := z.EncBinary()
+ _ = yym136
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NodeCIDRMaskSize))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("nodeCIDRMaskSize"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym137 := z.EncBinary()
+ _ = yym137
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NodeCIDRMaskSize))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym139 := z.EncBinary()
+ _ = yym139
+ if false {
+ } else {
+ r.EncodeBool(bool(x.AllocateNodeCIDRs))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("allocateNodeCIDRs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym140 := z.EncBinary()
+ _ = yym140
+ if false {
+ } else {
+ r.EncodeBool(bool(x.AllocateNodeCIDRs))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym142 := z.EncBinary()
+ _ = yym142
+ if false {
+ } else {
+ r.EncodeBool(bool(x.ConfigureCloudRoutes))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("configureCloudRoutes"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym131 := z.EncBinary()
- _ = yym131
+ yym143 := z.EncBinary()
+ _ = yym143
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR))
+ r.EncodeBool(bool(x.ConfigureCloudRoutes))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym133 := z.EncBinary()
- _ = yym133
+ yym145 := z.EncBinary()
+ _ = yym145
if false {
} else {
- r.EncodeBool(bool(x.AllocateNodeCIDRs))
+ r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("allocateNodeCIDRs"))
+ r.EncodeString(codecSelferC_UTF81234, string("rootCAFile"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym134 := z.EncBinary()
- _ = yym134
+ yym146 := z.EncBinary()
+ _ = yym146
if false {
} else {
- r.EncodeBool(bool(x.AllocateNodeCIDRs))
+ r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym136 := z.EncBinary()
- _ = yym136
+ yym148 := z.EncBinary()
+ _ = yym148
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rootCAFile"))
+ r.EncodeString(codecSelferC_UTF81234, string("contentType"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym137 := z.EncBinary()
- _ = yym137
+ yym149 := z.EncBinary()
+ _ = yym149
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile))
+ r.EncodeString(codecSelferC_UTF81234, string(x.ContentType))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym139 := z.EncBinary()
- _ = yym139
+ yym151 := z.EncBinary()
+ _ = yym151
if false {
} else {
r.EncodeFloat32(float32(x.KubeAPIQPS))
@@ -6590,8 +7423,8 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym140 := z.EncBinary()
- _ = yym140
+ yym152 := z.EncBinary()
+ _ = yym152
if false {
} else {
r.EncodeFloat32(float32(x.KubeAPIQPS))
@@ -6599,8 +7432,8 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym142 := z.EncBinary()
- _ = yym142
+ yym154 := z.EncBinary()
+ _ = yym154
if false {
} else {
r.EncodeInt(int64(x.KubeAPIBurst))
@@ -6609,8 +7442,8 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym143 := z.EncBinary()
- _ = yym143
+ yym155 := z.EncBinary()
+ _ = yym155
if false {
} else {
r.EncodeInt(int64(x.KubeAPIBurst))
@@ -6618,31 +7451,77 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy145 := &x.LeaderElection
- yy145.CodecEncodeSelf(e)
+ yy157 := &x.LeaderElection
+ yy157.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("leaderElection"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy147 := &x.LeaderElection
- yy147.CodecEncodeSelf(e)
+ yy159 := &x.LeaderElection
+ yy159.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy150 := &x.VolumeConfiguration
- yy150.CodecEncodeSelf(e)
+ yy162 := &x.VolumeConfiguration
+ yy162.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumeConfiguration"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy152 := &x.VolumeConfiguration
- yy152.CodecEncodeSelf(e)
+ yy164 := &x.VolumeConfiguration
+ yy164.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy167 := &x.ControllerStartInterval
+ yym168 := z.EncBinary()
+ _ = yym168
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy167) {
+ } else if !yym168 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy167)
+ } else {
+ z.EncFallback(yy167)
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("controllerStartInterval"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy169 := &x.ControllerStartInterval
+ yym170 := z.EncBinary()
+ _ = yym170
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy169) {
+ } else if !yym170 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy169)
+ } else {
+ z.EncFallback(yy169)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym172 := z.EncBinary()
+ _ = yym172
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableGarbageCollector))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("enableGarbageCollector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym173 := z.EncBinary()
+ _ = yym173
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableGarbageCollector))
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[41] {
- yym155 := z.EncBinary()
- _ = yym155
+ if yyq2[47] {
+ yym175 := z.EncBinary()
+ _ = yym175
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -6651,12 +7530,12 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[41] {
+ if yyq2[47] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym156 := z.EncBinary()
- _ = yym156
+ yym176 := z.EncBinary()
+ _ = yym176
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -6665,9 +7544,9 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[42] {
- yym158 := z.EncBinary()
- _ = yym158
+ if yyq2[48] {
+ yym178 := z.EncBinary()
+ _ = yym178
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -6676,12 +7555,12 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[42] {
+ if yyq2[48] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym159 := z.EncBinary()
- _ = yym159
+ yym179 := z.EncBinary()
+ _ = yym179
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -6753,7 +7632,7 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
case "address":
if r.TryDecodeAsNil() {
@@ -6777,67 +7656,67 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.ConcurrentEndpointSyncs = 0
} else {
- x.ConcurrentEndpointSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentEndpointSyncs = int32(r.DecodeInt(32))
}
case "concurrentRSSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentRSSyncs = 0
} else {
- x.ConcurrentRSSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentRSSyncs = int32(r.DecodeInt(32))
}
case "concurrentRCSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentRCSyncs = 0
} else {
- x.ConcurrentRCSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentRCSyncs = int32(r.DecodeInt(32))
}
case "concurrentResourceQuotaSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentResourceQuotaSyncs = 0
} else {
- x.ConcurrentResourceQuotaSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentResourceQuotaSyncs = int32(r.DecodeInt(32))
}
case "concurrentDeploymentSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentDeploymentSyncs = 0
} else {
- x.ConcurrentDeploymentSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentDeploymentSyncs = int32(r.DecodeInt(32))
}
case "concurrentDaemonSetSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentDaemonSetSyncs = 0
} else {
- x.ConcurrentDaemonSetSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentDaemonSetSyncs = int32(r.DecodeInt(32))
}
case "concurrentJobSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentJobSyncs = 0
} else {
- x.ConcurrentJobSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentJobSyncs = int32(r.DecodeInt(32))
}
case "concurrentNamespaceSyncs":
if r.TryDecodeAsNil() {
x.ConcurrentNamespaceSyncs = 0
} else {
- x.ConcurrentNamespaceSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentNamespaceSyncs = int32(r.DecodeInt(32))
}
case "lookupCacheSizeForRC":
if r.TryDecodeAsNil() {
x.LookupCacheSizeForRC = 0
} else {
- x.LookupCacheSizeForRC = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForRC = int32(r.DecodeInt(32))
}
case "lookupCacheSizeForRS":
if r.TryDecodeAsNil() {
x.LookupCacheSizeForRS = 0
} else {
- x.LookupCacheSizeForRS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForRS = int32(r.DecodeInt(32))
}
case "lookupCacheSizeForDaemonSet":
if r.TryDecodeAsNil() {
x.LookupCacheSizeForDaemonSet = 0
} else {
- x.LookupCacheSizeForDaemonSet = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForDaemonSet = int32(r.DecodeInt(32))
}
case "serviceSyncPeriod":
if r.TryDecodeAsNil() {
@@ -6933,7 +7812,7 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.TerminatedPodGCThreshold = 0
} else {
- x.TerminatedPodGCThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.TerminatedPodGCThreshold = int32(r.DecodeInt(32))
}
case "horizontalPodAutoscalerSyncPeriod":
if r.TryDecodeAsNil() {
@@ -6990,7 +7869,7 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.DeletingPodsBurst = 0
} else {
- x.DeletingPodsBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.DeletingPodsBurst = int32(r.DecodeInt(32))
}
case "nodeMonitorGracePeriod":
if r.TryDecodeAsNil() {
@@ -7011,7 +7890,7 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.RegisterRetryCount = 0
} else {
- x.RegisterRetryCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RegisterRetryCount = int32(r.DecodeInt(32))
}
case "nodeStartupGracePeriod":
if r.TryDecodeAsNil() {
@@ -7067,18 +7946,42 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
} else {
x.ClusterCIDR = string(r.DecodeString())
}
+ case "serviceCIDR":
+ if r.TryDecodeAsNil() {
+ x.ServiceCIDR = ""
+ } else {
+ x.ServiceCIDR = string(r.DecodeString())
+ }
+ case "nodeCIDRMaskSize":
+ if r.TryDecodeAsNil() {
+ x.NodeCIDRMaskSize = 0
+ } else {
+ x.NodeCIDRMaskSize = int32(r.DecodeInt(32))
+ }
case "allocateNodeCIDRs":
if r.TryDecodeAsNil() {
x.AllocateNodeCIDRs = false
} else {
x.AllocateNodeCIDRs = bool(r.DecodeBool())
}
+ case "configureCloudRoutes":
+ if r.TryDecodeAsNil() {
+ x.ConfigureCloudRoutes = false
+ } else {
+ x.ConfigureCloudRoutes = bool(r.DecodeBool())
+ }
case "rootCAFile":
if r.TryDecodeAsNil() {
x.RootCAFile = ""
} else {
x.RootCAFile = string(r.DecodeString())
}
+ case "contentType":
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
case "kubeAPIQPS":
if r.TryDecodeAsNil() {
x.KubeAPIQPS = 0
@@ -7089,21 +7992,42 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
case "leaderElection":
if r.TryDecodeAsNil() {
x.LeaderElection = LeaderElectionConfiguration{}
} else {
- yyv55 := &x.LeaderElection
- yyv55.CodecDecodeSelf(d)
+ yyv59 := &x.LeaderElection
+ yyv59.CodecDecodeSelf(d)
}
case "volumeConfiguration":
if r.TryDecodeAsNil() {
x.VolumeConfiguration = VolumeConfiguration{}
} else {
- yyv56 := &x.VolumeConfiguration
- yyv56.CodecDecodeSelf(d)
+ yyv60 := &x.VolumeConfiguration
+ yyv60.CodecDecodeSelf(d)
+ }
+ case "controllerStartInterval":
+ if r.TryDecodeAsNil() {
+ x.ControllerStartInterval = pkg1_unversioned.Duration{}
+ } else {
+ yyv61 := &x.ControllerStartInterval
+ yym62 := z.DecBinary()
+ _ = yym62
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv61) {
+ } else if !yym62 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv61)
+ } else {
+ z.DecFallback(yyv61, false)
+ }
+ }
+ case "enableGarbageCollector":
+ if r.TryDecodeAsNil() {
+ x.EnableGarbageCollector = false
+ } else {
+ x.EnableGarbageCollector = bool(r.DecodeBool())
}
case "kind":
if r.TryDecodeAsNil() {
@@ -7128,16 +8052,16 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj59 int
- var yyb59 bool
- var yyhl59 bool = l >= 0
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ var yyj66 int
+ var yyb66 bool
+ var yyhl66 bool = l >= 0
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7145,15 +8069,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.Port = 0
} else {
- x.Port = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Port = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7163,13 +8087,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.Address = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7179,13 +8103,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.CloudProvider = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7195,13 +8119,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.CloudConfigFile = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7209,15 +8133,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentEndpointSyncs = 0
} else {
- x.ConcurrentEndpointSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentEndpointSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7225,15 +8149,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentRSSyncs = 0
} else {
- x.ConcurrentRSSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentRSSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7241,15 +8165,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentRCSyncs = 0
} else {
- x.ConcurrentRCSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentRCSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7257,15 +8181,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentResourceQuotaSyncs = 0
} else {
- x.ConcurrentResourceQuotaSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentResourceQuotaSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7273,15 +8197,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentDeploymentSyncs = 0
} else {
- x.ConcurrentDeploymentSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentDeploymentSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7289,15 +8213,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentDaemonSetSyncs = 0
} else {
- x.ConcurrentDaemonSetSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentDaemonSetSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7305,15 +8229,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentJobSyncs = 0
} else {
- x.ConcurrentJobSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentJobSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7321,15 +8245,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ConcurrentNamespaceSyncs = 0
} else {
- x.ConcurrentNamespaceSyncs = int(r.DecodeInt(codecSelferBitsize1234))
+ x.ConcurrentNamespaceSyncs = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7337,15 +8261,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.LookupCacheSizeForRC = 0
} else {
- x.LookupCacheSizeForRC = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForRC = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7353,15 +8277,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.LookupCacheSizeForRS = 0
} else {
- x.LookupCacheSizeForRS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForRS = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7369,15 +8293,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.LookupCacheSizeForDaemonSet = 0
} else {
- x.LookupCacheSizeForDaemonSet = int(r.DecodeInt(codecSelferBitsize1234))
+ x.LookupCacheSizeForDaemonSet = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7385,24 +8309,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ServiceSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv75 := &x.ServiceSyncPeriod
- yym76 := z.DecBinary()
- _ = yym76
+ yyv82 := &x.ServiceSyncPeriod
+ yym83 := z.DecBinary()
+ _ = yym83
if false {
- } else if z.HasExtensions() && z.DecExt(yyv75) {
- } else if !yym76 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv75)
+ } else if z.HasExtensions() && z.DecExt(yyv82) {
+ } else if !yym83 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv82)
} else {
- z.DecFallback(yyv75, false)
+ z.DecFallback(yyv82, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7410,24 +8334,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.NodeSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv77 := &x.NodeSyncPeriod
- yym78 := z.DecBinary()
- _ = yym78
+ yyv84 := &x.NodeSyncPeriod
+ yym85 := z.DecBinary()
+ _ = yym85
if false {
- } else if z.HasExtensions() && z.DecExt(yyv77) {
- } else if !yym78 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv77)
+ } else if z.HasExtensions() && z.DecExt(yyv84) {
+ } else if !yym85 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv84)
} else {
- z.DecFallback(yyv77, false)
+ z.DecFallback(yyv84, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7435,24 +8359,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.ResourceQuotaSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv79 := &x.ResourceQuotaSyncPeriod
- yym80 := z.DecBinary()
- _ = yym80
+ yyv86 := &x.ResourceQuotaSyncPeriod
+ yym87 := z.DecBinary()
+ _ = yym87
if false {
- } else if z.HasExtensions() && z.DecExt(yyv79) {
- } else if !yym80 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv79)
+ } else if z.HasExtensions() && z.DecExt(yyv86) {
+ } else if !yym87 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv86)
} else {
- z.DecFallback(yyv79, false)
+ z.DecFallback(yyv86, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7460,24 +8384,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.NamespaceSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv81 := &x.NamespaceSyncPeriod
- yym82 := z.DecBinary()
- _ = yym82
+ yyv88 := &x.NamespaceSyncPeriod
+ yym89 := z.DecBinary()
+ _ = yym89
if false {
- } else if z.HasExtensions() && z.DecExt(yyv81) {
- } else if !yym82 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv81)
+ } else if z.HasExtensions() && z.DecExt(yyv88) {
+ } else if !yym89 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv88)
} else {
- z.DecFallback(yyv81, false)
+ z.DecFallback(yyv88, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7485,24 +8409,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv83 := &x.PVClaimBinderSyncPeriod
- yym84 := z.DecBinary()
- _ = yym84
+ yyv90 := &x.PVClaimBinderSyncPeriod
+ yym91 := z.DecBinary()
+ _ = yym91
if false {
- } else if z.HasExtensions() && z.DecExt(yyv83) {
- } else if !yym84 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv83)
+ } else if z.HasExtensions() && z.DecExt(yyv90) {
+ } else if !yym91 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv90)
} else {
- z.DecFallback(yyv83, false)
+ z.DecFallback(yyv90, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7510,24 +8434,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.MinResyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv85 := &x.MinResyncPeriod
- yym86 := z.DecBinary()
- _ = yym86
+ yyv92 := &x.MinResyncPeriod
+ yym93 := z.DecBinary()
+ _ = yym93
if false {
- } else if z.HasExtensions() && z.DecExt(yyv85) {
- } else if !yym86 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv85)
+ } else if z.HasExtensions() && z.DecExt(yyv92) {
+ } else if !yym93 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv92)
} else {
- z.DecFallback(yyv85, false)
+ z.DecFallback(yyv92, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7535,15 +8459,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.TerminatedPodGCThreshold = 0
} else {
- x.TerminatedPodGCThreshold = int(r.DecodeInt(codecSelferBitsize1234))
+ x.TerminatedPodGCThreshold = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7551,24 +8475,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv88 := &x.HorizontalPodAutoscalerSyncPeriod
- yym89 := z.DecBinary()
- _ = yym89
+ yyv95 := &x.HorizontalPodAutoscalerSyncPeriod
+ yym96 := z.DecBinary()
+ _ = yym96
if false {
- } else if z.HasExtensions() && z.DecExt(yyv88) {
- } else if !yym89 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv88)
+ } else if z.HasExtensions() && z.DecExt(yyv95) {
+ } else if !yym96 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv95)
} else {
- z.DecFallback(yyv88, false)
+ z.DecFallback(yyv95, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7576,24 +8500,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{}
} else {
- yyv90 := &x.DeploymentControllerSyncPeriod
- yym91 := z.DecBinary()
- _ = yym91
+ yyv97 := &x.DeploymentControllerSyncPeriod
+ yym98 := z.DecBinary()
+ _ = yym98
if false {
- } else if z.HasExtensions() && z.DecExt(yyv90) {
- } else if !yym91 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv90)
+ } else if z.HasExtensions() && z.DecExt(yyv97) {
+ } else if !yym98 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv97)
} else {
- z.DecFallback(yyv90, false)
+ z.DecFallback(yyv97, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7601,24 +8525,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.PodEvictionTimeout = pkg1_unversioned.Duration{}
} else {
- yyv92 := &x.PodEvictionTimeout
- yym93 := z.DecBinary()
- _ = yym93
+ yyv99 := &x.PodEvictionTimeout
+ yym100 := z.DecBinary()
+ _ = yym100
if false {
- } else if z.HasExtensions() && z.DecExt(yyv92) {
- } else if !yym93 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv92)
+ } else if z.HasExtensions() && z.DecExt(yyv99) {
+ } else if !yym100 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv99)
} else {
- z.DecFallback(yyv92, false)
+ z.DecFallback(yyv99, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7628,13 +8552,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.DeletingPodsQps = float32(r.DecodeFloat(true))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7642,15 +8566,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.DeletingPodsBurst = 0
} else {
- x.DeletingPodsBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.DeletingPodsBurst = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7658,24 +8582,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{}
} else {
- yyv96 := &x.NodeMonitorGracePeriod
- yym97 := z.DecBinary()
- _ = yym97
+ yyv103 := &x.NodeMonitorGracePeriod
+ yym104 := z.DecBinary()
+ _ = yym104
if false {
- } else if z.HasExtensions() && z.DecExt(yyv96) {
- } else if !yym97 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv96)
+ } else if z.HasExtensions() && z.DecExt(yyv103) {
+ } else if !yym104 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv103)
} else {
- z.DecFallback(yyv96, false)
+ z.DecFallback(yyv103, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7683,15 +8607,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.RegisterRetryCount = 0
} else {
- x.RegisterRetryCount = int(r.DecodeInt(codecSelferBitsize1234))
+ x.RegisterRetryCount = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7699,24 +8623,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.NodeStartupGracePeriod = pkg1_unversioned.Duration{}
} else {
- yyv99 := &x.NodeStartupGracePeriod
- yym100 := z.DecBinary()
- _ = yym100
+ yyv106 := &x.NodeStartupGracePeriod
+ yym107 := z.DecBinary()
+ _ = yym107
if false {
- } else if z.HasExtensions() && z.DecExt(yyv99) {
- } else if !yym100 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv99)
+ } else if z.HasExtensions() && z.DecExt(yyv106) {
+ } else if !yym107 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv106)
} else {
- z.DecFallback(yyv99, false)
+ z.DecFallback(yyv106, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7724,24 +8648,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.NodeMonitorPeriod = pkg1_unversioned.Duration{}
} else {
- yyv101 := &x.NodeMonitorPeriod
- yym102 := z.DecBinary()
- _ = yym102
+ yyv108 := &x.NodeMonitorPeriod
+ yym109 := z.DecBinary()
+ _ = yym109
if false {
- } else if z.HasExtensions() && z.DecExt(yyv101) {
- } else if !yym102 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv101)
+ } else if z.HasExtensions() && z.DecExt(yyv108) {
+ } else if !yym109 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv108)
} else {
- z.DecFallback(yyv101, false)
+ z.DecFallback(yyv108, false)
}
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7751,13 +8675,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.ServiceAccountKeyFile = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7767,13 +8691,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.EnableProfiling = bool(r.DecodeBool())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7783,13 +8707,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.ClusterName = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7799,13 +8723,45 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.ClusterCIDR = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ServiceCIDR = ""
+ } else {
+ x.ServiceCIDR = string(r.DecodeString())
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.NodeCIDRMaskSize = 0
+ } else {
+ x.NodeCIDRMaskSize = int32(r.DecodeInt(32))
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7815,13 +8771,29 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.AllocateNodeCIDRs = bool(r.DecodeBool())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ConfigureCloudRoutes = false
+ } else {
+ x.ConfigureCloudRoutes = bool(r.DecodeBool())
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7831,13 +8803,29 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.RootCAFile = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ContentType = ""
+ } else {
+ x.ContentType = string(r.DecodeString())
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7847,13 +8835,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.KubeAPIQPS = float32(r.DecodeFloat(true))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7861,15 +8849,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.KubeAPIBurst = 0
} else {
- x.KubeAPIBurst = int(r.DecodeInt(codecSelferBitsize1234))
+ x.KubeAPIBurst = int32(r.DecodeInt(32))
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7877,16 +8865,16 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.LeaderElection = LeaderElectionConfiguration{}
} else {
- yyv111 := &x.LeaderElection
- yyv111.CodecDecodeSelf(d)
+ yyv122 := &x.LeaderElection
+ yyv122.CodecDecodeSelf(d)
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7894,16 +8882,57 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
if r.TryDecodeAsNil() {
x.VolumeConfiguration = VolumeConfiguration{}
} else {
- yyv112 := &x.VolumeConfiguration
- yyv112.CodecDecodeSelf(d)
+ yyv123 := &x.VolumeConfiguration
+ yyv123.CodecDecodeSelf(d)
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ControllerStartInterval = pkg1_unversioned.Duration{}
+ } else {
+ yyv124 := &x.ControllerStartInterval
+ yym125 := z.DecBinary()
+ _ = yym125
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv124) {
+ } else if !yym125 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv124)
+ } else {
+ z.DecFallback(yyv124, false)
+ }
+ }
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
+ } else {
+ yyb66 = r.CheckBreak()
+ }
+ if yyb66 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EnableGarbageCollector = false
+ } else {
+ x.EnableGarbageCollector = bool(r.DecodeBool())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7913,13 +8942,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
} else {
x.Kind = string(r.DecodeString())
}
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7930,17 +8959,17 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d *
x.APIVersion = string(r.DecodeString())
}
for {
- yyj59++
- if yyhl59 {
- yyb59 = yyj59 > l
+ yyj66++
+ if yyhl66 {
+ yyb66 = yyj66 > l
} else {
- yyb59 = r.CheckBreak()
+ yyb66 = r.CheckBreak()
}
- if yyb59 {
+ if yyb66 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj59-1, "")
+ z.DecStructFieldNotFound(yyj66-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -7959,14 +8988,14 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 2
+ yynn2 = 4
for _, b := range yyq2 {
if b {
yynn2++
@@ -7996,14 +9025,52 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.PersistentVolumeRecyclerConfiguration
- yy7.CodecEncodeSelf(e)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableDynamicProvisioning))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("enableDynamicProvisioning"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeBool(bool(x.EnableDynamicProvisioning))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy10 := &x.PersistentVolumeRecyclerConfiguration
+ yy10.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("persitentVolumeRecyclerConfiguration"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.PersistentVolumeRecyclerConfiguration
- yy9.CodecEncodeSelf(e)
+ yy12 := &x.PersistentVolumeRecyclerConfiguration
+ yy12.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FlexVolumePluginDir))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("flexVolumePluginDir"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.FlexVolumePluginDir))
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -8072,12 +9139,24 @@ func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
} else {
x.EnableHostPathProvisioning = bool(r.DecodeBool())
}
+ case "enableDynamicProvisioning":
+ if r.TryDecodeAsNil() {
+ x.EnableDynamicProvisioning = false
+ } else {
+ x.EnableDynamicProvisioning = bool(r.DecodeBool())
+ }
case "persitentVolumeRecyclerConfiguration":
if r.TryDecodeAsNil() {
x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{}
} else {
- yyv5 := &x.PersistentVolumeRecyclerConfiguration
- yyv5.CodecDecodeSelf(d)
+ yyv6 := &x.PersistentVolumeRecyclerConfiguration
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "flexVolumePluginDir":
+ if r.TryDecodeAsNil() {
+ x.FlexVolumePluginDir = ""
+ } else {
+ x.FlexVolumePluginDir = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -8090,16 +9169,16 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -8109,13 +9188,29 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.EnableHostPathProvisioning = bool(r.DecodeBool())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.EnableDynamicProvisioning = false
+ } else {
+ x.EnableDynamicProvisioning = bool(r.DecodeBool())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -8123,21 +9218,37 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{}
} else {
- yyv8 := &x.PersistentVolumeRecyclerConfiguration
- yyv8.CodecDecodeSelf(d)
+ yyv11 := &x.PersistentVolumeRecyclerConfiguration
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.FlexVolumePluginDir = ""
+ } else {
+ x.FlexVolumePluginDir = string(r.DecodeString())
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -8370,13 +9481,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d
if r.TryDecodeAsNil() {
x.MaximumRetry = 0
} else {
- x.MaximumRetry = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaximumRetry = int32(r.DecodeInt(32))
}
case "minimumTimeoutNFS":
if r.TryDecodeAsNil() {
x.MinimumTimeoutNFS = 0
} else {
- x.MinimumTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MinimumTimeoutNFS = int32(r.DecodeInt(32))
}
case "podTemplateFilePathNFS":
if r.TryDecodeAsNil() {
@@ -8388,7 +9499,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d
if r.TryDecodeAsNil() {
x.IncrementTimeoutNFS = 0
} else {
- x.IncrementTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.IncrementTimeoutNFS = int32(r.DecodeInt(32))
}
case "podTemplateFilePathHostPath":
if r.TryDecodeAsNil() {
@@ -8400,13 +9511,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d
if r.TryDecodeAsNil() {
x.MinimumTimeoutHostPath = 0
} else {
- x.MinimumTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MinimumTimeoutHostPath = int32(r.DecodeInt(32))
}
case "incrementTimeoutHostPath":
if r.TryDecodeAsNil() {
x.IncrementTimeoutHostPath = 0
} else {
- x.IncrementTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234))
+ x.IncrementTimeoutHostPath = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -8436,7 +9547,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int,
if r.TryDecodeAsNil() {
x.MaximumRetry = 0
} else {
- x.MaximumRetry = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MaximumRetry = int32(r.DecodeInt(32))
}
yyj11++
if yyhl11 {
@@ -8452,7 +9563,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int,
if r.TryDecodeAsNil() {
x.MinimumTimeoutNFS = 0
} else {
- x.MinimumTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MinimumTimeoutNFS = int32(r.DecodeInt(32))
}
yyj11++
if yyhl11 {
@@ -8484,7 +9595,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int,
if r.TryDecodeAsNil() {
x.IncrementTimeoutNFS = 0
} else {
- x.IncrementTimeoutNFS = int(r.DecodeInt(codecSelferBitsize1234))
+ x.IncrementTimeoutNFS = int32(r.DecodeInt(32))
}
yyj11++
if yyhl11 {
@@ -8516,7 +9627,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int,
if r.TryDecodeAsNil() {
x.MinimumTimeoutHostPath = 0
} else {
- x.MinimumTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234))
+ x.MinimumTimeoutHostPath = int32(r.DecodeInt(32))
}
yyj11++
if yyhl11 {
@@ -8532,7 +9643,7 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int,
if r.TryDecodeAsNil() {
x.IncrementTimeoutHostPath = 0
} else {
- x.IncrementTimeoutHostPath = int(r.DecodeInt(codecSelferBitsize1234))
+ x.IncrementTimeoutHostPath = int32(r.DecodeInt(32))
}
for {
yyj11++
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.go
similarity index 81%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.go
index 04ec6e0b12e3375cfc7ee8544392c281877aaa1a..6121048b4761c6bfaaeddae7b18667948761f37a 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/types.go
@@ -32,12 +32,12 @@ type KubeProxyConfiguration struct {
// defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)
HealthzBindAddress string `json:"healthzBindAddress"`
// healthzPort is the port to bind the health check server. Use 0 to disable.
- HealthzPort int `json:"healthzPort"`
+ HealthzPort int32 `json:"healthzPort"`
// hostnameOverride, if non-empty, will be used as the identity instead of the actual hostname.
HostnameOverride string `json:"hostnameOverride"`
// iptablesMasqueradeBit is the bit of the iptables fwmark space to use for SNAT if using
// the pure iptables proxy mode. Values must be within the range [0, 31].
- IPTablesMasqueradeBit *int `json:"iptablesMasqueradeBit"`
+ IPTablesMasqueradeBit *int32 `json:"iptablesMasqueradeBit"`
// iptablesSyncPeriod is the period that iptables rules are refreshed (e.g. '5s', '1m',
// '2h22m'). Must be greater than 0.
IPTablesSyncPeriod unversioned.Duration `json:"iptablesSyncPeriodSeconds"`
@@ -50,7 +50,7 @@ type KubeProxyConfiguration struct {
Master string `json:"master"`
// oomScoreAdj is the oom-score-adj value for kube-proxy process. Values must be within
// the range [-1000, 1000]
- OOMScoreAdj *int `json:"oomScoreAdj"`
+ OOMScoreAdj *int32 `json:"oomScoreAdj"`
// mode specifies which proxy mode to use.
Mode ProxyMode `json:"mode"`
// portRange is the range of host ports (beginPort-endPort, inclusive) that may be consumed
@@ -63,7 +63,7 @@ type KubeProxyConfiguration struct {
// Must be greater than 0. Only applicable for proxyMode=userspace.
UDPIdleTimeout unversioned.Duration `json:"udpTimeoutMilliseconds"`
// conntrackMax is the maximum number of NAT connections to track (0 to leave as-is)")
- ConntrackMax int `json:"conntrackMax"`
+ ConntrackMax int32 `json:"conntrackMax"`
// conntrackTCPEstablishedTimeout is how long an idle UDP connection will be kept open
// (e.g. '250ms', '2s'). Must be greater than 0. Only applicable for proxyMode is Userspace
ConntrackTCPEstablishedTimeout unversioned.Duration `json:"conntrackTCPEstablishedTimeout"`
@@ -151,6 +151,8 @@ type KubeletConfiguration struct {
// rootDirectory is the directory path to place kubelet files (volume
// mounts,etc).
RootDirectory string `json:"rootDirectory"`
+ // seccompProfileRoot is the directory path for seccomp profiles.
+ SeccompProfileRoot string `json:"seccompProfileRoot"`
// allowPrivileged enables containers to request privileged mode.
// Defaults to false.
AllowPrivileged bool `json:"allowPrivileged"`
@@ -169,14 +171,14 @@ type KubeletConfiguration struct {
// registryBurst is the maximum size of a bursty pulls, temporarily allows
// pulls to burst to this number, while still not exceeding registryQps.
// Only used if registryQps > 0.
- RegistryBurst int `json:"registryBurst"`
+ RegistryBurst int32 `json:"registryBurst"`
// eventRecordQPS is the maximum event creations per second. If 0, there
// is no limit enforced.
EventRecordQPS float32 `json:"eventRecordQPS"`
// eventBurst is the maximum size of a bursty event records, temporarily
// allows event records to burst to this number, while still not exceeding
// event-qps. Only used if eventQps > 0
- EventBurst int `json:"eventBurst"`
+ EventBurst int32 `json:"eventBurst"`
// enableDebuggingHandlers enables server endpoints for log collection
// and local running of containers and commands
EnableDebuggingHandlers bool `json:"enableDebuggingHandlers"`
@@ -185,20 +187,20 @@ type KubeletConfiguration struct {
MinimumGCAge unversioned.Duration `json:"minimumGCAge"`
// maxPerPodContainerCount is the maximum number of old instances to
// retain per container. Each container takes up some disk space.
- MaxPerPodContainerCount int `json:"maxPerPodContainerCount"`
+ MaxPerPodContainerCount int32 `json:"maxPerPodContainerCount"`
// maxContainerCount is the maximum number of old instances of containers
// to retain globally. Each container takes up some disk space.
- MaxContainerCount int `json:"maxContainerCount"`
+ MaxContainerCount int32 `json:"maxContainerCount"`
// cAdvisorPort is the port of the localhost cAdvisor endpoint
CAdvisorPort uint `json:"cAdvisorPort"`
// healthzPort is the port of the localhost healthz endpoint
- HealthzPort int `json:"healthzPort"`
+ HealthzPort int32 `json:"healthzPort"`
// healthzBindAddress is the IP address for the healthz server to serve
// on.
HealthzBindAddress string `json:"healthzBindAddress"`
// oomScoreAdj is The oom-score-adj value for kubelet process. Values
// must be within the range [-1000, 1000].
- OOMScoreAdj int `json:"oomScoreAdj"`
+ OOMScoreAdj int32 `json:"oomScoreAdj"`
// registerNode enables automatic registration with the apiserver.
RegisterNode bool `json:"registerNode"`
// clusterDomain is the DNS domain for this cluster. If set, kubelet will
@@ -224,17 +226,17 @@ type KubeletConfiguration struct {
ImageMinimumGCAge unversioned.Duration `json:"imageMinimumGCAge"`
// imageGCHighThresholdPercent is the percent of disk usage after which
// image garbage collection is always run.
- ImageGCHighThresholdPercent int `json:"imageGCHighThresholdPercent"`
+ ImageGCHighThresholdPercent int32 `json:"imageGCHighThresholdPercent"`
// imageGCLowThresholdPercent is the percent of disk usage before which
// image garbage collection is never run. Lowest disk usage to garbage
// collect to.
- ImageGCLowThresholdPercent int `json:"imageGCLowThresholdPercent"`
+ ImageGCLowThresholdPercent int32 `json:"imageGCLowThresholdPercent"`
// lowDiskSpaceThresholdMB is the absolute free disk space, in MB, to
// maintain. When disk space falls below this threshold, new pods would
// be rejected.
- LowDiskSpaceThresholdMB int `json:"lowDiskSpaceThresholdMB"`
+ LowDiskSpaceThresholdMB int32 `json:"lowDiskSpaceThresholdMB"`
// How frequently to calculate and cache volume disk usage for all pods
- VolumeStatsAggPeriod unversioned.Duration `json:volumeStatsAggPeriod`
+ VolumeStatsAggPeriod unversioned.Duration `json:"volumeStatsAggPeriod"`
// networkPluginName is the name of the network plugin to be invoked for
// various events in kubelet/pod lifecycle
NetworkPluginName string `json:"networkPluginName"`
@@ -261,16 +263,26 @@ type KubeletConfiguration struct {
CgroupRoot string `json:"cgroupRoot,omitempty"`
// containerRuntime is the container runtime to use.
ContainerRuntime string `json:"containerRuntime"`
- // rktPath is hte path of rkt binary. Leave empty to use the first rkt in
+ // runtimeRequestTimeout is the timeout for all runtime requests except long running
+ // requests - pull, logs, exec and attach.
+ RuntimeRequestTimeout unversioned.Duration `json:"runtimeRequestTimeout,omitempty"`
+ // rktPath is the path of rkt binary. Leave empty to use the first rkt in
// $PATH.
RktPath string `json:"rktPath,omitempty"`
+ // rktApiEndpoint is the endpoint of the rkt API service to communicate with.
+ RktAPIEndpoint string `json:"rktAPIEndpoint,omitempty"`
+ // rktStage1Image is the image to use as stage1. Local paths and
+ // http/https URLs are supported.
+ RktStage1Image string `json:"rktStage1Image,omitempty"`
// lockFilePath is the path that kubelet will use to as a lock file.
// It uses this file as a lock to synchronize with other kubelet processes
// that may be running.
LockFilePath string `json:"lockFilePath"`
- // rktStage1Image is the image to use as stage1. Local paths and
- // http/https URLs are supported.
- RktStage1Image string `json:"rktStage1Image,omitempty"`
+ // ExitOnLockContention is a flag that signifies to the kubelet that it is running
+ // in "bootstrap" mode. This requires that 'LockFilePath' has been set.
+ // This will cause the kubelet to listen to inotify events on the lock file,
+ // releasing it and exiting when another process tries to open that file.
+ ExitOnLockContention bool `json:"exitOnLockContention"`
// configureCBR0 enables the kublet to configure cbr0 based on
// Node.Spec.PodCIDR.
ConfigureCBR0 bool `json:"configureCbr0"`
@@ -287,7 +299,9 @@ type KubeletConfiguration struct {
// The node has babysitter process monitoring docker and kubelet.
BabysitDaemons bool `json:"babysitDaemons"`
// maxPods is the number of pods that can run on this Kubelet.
- MaxPods int `json:"maxPods"`
+ MaxPods int32 `json:"maxPods"`
+ // nvidiaGPUs is the number of NVIDIA GPU devices on this node.
+ NvidiaGPUs int32 `json:"nvidiaGPUs"`
// dockerExecHandlerName is the handler to use when executing a command
// in a container. Valid values are 'native' and 'nsenter'. Defaults to
// 'native'.
@@ -311,11 +325,13 @@ type KubeletConfiguration struct {
// registerSchedulable tells the kubelet to register the node as
// schedulable. No-op if register-node is false.
RegisterSchedulable bool `json:"registerSchedulable"`
+ // contentType is contentType of requests sent to apiserver.
+ ContentType string `json:"contentType"`
// kubeAPIQPS is the QPS to use while talking with kubernetes apiserver
KubeAPIQPS float32 `json:"kubeAPIQPS"`
// kubeAPIBurst is the burst to allow while talking with kubernetes
// apiserver
- KubeAPIBurst int `json:"kubeAPIBurst"`
+ KubeAPIBurst int32 `json:"kubeAPIBurst"`
// serializeImagePulls when enabled, tells the Kubelet to pull images one
// at a time. We recommend *not* changing the default value on nodes that
// run docker daemon with version < 1.9 or an Aufs storage backend.
@@ -337,13 +353,29 @@ type KubeletConfiguration struct {
NonMasqueradeCIDR string `json:"nonMasqueradeCIDR"`
// enable gathering custom metrics.
EnableCustomMetrics bool `json:"enableCustomMetrics"`
+ // Comma-delimited list of hard eviction expressions. For example, 'memory.available<300Mi'.
+ EvictionHard string `json:"evictionHard,omitempty"`
+ // Comma-delimited list of soft eviction expressions. For example, 'memory.available<300Mi'.
+ EvictionSoft string `json:"evictionSoft,omitempty"`
+ // Comma-delimeted list of grace periods for each soft eviction signal. For example, 'memory.available=30s'.
+ EvictionSoftGracePeriod string `json:"evictionSoftGracePeriod,omitempty"`
+ // Duration for which the kubelet has to wait before transitioning out of an eviction pressure condition.
+ EvictionPressureTransitionPeriod unversioned.Duration `json:"evictionPressureTransitionPeriod,omitempty"`
+ // Maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+ EvictionMaxPodGracePeriod int32 `json:"evictionMaxPodGracePeriod,omitempty"`
+ // Maximum number of pods per core. Cannot exceed MaxPods
+ PodsPerCore int32 `json:"podsPerCore"`
+ // enableControllerAttachDetach enables the Attach/Detach controller to
+ // manage attachment/detachment of volumes scheduled to this node, and
+ // disables kubelet from executing any attach/detach operations
+ EnableControllerAttachDetach bool `json:"enableControllerAttachDetach"`
}
type KubeSchedulerConfiguration struct {
unversioned.TypeMeta
// port is the port that the scheduler's http service runs on.
- Port int `json:"port"`
+ Port int32 `json:"port"`
// address is the IP address to serve on.
Address string `json:"address"`
// algorithmProvider is the scheduling algorithm provider to use.
@@ -352,14 +384,22 @@ type KubeSchedulerConfiguration struct {
PolicyConfigFile string `json:"policyConfigFile"`
// enableProfiling enables profiling via web interface.
EnableProfiling bool `json:"enableProfiling"`
+ // contentType is contentType of requests sent to apiserver.
+ ContentType string `json:"contentType"`
// kubeAPIQPS is the QPS to use while talking with kubernetes apiserver.
KubeAPIQPS float32 `json:"kubeAPIQPS"`
// kubeAPIBurst is the QPS burst to use while talking with kubernetes apiserver.
- KubeAPIBurst int `json:"kubeAPIBurst"`
+ KubeAPIBurst int32 `json:"kubeAPIBurst"`
// schedulerName is name of the scheduler, used to select which pods
// will be processed by this scheduler, based on pod's annotation with
// key 'scheduler.alpha.kubernetes.io/name'.
SchedulerName string `json:"schedulerName"`
+ // RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule
+ // corresponding to every RequiredDuringScheduling affinity rule.
+ // HardPodAffinitySymmetricWeight represents the weight of implicit PreferredDuringScheduling affinity rule, in the range 0-100.
+ HardPodAffinitySymmetricWeight int `json:"hardPodAffinitySymmetricWeight"`
+ // Indicate the "all topologies" set for empty topologyKey when it's used for PreferredDuringScheduling pod anti-affinity.
+ FailureDomains string `json:"failureDomains"`
// leaderElection defines the configuration of leader election client.
LeaderElection LeaderElectionConfiguration `json:"leaderElection"`
}
@@ -393,7 +433,7 @@ type KubeControllerManagerConfiguration struct {
unversioned.TypeMeta
// port is the port that the controller-manager's http service runs on.
- Port int `json:"port"`
+ Port int32 `json:"port"`
// address is the IP address to serve on (set to 0.0.0.0 for all interfaces).
Address string `json:"address"`
// cloudProvider is the provider for cloud services.
@@ -403,43 +443,43 @@ type KubeControllerManagerConfiguration struct {
// concurrentEndpointSyncs is the number of endpoint syncing operations
// that will be done concurrently. Larger number = faster endpoint updating,
// but more CPU (and network) load.
- ConcurrentEndpointSyncs int `json:"concurrentEndpointSyncs"`
+ ConcurrentEndpointSyncs int32 `json:"concurrentEndpointSyncs"`
// concurrentRSSyncs is the number of replica sets that are allowed to sync
// concurrently. Larger number = more responsive replica management, but more
// CPU (and network) load.
- ConcurrentRSSyncs int `json:"concurrentRSSyncs"`
+ ConcurrentRSSyncs int32 `json:"concurrentRSSyncs"`
// concurrentRCSyncs is the number of replication controllers that are
// allowed to sync concurrently. Larger number = more responsive replica
// management, but more CPU (and network) load.
- ConcurrentRCSyncs int `json:"concurrentRCSyncs"`
+ ConcurrentRCSyncs int32 `json:"concurrentRCSyncs"`
// concurrentResourceQuotaSyncs is the number of resource quotas that are
// allowed to sync concurrently. Larger number = more responsive quota
// management, but more CPU (and network) load.
- ConcurrentResourceQuotaSyncs int `json:"concurrentResourceQuotaSyncs"`
+ ConcurrentResourceQuotaSyncs int32 `json:"concurrentResourceQuotaSyncs"`
// concurrentDeploymentSyncs is the number of deployment objects that are
// allowed to sync concurrently. Larger number = more responsive deployments,
// but more CPU (and network) load.
- ConcurrentDeploymentSyncs int `json:"concurrentDeploymentSyncs"`
+ ConcurrentDeploymentSyncs int32 `json:"concurrentDeploymentSyncs"`
// concurrentDaemonSetSyncs is the number of daemonset objects that are
// allowed to sync concurrently. Larger number = more responsive daemonset,
// but more CPU (and network) load.
- ConcurrentDaemonSetSyncs int `json:"concurrentDaemonSetSyncs"`
+ ConcurrentDaemonSetSyncs int32 `json:"concurrentDaemonSetSyncs"`
// concurrentJobSyncs is the number of job objects that are
// allowed to sync concurrently. Larger number = more responsive jobs,
// but more CPU (and network) load.
- ConcurrentJobSyncs int `json:"concurrentJobSyncs"`
+ ConcurrentJobSyncs int32 `json:"concurrentJobSyncs"`
// concurrentNamespaceSyncs is the number of namespace objects that are
// allowed to sync concurrently.
- ConcurrentNamespaceSyncs int `json:"concurrentNamespaceSyncs"`
+ ConcurrentNamespaceSyncs int32 `json:"concurrentNamespaceSyncs"`
// lookupCacheSizeForRC is the size of lookup cache for replication controllers.
// Larger number = more responsive replica management, but more MEM load.
- LookupCacheSizeForRC int `json:"lookupCacheSizeForRC"`
+ LookupCacheSizeForRC int32 `json:"lookupCacheSizeForRC"`
// lookupCacheSizeForRS is the size of lookup cache for replicatsets.
// Larger number = more responsive replica management, but more MEM load.
- LookupCacheSizeForRS int `json:"lookupCacheSizeForRS"`
+ LookupCacheSizeForRS int32 `json:"lookupCacheSizeForRS"`
// lookupCacheSizeForDaemonSet is the size of lookup cache for daemonsets.
// Larger number = more responsive daemonset, but more MEM load.
- LookupCacheSizeForDaemonSet int `json:"lookupCacheSizeForDaemonSet"`
+ LookupCacheSizeForDaemonSet int32 `json:"lookupCacheSizeForDaemonSet"`
// serviceSyncPeriod is the period for syncing services with their external
// load balancers.
ServiceSyncPeriod unversioned.Duration `json:"serviceSyncPeriod"`
@@ -462,7 +502,7 @@ type KubeControllerManagerConfiguration struct {
// terminatedPodGCThreshold is the number of terminated pods that can exist
// before the terminated pod garbage collector starts deleting terminated pods.
// If <= 0, the terminated pod garbage collector is disabled.
- TerminatedPodGCThreshold int `json:"terminatedPodGCThreshold"`
+ TerminatedPodGCThreshold int32 `json:"terminatedPodGCThreshold"`
// horizontalPodAutoscalerSyncPeriod is the period for syncing the number of
// pods in horizontal pod autoscaler.
HorizontalPodAutoscalerSyncPeriod unversioned.Duration `json:"horizontalPodAutoscalerSyncPeriod"`
@@ -475,7 +515,7 @@ type KubeControllerManagerConfiguration struct {
DeletingPodsQps float32 `json:"deletingPodsQps"`
// deletingPodsBurst is the number of nodes on which pods are bursty deleted in
// case of node failure. For more details look into RateLimiter.
- DeletingPodsBurst int `json:"deletingPodsBurst"`
+ DeletingPodsBurst int32 `json:"deletingPodsBurst"`
// nodeMontiorGracePeriod is the amount of time which we allow a running node to be
// unresponsive before marking it unhealty. Must be N times more than kubelet's
// nodeStatusUpdateFrequency, where N means number of retries allowed for kubelet
@@ -483,7 +523,7 @@ type KubeControllerManagerConfiguration struct {
NodeMonitorGracePeriod unversioned.Duration `json:"nodeMonitorGracePeriod"`
// registerRetryCount is the number of retries for initial node registration.
// Retry interval equals node-sync-period.
- RegisterRetryCount int `json:"registerRetryCount"`
+ RegisterRetryCount int32 `json:"registerRetryCount"`
// nodeStartupGracePeriod is the amount of time which we allow starting a node to
// be unresponsive before marking it unhealty.
NodeStartupGracePeriod unversioned.Duration `json:"nodeStartupGracePeriod"`
@@ -498,20 +538,35 @@ type KubeControllerManagerConfiguration struct {
ClusterName string `json:"clusterName"`
// clusterCIDR is CIDR Range for Pods in cluster.
ClusterCIDR string `json:"clusterCIDR"`
- // allocateNodeCIDRs enables CIDRs for Pods to be allocated and set on the
- // cloud provider.
+ // serviceCIDR is CIDR Range for Services in cluster.
+ ServiceCIDR string `json:"serviceCIDR"`
+ // NodeCIDRMaskSize is the mask size for node cidr in cluster.
+ NodeCIDRMaskSize int32 `json:"nodeCIDRMaskSize"`
+ // allocateNodeCIDRs enables CIDRs for Pods to be allocated and, if
+ // ConfigureCloudRoutes is true, to be set on the cloud provider.
AllocateNodeCIDRs bool `json:"allocateNodeCIDRs"`
+ // configureCloudRoutes enables CIDRs allocated with allocateNodeCIDRs
+ // to be configured on the cloud provider.
+ ConfigureCloudRoutes bool `json:"configureCloudRoutes"`
// rootCAFile is the root certificate authority will be included in service
// account's token secret. This must be a valid PEM-encoded CA bundle.
RootCAFile string `json:"rootCAFile"`
+ // contentType is contentType of requests sent to apiserver.
+ ContentType string `json:"contentType"`
// kubeAPIQPS is the QPS to use while talking with kubernetes apiserver.
KubeAPIQPS float32 `json:"kubeAPIQPS"`
// kubeAPIBurst is the burst to use while talking with kubernetes apiserver.
- KubeAPIBurst int `json:"kubeAPIBurst"`
+ KubeAPIBurst int32 `json:"kubeAPIBurst"`
// leaderElection defines the configuration of leader election client.
LeaderElection LeaderElectionConfiguration `json:"leaderElection"`
- // vloumeConfiguration holds configuration for volume related features.
+ // volumeConfiguration holds configuration for volume related features.
VolumeConfiguration VolumeConfiguration `json:"volumeConfiguration"`
+ // How long to wait between starting controller managers
+ ControllerStartInterval unversioned.Duration `json:"controllerStartInterval"`
+ // enables the generic garbage collector. MUST be synced with the
+ // corresponding flag of the kube-apiserver. WARNING: the generic garbage
+ // collector is an alpha feature.
+ EnableGarbageCollector bool `json:"enableGarbageCollector"`
}
// VolumeConfiguration contains *all* enumerated flags meant to configure all volume
@@ -525,23 +580,29 @@ type VolumeConfiguration struct {
// provisioning is not supported in any way, won't work in a multi-node cluster, and
// should not be used for anything other than testing or development.
EnableHostPathProvisioning bool `json:"enableHostPathProvisioning"`
+ // enableDynamicProvisioning enables the provisioning of volumes when running within an environment
+ // that supports dynamic provisioning. Defaults to true.
+ EnableDynamicProvisioning bool `json:"enableDynamicProvisioning"`
// persistentVolumeRecyclerConfiguration holds configuration for persistent volume plugins.
PersistentVolumeRecyclerConfiguration PersistentVolumeRecyclerConfiguration `json:"persitentVolumeRecyclerConfiguration"`
+ // volumePluginDir is the full path of the directory in which the flex
+ // volume plugin should search for additional third party volume plugins
+ FlexVolumePluginDir string `json:"flexVolumePluginDir"`
}
type PersistentVolumeRecyclerConfiguration struct {
// maximumRetry is number of retries the PV recycler will execute on failure to recycle
// PV.
- MaximumRetry int `json:"maximumRetry"`
+ MaximumRetry int32 `json:"maximumRetry"`
// minimumTimeoutNFS is the minimum ActiveDeadlineSeconds to use for an NFS Recycler
// pod.
- MinimumTimeoutNFS int `json:"minimumTimeoutNFS"`
+ MinimumTimeoutNFS int32 `json:"minimumTimeoutNFS"`
// podTemplateFilePathNFS is the file path to a pod definition used as a template for
// NFS persistent volume recycling
PodTemplateFilePathNFS string `json:"podTemplateFilePathNFS"`
// incrementTimeoutNFS is the increment of time added per Gi to ActiveDeadlineSeconds
// for an NFS scrubber pod.
- IncrementTimeoutNFS int `json:"incrementTimeoutNFS"`
+ IncrementTimeoutNFS int32 `json:"incrementTimeoutNFS"`
// podTemplateFilePathHostPath is the file path to a pod definition used as a template for
// HostPath persistent volume recycling. This is for development and testing only and
// will not work in a multi-node cluster.
@@ -549,9 +610,9 @@ type PersistentVolumeRecyclerConfiguration struct {
// minimumTimeoutHostPath is the minimum ActiveDeadlineSeconds to use for a HostPath
// Recycler pod. This is for development and testing only and will not work in a multi-node
// cluster.
- MinimumTimeoutHostPath int `json:"minimumTimeoutHostPath"`
+ MinimumTimeoutHostPath int32 `json:"minimumTimeoutHostPath"`
// incrementTimeoutHostPath is the increment of time added per Gi to ActiveDeadlineSeconds
// for a HostPath scrubber pod. This is for development and testing only and will not work
// in a multi-node cluster.
- IncrementTimeoutHostPath int `json:"incrementTimeoutHostPath"`
+ IncrementTimeoutHostPath int32 `json:"incrementTimeoutHostPath"`
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go
similarity index 58%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go
index 8b13ab50eb6cb10c43968bb42976b6439cc4bbe2..fd607760bfc4c3c48b28052feb3d4e3ce6d6c8f9 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/conversion_generated.go
@@ -1,5 +1,7 @@
+// +build !ignore_autogenerated
+
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,179 +16,105 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-conversions.sh
+// This file was autogenerated by conversion-gen. Do not edit it manually!
package v1alpha1
import (
- reflect "reflect"
-
api "k8s.io/kubernetes/pkg/api"
componentconfig "k8s.io/kubernetes/pkg/apis/componentconfig"
conversion "k8s.io/kubernetes/pkg/conversion"
)
-func autoConvert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in *componentconfig.KubeProxyConfiguration, out *KubeProxyConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*componentconfig.KubeProxyConfiguration))(in)
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration,
+ Convert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration,
+ Convert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedulerConfiguration,
+ Convert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration,
+ Convert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration,
+ Convert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
}
+}
+
+func autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in *KubeProxyConfiguration, out *componentconfig.KubeProxyConfiguration, s conversion.Scope) error {
+ SetDefaults_KubeProxyConfiguration(in)
if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
return err
}
out.BindAddress = in.BindAddress
out.ClusterCIDR = in.ClusterCIDR
out.HealthzBindAddress = in.HealthzBindAddress
- out.HealthzPort = int32(in.HealthzPort)
+ out.HealthzPort = in.HealthzPort
out.HostnameOverride = in.HostnameOverride
- if in.IPTablesMasqueradeBit != nil {
- out.IPTablesMasqueradeBit = new(int32)
- *out.IPTablesMasqueradeBit = int32(*in.IPTablesMasqueradeBit)
- } else {
- out.IPTablesMasqueradeBit = nil
- }
- if err := s.Convert(&in.IPTablesSyncPeriod, &out.IPTablesSyncPeriod, 0); err != nil {
- return err
- }
+ out.IPTablesMasqueradeBit = in.IPTablesMasqueradeBit
+ out.IPTablesSyncPeriod = in.IPTablesSyncPeriod
out.KubeconfigPath = in.KubeconfigPath
out.MasqueradeAll = in.MasqueradeAll
out.Master = in.Master
- if in.OOMScoreAdj != nil {
- out.OOMScoreAdj = new(int32)
- *out.OOMScoreAdj = int32(*in.OOMScoreAdj)
- } else {
- out.OOMScoreAdj = nil
- }
- out.Mode = ProxyMode(in.Mode)
+ out.OOMScoreAdj = in.OOMScoreAdj
+ out.Mode = componentconfig.ProxyMode(in.Mode)
out.PortRange = in.PortRange
out.ResourceContainer = in.ResourceContainer
- if err := s.Convert(&in.UDPIdleTimeout, &out.UDPIdleTimeout, 0); err != nil {
- return err
- }
- out.ConntrackMax = int32(in.ConntrackMax)
- if err := s.Convert(&in.ConntrackTCPEstablishedTimeout, &out.ConntrackTCPEstablishedTimeout, 0); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in *componentconfig.KubeProxyConfiguration, out *KubeProxyConfiguration, s conversion.Scope) error {
- return autoConvert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in, out, s)
-}
-
-func autoConvert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in *componentconfig.KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*componentconfig.KubeSchedulerConfiguration))(in)
- }
- if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
- return err
- }
- out.Port = in.Port
- out.Address = in.Address
- out.AlgorithmProvider = in.AlgorithmProvider
- out.PolicyConfigFile = in.PolicyConfigFile
- if err := api.Convert_bool_To_bool_ref(&in.EnableProfiling, &out.EnableProfiling, s); err != nil {
- return err
- }
- out.KubeAPIQPS = in.KubeAPIQPS
- out.KubeAPIBurst = in.KubeAPIBurst
- out.SchedulerName = in.SchedulerName
- if err := Convert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(&in.LeaderElection, &out.LeaderElection, s); err != nil {
- return err
- }
- return nil
-}
-
-func Convert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in *componentconfig.KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, s conversion.Scope) error {
- return autoConvert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in, out, s)
-}
-
-func autoConvert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in *componentconfig.LeaderElectionConfiguration, out *LeaderElectionConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*componentconfig.LeaderElectionConfiguration))(in)
- }
- if err := api.Convert_bool_To_bool_ref(&in.LeaderElect, &out.LeaderElect, s); err != nil {
- return err
- }
- if err := s.Convert(&in.LeaseDuration, &out.LeaseDuration, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.RenewDeadline, &out.RenewDeadline, 0); err != nil {
- return err
- }
- if err := s.Convert(&in.RetryPeriod, &out.RetryPeriod, 0); err != nil {
- return err
- }
+ out.UDPIdleTimeout = in.UDPIdleTimeout
+ out.ConntrackMax = in.ConntrackMax
+ out.ConntrackTCPEstablishedTimeout = in.ConntrackTCPEstablishedTimeout
return nil
}
-func Convert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in *componentconfig.LeaderElectionConfiguration, out *LeaderElectionConfiguration, s conversion.Scope) error {
- return autoConvert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in, out, s)
+func Convert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in *KubeProxyConfiguration, out *componentconfig.KubeProxyConfiguration, s conversion.Scope) error {
+ return autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in, out, s)
}
-func autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in *KubeProxyConfiguration, out *componentconfig.KubeProxyConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*KubeProxyConfiguration))(in)
- }
+func autoConvert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in *componentconfig.KubeProxyConfiguration, out *KubeProxyConfiguration, s conversion.Scope) error {
if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
return err
}
out.BindAddress = in.BindAddress
out.ClusterCIDR = in.ClusterCIDR
out.HealthzBindAddress = in.HealthzBindAddress
- out.HealthzPort = int(in.HealthzPort)
+ out.HealthzPort = in.HealthzPort
out.HostnameOverride = in.HostnameOverride
- if in.IPTablesMasqueradeBit != nil {
- out.IPTablesMasqueradeBit = new(int)
- *out.IPTablesMasqueradeBit = int(*in.IPTablesMasqueradeBit)
- } else {
- out.IPTablesMasqueradeBit = nil
- }
- if err := s.Convert(&in.IPTablesSyncPeriod, &out.IPTablesSyncPeriod, 0); err != nil {
- return err
- }
+ out.IPTablesMasqueradeBit = in.IPTablesMasqueradeBit
+ out.IPTablesSyncPeriod = in.IPTablesSyncPeriod
out.KubeconfigPath = in.KubeconfigPath
out.MasqueradeAll = in.MasqueradeAll
out.Master = in.Master
- if in.OOMScoreAdj != nil {
- out.OOMScoreAdj = new(int)
- *out.OOMScoreAdj = int(*in.OOMScoreAdj)
- } else {
- out.OOMScoreAdj = nil
- }
- out.Mode = componentconfig.ProxyMode(in.Mode)
+ out.OOMScoreAdj = in.OOMScoreAdj
+ out.Mode = ProxyMode(in.Mode)
out.PortRange = in.PortRange
out.ResourceContainer = in.ResourceContainer
- if err := s.Convert(&in.UDPIdleTimeout, &out.UDPIdleTimeout, 0); err != nil {
- return err
- }
- out.ConntrackMax = int(in.ConntrackMax)
- if err := s.Convert(&in.ConntrackTCPEstablishedTimeout, &out.ConntrackTCPEstablishedTimeout, 0); err != nil {
- return err
- }
+ out.UDPIdleTimeout = in.UDPIdleTimeout
+ out.ConntrackMax = in.ConntrackMax
+ out.ConntrackTCPEstablishedTimeout = in.ConntrackTCPEstablishedTimeout
return nil
}
-func Convert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in *KubeProxyConfiguration, out *componentconfig.KubeProxyConfiguration, s conversion.Scope) error {
- return autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in, out, s)
+func Convert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in *componentconfig.KubeProxyConfiguration, out *KubeProxyConfiguration, s conversion.Scope) error {
+ return autoConvert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration(in, out, s)
}
func autoConvert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedulerConfiguration(in *KubeSchedulerConfiguration, out *componentconfig.KubeSchedulerConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*KubeSchedulerConfiguration))(in)
- }
+ SetDefaults_KubeSchedulerConfiguration(in)
if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
return err
}
- out.Port = in.Port
+ out.Port = int32(in.Port)
out.Address = in.Address
out.AlgorithmProvider = in.AlgorithmProvider
out.PolicyConfigFile = in.PolicyConfigFile
- if err := api.Convert_bool_ref_To_bool(&in.EnableProfiling, &out.EnableProfiling, s); err != nil {
+ if err := api.Convert_Pointer_bool_To_bool(&in.EnableProfiling, &out.EnableProfiling, s); err != nil {
return err
}
+ out.ContentType = in.ContentType
out.KubeAPIQPS = in.KubeAPIQPS
- out.KubeAPIBurst = in.KubeAPIBurst
+ out.KubeAPIBurst = int32(in.KubeAPIBurst)
out.SchedulerName = in.SchedulerName
+ out.HardPodAffinitySymmetricWeight = in.HardPodAffinitySymmetricWeight
+ out.FailureDomains = in.FailureDomains
if err := Convert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration(&in.LeaderElection, &out.LeaderElection, s); err != nil {
return err
}
@@ -197,22 +125,41 @@ func Convert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedule
return autoConvert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedulerConfiguration(in, out, s)
}
-func autoConvert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration(in *LeaderElectionConfiguration, out *componentconfig.LeaderElectionConfiguration, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*LeaderElectionConfiguration))(in)
- }
- if err := api.Convert_bool_ref_To_bool(&in.LeaderElect, &out.LeaderElect, s); err != nil {
+func autoConvert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in *componentconfig.KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
return err
}
- if err := s.Convert(&in.LeaseDuration, &out.LeaseDuration, 0); err != nil {
+ out.Port = int(in.Port)
+ out.Address = in.Address
+ out.AlgorithmProvider = in.AlgorithmProvider
+ out.PolicyConfigFile = in.PolicyConfigFile
+ if err := api.Convert_bool_To_Pointer_bool(&in.EnableProfiling, &out.EnableProfiling, s); err != nil {
return err
}
- if err := s.Convert(&in.RenewDeadline, &out.RenewDeadline, 0); err != nil {
+ out.ContentType = in.ContentType
+ out.KubeAPIQPS = in.KubeAPIQPS
+ out.KubeAPIBurst = int(in.KubeAPIBurst)
+ out.SchedulerName = in.SchedulerName
+ out.HardPodAffinitySymmetricWeight = in.HardPodAffinitySymmetricWeight
+ out.FailureDomains = in.FailureDomains
+ if err := Convert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(&in.LeaderElection, &out.LeaderElection, s); err != nil {
return err
}
- if err := s.Convert(&in.RetryPeriod, &out.RetryPeriod, 0); err != nil {
+ return nil
+}
+
+func Convert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in *componentconfig.KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, s conversion.Scope) error {
+ return autoConvert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration(in, out, s)
+}
+
+func autoConvert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration(in *LeaderElectionConfiguration, out *componentconfig.LeaderElectionConfiguration, s conversion.Scope) error {
+ SetDefaults_LeaderElectionConfiguration(in)
+ if err := api.Convert_Pointer_bool_To_bool(&in.LeaderElect, &out.LeaderElect, s); err != nil {
return err
}
+ out.LeaseDuration = in.LeaseDuration
+ out.RenewDeadline = in.RenewDeadline
+ out.RetryPeriod = in.RetryPeriod
return nil
}
@@ -220,17 +167,16 @@ func Convert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElect
return autoConvert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration(in, out, s)
}
-func init() {
- err := api.Scheme.AddGeneratedConversionFuncs(
- autoConvert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfiguration,
- autoConvert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedulerConfiguration,
- autoConvert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration,
- autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration,
- autoConvert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedulerConfiguration,
- autoConvert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration,
- )
- if err != nil {
- // If one of the conversion functions is malformed, detect it immediately.
- panic(err)
+func autoConvert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in *componentconfig.LeaderElectionConfiguration, out *LeaderElectionConfiguration, s conversion.Scope) error {
+ if err := api.Convert_bool_To_Pointer_bool(&in.LeaderElect, &out.LeaderElect, s); err != nil {
+ return err
}
+ out.LeaseDuration = in.LeaseDuration
+ out.RenewDeadline = in.RenewDeadline
+ out.RetryPeriod = in.RetryPeriod
+ return nil
+}
+
+func Convert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in *componentconfig.LeaderElectionConfiguration, out *LeaderElectionConfiguration, s conversion.Scope) error {
+ return autoConvert_componentconfig_LeaderElectionConfiguration_To_v1alpha1_LeaderElectionConfiguration(in, out, s)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go
similarity index 51%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go
index 451fd732fcedf9f4e84bb1534a83a92b87ea98b3..f4f9fc9322853ca703e2fe34cb79ef7881b067d1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/deep_copy_generated.go
@@ -1,5 +1,7 @@
+// +build !ignore_autogenerated
+
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,7 +16,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// DO NOT EDIT. THIS FILE IS AUTO-GENERATED BY $KUBEROOT/hack/update-generated-deep-copies.sh.
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
package v1alpha1
@@ -24,19 +26,19 @@ import (
conversion "k8s.io/kubernetes/pkg/conversion"
)
-func deepCopy_unversioned_Duration(in unversioned.Duration, out *unversioned.Duration, c *conversion.Cloner) error {
- out.Duration = in.Duration
- return nil
-}
-
-func deepCopy_unversioned_TypeMeta(in unversioned.TypeMeta, out *unversioned.TypeMeta, c *conversion.Cloner) error {
- out.Kind = in.Kind
- out.APIVersion = in.APIVersion
- return nil
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1alpha1_KubeProxyConfiguration,
+ DeepCopy_v1alpha1_KubeSchedulerConfiguration,
+ DeepCopy_v1alpha1_LeaderElectionConfiguration,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
}
-func deepCopy_v1alpha1_KubeProxyConfiguration(in KubeProxyConfiguration, out *KubeProxyConfiguration, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+func DeepCopy_v1alpha1_KubeProxyConfiguration(in KubeProxyConfiguration, out *KubeProxyConfiguration, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.BindAddress = in.BindAddress
@@ -45,38 +47,40 @@ func deepCopy_v1alpha1_KubeProxyConfiguration(in KubeProxyConfiguration, out *Ku
out.HealthzPort = in.HealthzPort
out.HostnameOverride = in.HostnameOverride
if in.IPTablesMasqueradeBit != nil {
- out.IPTablesMasqueradeBit = new(int32)
- *out.IPTablesMasqueradeBit = *in.IPTablesMasqueradeBit
+ in, out := in.IPTablesMasqueradeBit, &out.IPTablesMasqueradeBit
+ *out = new(int32)
+ **out = *in
} else {
out.IPTablesMasqueradeBit = nil
}
- if err := deepCopy_unversioned_Duration(in.IPTablesSyncPeriod, &out.IPTablesSyncPeriod, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.IPTablesSyncPeriod, &out.IPTablesSyncPeriod, c); err != nil {
return err
}
out.KubeconfigPath = in.KubeconfigPath
out.MasqueradeAll = in.MasqueradeAll
out.Master = in.Master
if in.OOMScoreAdj != nil {
- out.OOMScoreAdj = new(int32)
- *out.OOMScoreAdj = *in.OOMScoreAdj
+ in, out := in.OOMScoreAdj, &out.OOMScoreAdj
+ *out = new(int32)
+ **out = *in
} else {
out.OOMScoreAdj = nil
}
out.Mode = in.Mode
out.PortRange = in.PortRange
out.ResourceContainer = in.ResourceContainer
- if err := deepCopy_unversioned_Duration(in.UDPIdleTimeout, &out.UDPIdleTimeout, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.UDPIdleTimeout, &out.UDPIdleTimeout, c); err != nil {
return err
}
out.ConntrackMax = in.ConntrackMax
- if err := deepCopy_unversioned_Duration(in.ConntrackTCPEstablishedTimeout, &out.ConntrackTCPEstablishedTimeout, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.ConntrackTCPEstablishedTimeout, &out.ConntrackTCPEstablishedTimeout, c); err != nil {
return err
}
return nil
}
-func deepCopy_v1alpha1_KubeSchedulerConfiguration(in KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, c *conversion.Cloner) error {
- if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+func DeepCopy_v1alpha1_KubeSchedulerConfiguration(in KubeSchedulerConfiguration, out *KubeSchedulerConfiguration, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
return err
}
out.Port = in.Port
@@ -84,49 +88,40 @@ func deepCopy_v1alpha1_KubeSchedulerConfiguration(in KubeSchedulerConfiguration,
out.AlgorithmProvider = in.AlgorithmProvider
out.PolicyConfigFile = in.PolicyConfigFile
if in.EnableProfiling != nil {
- out.EnableProfiling = new(bool)
- *out.EnableProfiling = *in.EnableProfiling
+ in, out := in.EnableProfiling, &out.EnableProfiling
+ *out = new(bool)
+ **out = *in
} else {
out.EnableProfiling = nil
}
+ out.ContentType = in.ContentType
out.KubeAPIQPS = in.KubeAPIQPS
out.KubeAPIBurst = in.KubeAPIBurst
out.SchedulerName = in.SchedulerName
- if err := deepCopy_v1alpha1_LeaderElectionConfiguration(in.LeaderElection, &out.LeaderElection, c); err != nil {
+ out.HardPodAffinitySymmetricWeight = in.HardPodAffinitySymmetricWeight
+ out.FailureDomains = in.FailureDomains
+ if err := DeepCopy_v1alpha1_LeaderElectionConfiguration(in.LeaderElection, &out.LeaderElection, c); err != nil {
return err
}
return nil
}
-func deepCopy_v1alpha1_LeaderElectionConfiguration(in LeaderElectionConfiguration, out *LeaderElectionConfiguration, c *conversion.Cloner) error {
+func DeepCopy_v1alpha1_LeaderElectionConfiguration(in LeaderElectionConfiguration, out *LeaderElectionConfiguration, c *conversion.Cloner) error {
if in.LeaderElect != nil {
- out.LeaderElect = new(bool)
- *out.LeaderElect = *in.LeaderElect
+ in, out := in.LeaderElect, &out.LeaderElect
+ *out = new(bool)
+ **out = *in
} else {
out.LeaderElect = nil
}
- if err := deepCopy_unversioned_Duration(in.LeaseDuration, &out.LeaseDuration, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.LeaseDuration, &out.LeaseDuration, c); err != nil {
return err
}
- if err := deepCopy_unversioned_Duration(in.RenewDeadline, &out.RenewDeadline, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.RenewDeadline, &out.RenewDeadline, c); err != nil {
return err
}
- if err := deepCopy_unversioned_Duration(in.RetryPeriod, &out.RetryPeriod, c); err != nil {
+ if err := unversioned.DeepCopy_unversioned_Duration(in.RetryPeriod, &out.RetryPeriod, c); err != nil {
return err
}
return nil
}
-
-func init() {
- err := api.Scheme.AddGeneratedDeepCopyFuncs(
- deepCopy_unversioned_Duration,
- deepCopy_unversioned_TypeMeta,
- deepCopy_v1alpha1_KubeProxyConfiguration,
- deepCopy_v1alpha1_KubeSchedulerConfiguration,
- deepCopy_v1alpha1_LeaderElectionConfiguration,
- )
- if err != nil {
- // if one of the deep copy functions is malformed, detect it immediately.
- panic(err)
- }
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..bab6bb3e32f803aebdcfb5ddbe99b1ba5c64c2c8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go
@@ -0,0 +1,114 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "time"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/kubelet/qos"
+ "k8s.io/kubernetes/pkg/master/ports"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_KubeProxyConfiguration,
+ SetDefaults_KubeSchedulerConfiguration,
+ SetDefaults_LeaderElectionConfiguration,
+ )
+}
+
+func SetDefaults_KubeProxyConfiguration(obj *KubeProxyConfiguration) {
+ if obj.BindAddress == "" {
+ obj.BindAddress = "0.0.0.0"
+ }
+ if obj.HealthzPort == 0 {
+ obj.HealthzPort = 10249
+ }
+ if obj.HealthzBindAddress == "" {
+ obj.HealthzBindAddress = "127.0.0.1"
+ }
+ if obj.OOMScoreAdj == nil {
+ temp := int32(qos.KubeProxyOOMScoreAdj)
+ obj.OOMScoreAdj = &temp
+ }
+ if obj.ResourceContainer == "" {
+ obj.ResourceContainer = "/kube-proxy"
+ }
+ if obj.IPTablesSyncPeriod.Duration == 0 {
+ obj.IPTablesSyncPeriod = unversioned.Duration{Duration: 30 * time.Second}
+ }
+ zero := unversioned.Duration{}
+ if obj.UDPIdleTimeout == zero {
+ obj.UDPIdleTimeout = unversioned.Duration{Duration: 250 * time.Millisecond}
+ }
+ if obj.ConntrackMax == 0 {
+ obj.ConntrackMax = 256 * 1024 // 4x default (64k)
+ }
+ if obj.IPTablesMasqueradeBit == nil {
+ temp := int32(14)
+ obj.IPTablesMasqueradeBit = &temp
+ }
+ if obj.ConntrackTCPEstablishedTimeout == zero {
+ obj.ConntrackTCPEstablishedTimeout = unversioned.Duration{Duration: 24 * time.Hour} // 1 day (1/5 default)
+ }
+}
+
+func SetDefaults_KubeSchedulerConfiguration(obj *KubeSchedulerConfiguration) {
+ if obj.Port == 0 {
+ obj.Port = ports.SchedulerPort
+ }
+ if obj.Address == "" {
+ obj.Address = "0.0.0.0"
+ }
+ if obj.AlgorithmProvider == "" {
+ obj.AlgorithmProvider = "DefaultProvider"
+ }
+ if obj.ContentType == "" {
+ obj.ContentType = "application/vnd.kubernetes.protobuf"
+ }
+ if obj.KubeAPIQPS == 0 {
+ obj.KubeAPIQPS = 50.0
+ }
+ if obj.KubeAPIBurst == 0 {
+ obj.KubeAPIBurst = 100
+ }
+ if obj.SchedulerName == "" {
+ obj.SchedulerName = api.DefaultSchedulerName
+ }
+ if obj.HardPodAffinitySymmetricWeight == 0 {
+ obj.HardPodAffinitySymmetricWeight = api.DefaultHardPodAffinitySymmetricWeight
+ }
+ if obj.FailureDomains == "" {
+ obj.FailureDomains = api.DefaultFailureDomains
+ }
+}
+
+func SetDefaults_LeaderElectionConfiguration(obj *LeaderElectionConfiguration) {
+ zero := unversioned.Duration{}
+ if obj.LeaseDuration == zero {
+ obj.LeaseDuration = unversioned.Duration{Duration: 15 * time.Second}
+ }
+ if obj.RenewDeadline == zero {
+ obj.RenewDeadline = unversioned.Duration{Duration: 10 * time.Second}
+ }
+ if obj.RetryPeriod == zero {
+ obj.RetryPeriod = unversioned.Duration{Duration: 2 * time.Second}
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..65a03a2093dc4d92ed81d9112ce200244fbc8a24
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1alpha1
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go
index 4510fac926313787219e6f2b39e0ae25d60482b1..d74effb7d1781d0da0a2f07b31d26c59c4d2f4df 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/register.go
@@ -38,6 +38,3 @@ func addKnownTypes(scheme *runtime.Scheme) {
&KubeSchedulerConfiguration{},
)
}
-
-func (obj *KubeProxyConfiguration) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *KubeSchedulerConfiguration) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go
index 307999a4b66884e858fdbb062756231b43915de7..2ae65d87da1d902a82f4eed028f6372529e737b6 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/types.go
@@ -95,6 +95,8 @@ type KubeSchedulerConfiguration struct {
PolicyConfigFile string `json:"policyConfigFile"`
// enableProfiling enables profiling via web interface.
EnableProfiling *bool `json:"enableProfiling"`
+ // contentType is contentType of requests sent to apiserver.
+ ContentType string `json:"contentType"`
// kubeAPIQPS is the QPS to use while talking with kubernetes apiserver.
KubeAPIQPS float32 `json:"kubeAPIQPS"`
// kubeAPIBurst is the QPS burst to use while talking with kubernetes apiserver.
@@ -103,6 +105,12 @@ type KubeSchedulerConfiguration struct {
// will be processed by this scheduler, based on pod's annotation with
// key 'scheduler.alpha.kubernetes.io/name'.
SchedulerName string `json:"schedulerName"`
+ // RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule
+ // corresponding to every RequiredDuringScheduling affinity rule.
+ // HardPodAffinitySymmetricWeight represents the weight of implicit PreferredDuringScheduling affinity rule, in the range 0-100.
+ HardPodAffinitySymmetricWeight int `json:"hardPodAffinitySymmetricWeight"`
+ // Indicate the "all topologies" set for empty topologyKey when it's used for PreferredDuringScheduling pod anti-affinity.
+ FailureDomains string `json:"failureDomains"`
// leaderElection defines the configuration of leader election client.
LeaderElection LeaderElectionConfiguration `json:"leaderElection"`
}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..118d478c28b0f0e26b93331c8e4e1662a60fb4a7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/deep_copy_generated.go
@@ -0,0 +1,958 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package extensions
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ resource "k8s.io/kubernetes/pkg/api/resource"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ intstr "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_extensions_APIVersion,
+ DeepCopy_extensions_CustomMetricCurrentStatus,
+ DeepCopy_extensions_CustomMetricCurrentStatusList,
+ DeepCopy_extensions_CustomMetricTarget,
+ DeepCopy_extensions_CustomMetricTargetList,
+ DeepCopy_extensions_DaemonSet,
+ DeepCopy_extensions_DaemonSetList,
+ DeepCopy_extensions_DaemonSetSpec,
+ DeepCopy_extensions_DaemonSetStatus,
+ DeepCopy_extensions_Deployment,
+ DeepCopy_extensions_DeploymentList,
+ DeepCopy_extensions_DeploymentRollback,
+ DeepCopy_extensions_DeploymentSpec,
+ DeepCopy_extensions_DeploymentStatus,
+ DeepCopy_extensions_DeploymentStrategy,
+ DeepCopy_extensions_FSGroupStrategyOptions,
+ DeepCopy_extensions_HTTPIngressPath,
+ DeepCopy_extensions_HTTPIngressRuleValue,
+ DeepCopy_extensions_HostPortRange,
+ DeepCopy_extensions_IDRange,
+ DeepCopy_extensions_Ingress,
+ DeepCopy_extensions_IngressBackend,
+ DeepCopy_extensions_IngressList,
+ DeepCopy_extensions_IngressRule,
+ DeepCopy_extensions_IngressRuleValue,
+ DeepCopy_extensions_IngressSpec,
+ DeepCopy_extensions_IngressStatus,
+ DeepCopy_extensions_IngressTLS,
+ DeepCopy_extensions_NetworkPolicy,
+ DeepCopy_extensions_NetworkPolicyIngressRule,
+ DeepCopy_extensions_NetworkPolicyList,
+ DeepCopy_extensions_NetworkPolicyPeer,
+ DeepCopy_extensions_NetworkPolicyPort,
+ DeepCopy_extensions_NetworkPolicySpec,
+ DeepCopy_extensions_PodSecurityPolicy,
+ DeepCopy_extensions_PodSecurityPolicyList,
+ DeepCopy_extensions_PodSecurityPolicySpec,
+ DeepCopy_extensions_ReplicaSet,
+ DeepCopy_extensions_ReplicaSetList,
+ DeepCopy_extensions_ReplicaSetSpec,
+ DeepCopy_extensions_ReplicaSetStatus,
+ DeepCopy_extensions_ReplicationControllerDummy,
+ DeepCopy_extensions_RollbackConfig,
+ DeepCopy_extensions_RollingUpdateDeployment,
+ DeepCopy_extensions_RunAsUserStrategyOptions,
+ DeepCopy_extensions_SELinuxStrategyOptions,
+ DeepCopy_extensions_Scale,
+ DeepCopy_extensions_ScaleSpec,
+ DeepCopy_extensions_ScaleStatus,
+ DeepCopy_extensions_SupplementalGroupsStrategyOptions,
+ DeepCopy_extensions_ThirdPartyResource,
+ DeepCopy_extensions_ThirdPartyResourceData,
+ DeepCopy_extensions_ThirdPartyResourceDataList,
+ DeepCopy_extensions_ThirdPartyResourceList,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_extensions_APIVersion(in APIVersion, out *APIVersion, c *conversion.Cloner) error {
+ out.Name = in.Name
+ return nil
+}
+
+func DeepCopy_extensions_CustomMetricCurrentStatus(in CustomMetricCurrentStatus, out *CustomMetricCurrentStatus, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := resource.DeepCopy_resource_Quantity(in.CurrentValue, &out.CurrentValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_CustomMetricCurrentStatusList(in CustomMetricCurrentStatusList, out *CustomMetricCurrentStatusList, c *conversion.Cloner) error {
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]CustomMetricCurrentStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_CustomMetricCurrentStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_CustomMetricTarget(in CustomMetricTarget, out *CustomMetricTarget, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := resource.DeepCopy_resource_Quantity(in.TargetValue, &out.TargetValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_CustomMetricTargetList(in CustomMetricTargetList, out *CustomMetricTargetList, c *conversion.Cloner) error {
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]CustomMetricTarget, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_CustomMetricTarget(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DaemonSet(in DaemonSet, out *DaemonSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_DaemonSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_DaemonSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DaemonSetList(in DaemonSetList, out *DaemonSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]DaemonSet, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_DaemonSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DaemonSetSpec(in DaemonSetSpec, out *DaemonSetSpec, c *conversion.Cloner) error {
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := api.DeepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DaemonSetStatus(in DaemonSetStatus, out *DaemonSetStatus, c *conversion.Cloner) error {
+ out.CurrentNumberScheduled = in.CurrentNumberScheduled
+ out.NumberMisscheduled = in.NumberMisscheduled
+ out.DesiredNumberScheduled = in.DesiredNumberScheduled
+ return nil
+}
+
+func DeepCopy_extensions_Deployment(in Deployment, out *Deployment, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_DeploymentSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_DeploymentStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DeploymentList(in DeploymentList, out *DeploymentList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Deployment, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_Deployment(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DeploymentRollback(in DeploymentRollback, out *DeploymentRollback, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Name = in.Name
+ if in.UpdatedAnnotations != nil {
+ in, out := in.UpdatedAnnotations, &out.UpdatedAnnotations
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.UpdatedAnnotations = nil
+ }
+ if err := DeepCopy_extensions_RollbackConfig(in.RollbackTo, &out.RollbackTo, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DeploymentSpec(in DeploymentSpec, out *DeploymentSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := api.DeepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_DeploymentStrategy(in.Strategy, &out.Strategy, c); err != nil {
+ return err
+ }
+ out.MinReadySeconds = in.MinReadySeconds
+ if in.RevisionHistoryLimit != nil {
+ in, out := in.RevisionHistoryLimit, &out.RevisionHistoryLimit
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.RevisionHistoryLimit = nil
+ }
+ out.Paused = in.Paused
+ if in.RollbackTo != nil {
+ in, out := in.RollbackTo, &out.RollbackTo
+ *out = new(RollbackConfig)
+ if err := DeepCopy_extensions_RollbackConfig(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RollbackTo = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_DeploymentStatus(in DeploymentStatus, out *DeploymentStatus, c *conversion.Cloner) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = in.Replicas
+ out.UpdatedReplicas = in.UpdatedReplicas
+ out.AvailableReplicas = in.AvailableReplicas
+ out.UnavailableReplicas = in.UnavailableReplicas
+ return nil
+}
+
+func DeepCopy_extensions_DeploymentStrategy(in DeploymentStrategy, out *DeploymentStrategy, c *conversion.Cloner) error {
+ out.Type = in.Type
+ if in.RollingUpdate != nil {
+ in, out := in.RollingUpdate, &out.RollingUpdate
+ *out = new(RollingUpdateDeployment)
+ if err := DeepCopy_extensions_RollingUpdateDeployment(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RollingUpdate = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_FSGroupStrategyOptions(in FSGroupStrategyOptions, out *FSGroupStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_HTTPIngressPath(in HTTPIngressPath, out *HTTPIngressPath, c *conversion.Cloner) error {
+ out.Path = in.Path
+ if err := DeepCopy_extensions_IngressBackend(in.Backend, &out.Backend, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_HTTPIngressRuleValue(in HTTPIngressRuleValue, out *HTTPIngressRuleValue, c *conversion.Cloner) error {
+ if in.Paths != nil {
+ in, out := in.Paths, &out.Paths
+ *out = make([]HTTPIngressPath, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_HTTPIngressPath(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Paths = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_HostPortRange(in HostPortRange, out *HostPortRange, c *conversion.Cloner) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func DeepCopy_extensions_IDRange(in IDRange, out *IDRange, c *conversion.Cloner) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func DeepCopy_extensions_Ingress(in Ingress, out *Ingress, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_IngressSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_IngressStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressBackend(in IngressBackend, out *IngressBackend, c *conversion.Cloner) error {
+ out.ServiceName = in.ServiceName
+ if err := intstr.DeepCopy_intstr_IntOrString(in.ServicePort, &out.ServicePort, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressList(in IngressList, out *IngressList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Ingress, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_Ingress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error {
+ out.Host = in.Host
+ if err := DeepCopy_extensions_IngressRuleValue(in.IngressRuleValue, &out.IngressRuleValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressRuleValue(in IngressRuleValue, out *IngressRuleValue, c *conversion.Cloner) error {
+ if in.HTTP != nil {
+ in, out := in.HTTP, &out.HTTP
+ *out = new(HTTPIngressRuleValue)
+ if err := DeepCopy_extensions_HTTPIngressRuleValue(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.HTTP = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressSpec(in IngressSpec, out *IngressSpec, c *conversion.Cloner) error {
+ if in.Backend != nil {
+ in, out := in.Backend, &out.Backend
+ *out = new(IngressBackend)
+ if err := DeepCopy_extensions_IngressBackend(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Backend = nil
+ }
+ if in.TLS != nil {
+ in, out := in.TLS, &out.TLS
+ *out = make([]IngressTLS, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_IngressTLS(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.TLS = nil
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]IngressRule, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_IngressRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressStatus(in IngressStatus, out *IngressStatus, c *conversion.Cloner) error {
+ if err := api.DeepCopy_api_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_IngressTLS(in IngressTLS, out *IngressTLS, c *conversion.Cloner) error {
+ if in.Hosts != nil {
+ in, out := in.Hosts, &out.Hosts
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Hosts = nil
+ }
+ out.SecretName = in.SecretName
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicy(in NetworkPolicy, out *NetworkPolicy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_NetworkPolicySpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicyIngressRule(in NetworkPolicyIngressRule, out *NetworkPolicyIngressRule, c *conversion.Cloner) error {
+ if in.Ports != nil {
+ in, out := in.Ports, &out.Ports
+ *out = make([]NetworkPolicyPort, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_NetworkPolicyPort(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.From != nil {
+ in, out := in.From, &out.From
+ *out = make([]NetworkPolicyPeer, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_NetworkPolicyPeer(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.From = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicyList(in NetworkPolicyList, out *NetworkPolicyList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]NetworkPolicy, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_NetworkPolicy(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicyPeer(in NetworkPolicyPeer, out *NetworkPolicyPeer, c *conversion.Cloner) error {
+ if in.PodSelector != nil {
+ in, out := in.PodSelector, &out.PodSelector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodSelector = nil
+ }
+ if in.NamespaceSelector != nil {
+ in, out := in.NamespaceSelector, &out.NamespaceSelector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NamespaceSelector = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicyPort(in NetworkPolicyPort, out *NetworkPolicyPort, c *conversion.Cloner) error {
+ if in.Protocol != nil {
+ in, out := in.Protocol, &out.Protocol
+ *out = new(api.Protocol)
+ **out = *in
+ } else {
+ out.Protocol = nil
+ }
+ if in.Port != nil {
+ in, out := in.Port, &out.Port
+ *out = new(intstr.IntOrString)
+ if err := intstr.DeepCopy_intstr_IntOrString(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Port = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_NetworkPolicySpec(in NetworkPolicySpec, out *NetworkPolicySpec, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(in.PodSelector, &out.PodSelector, c); err != nil {
+ return err
+ }
+ if in.Ingress != nil {
+ in, out := in.Ingress, &out.Ingress
+ *out = make([]NetworkPolicyIngressRule, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_NetworkPolicyIngressRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_PodSecurityPolicy(in PodSecurityPolicy, out *PodSecurityPolicy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_PodSecurityPolicySpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_PodSecurityPolicyList(in PodSecurityPolicyList, out *PodSecurityPolicyList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PodSecurityPolicy, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_PodSecurityPolicy(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_PodSecurityPolicySpec(in PodSecurityPolicySpec, out *PodSecurityPolicySpec, c *conversion.Cloner) error {
+ out.Privileged = in.Privileged
+ if in.DefaultAddCapabilities != nil {
+ in, out := in.DefaultAddCapabilities, &out.DefaultAddCapabilities
+ *out = make([]api.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.DefaultAddCapabilities = nil
+ }
+ if in.RequiredDropCapabilities != nil {
+ in, out := in.RequiredDropCapabilities, &out.RequiredDropCapabilities
+ *out = make([]api.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.RequiredDropCapabilities = nil
+ }
+ if in.AllowedCapabilities != nil {
+ in, out := in.AllowedCapabilities, &out.AllowedCapabilities
+ *out = make([]api.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.AllowedCapabilities = nil
+ }
+ if in.Volumes != nil {
+ in, out := in.Volumes, &out.Volumes
+ *out = make([]FSType, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Volumes = nil
+ }
+ out.HostNetwork = in.HostNetwork
+ if in.HostPorts != nil {
+ in, out := in.HostPorts, &out.HostPorts
+ *out = make([]HostPortRange, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_HostPortRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HostPorts = nil
+ }
+ out.HostPID = in.HostPID
+ out.HostIPC = in.HostIPC
+ if err := DeepCopy_extensions_SELinuxStrategyOptions(in.SELinux, &out.SELinux, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_RunAsUserStrategyOptions(in.RunAsUser, &out.RunAsUser, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_SupplementalGroupsStrategyOptions(in.SupplementalGroups, &out.SupplementalGroups, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_FSGroupStrategyOptions(in.FSGroup, &out.FSGroup, c); err != nil {
+ return err
+ }
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
+ return nil
+}
+
+func DeepCopy_extensions_ReplicaSet(in ReplicaSet, out *ReplicaSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_ReplicaSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_ReplicaSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ReplicaSetList(in ReplicaSetList, out *ReplicaSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ReplicaSet, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_ReplicaSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ReplicaSetSpec(in ReplicaSetSpec, out *ReplicaSetSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := api.DeepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ReplicaSetStatus(in ReplicaSetStatus, out *ReplicaSetStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func DeepCopy_extensions_ReplicationControllerDummy(in ReplicationControllerDummy, out *ReplicationControllerDummy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_RollbackConfig(in RollbackConfig, out *RollbackConfig, c *conversion.Cloner) error {
+ out.Revision = in.Revision
+ return nil
+}
+
+func DeepCopy_extensions_RollingUpdateDeployment(in RollingUpdateDeployment, out *RollingUpdateDeployment, c *conversion.Cloner) error {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.MaxUnavailable, &out.MaxUnavailable, c); err != nil {
+ return err
+ }
+ if err := intstr.DeepCopy_intstr_IntOrString(in.MaxSurge, &out.MaxSurge, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_RunAsUserStrategyOptions(in RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_SELinuxStrategyOptions(in SELinuxStrategyOptions, out *SELinuxStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.SELinuxOptions != nil {
+ in, out := in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(api.SELinuxOptions)
+ if err := api.DeepCopy_api_SELinuxOptions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_extensions_ScaleStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func DeepCopy_extensions_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_SupplementalGroupsStrategyOptions(in SupplementalGroupsStrategyOptions, out *SupplementalGroupsStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ThirdPartyResource(in ThirdPartyResource, out *ThirdPartyResource, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ out.Description = in.Description
+ if in.Versions != nil {
+ in, out := in.Versions, &out.Versions
+ *out = make([]APIVersion, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_APIVersion(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Versions = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ThirdPartyResourceData(in ThirdPartyResourceData, out *ThirdPartyResourceData, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Data != nil {
+ in, out := in.Data, &out.Data
+ *out = make([]byte, len(in))
+ copy(*out, in)
+ } else {
+ out.Data = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ThirdPartyResourceDataList(in ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ThirdPartyResourceData, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_ThirdPartyResourceData(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_extensions_ThirdPartyResourceList(in ThirdPartyResourceList, out *ThirdPartyResourceList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ThirdPartyResource, len(in))
+ for i := range in {
+ if err := DeepCopy_extensions_ThirdPartyResource(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/install/install.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/install/install.go
index 90d5c507335b79aef1cf5d5b22a87e39b828b835..449127084b32b8097c8feb395cacb21d9b14a67d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/install/install.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/install/install.go
@@ -92,6 +92,7 @@ func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper
// if a kind is not enumerated here, it is assumed to have a namespace scope
rootScoped := sets.NewString(
"PodSecurityPolicy",
+ "ThirdPartyResource",
)
ignoredKinds := sets.NewString()
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/register.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c5f6ba105aba4515b73a440cabe60a1e1e76234
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/register.go
@@ -0,0 +1,79 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 extensions
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/autoscaling"
+ "k8s.io/kubernetes/pkg/apis/batch"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "extensions"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ // Add the API to Scheme.
+ addKnownTypes(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ // TODO this gets cleaned up when the types are fixed
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Deployment{},
+ &DeploymentList{},
+ &DeploymentRollback{},
+ &autoscaling.HorizontalPodAutoscaler{},
+ &autoscaling.HorizontalPodAutoscalerList{},
+ &batch.Job{},
+ &batch.JobList{},
+ &batch.JobTemplate{},
+ &ReplicationControllerDummy{},
+ &Scale{},
+ &ThirdPartyResource{},
+ &ThirdPartyResourceList{},
+ &DaemonSetList{},
+ &DaemonSet{},
+ &ThirdPartyResourceData{},
+ &ThirdPartyResourceDataList{},
+ &Ingress{},
+ &IngressList{},
+ &api.ListOptions{},
+ &ReplicaSet{},
+ &ReplicaSetList{},
+ &api.ExportOptions{},
+ &PodSecurityPolicy{},
+ &PodSecurityPolicyList{},
+ &NetworkPolicy{},
+ &NetworkPolicyList{},
+ )
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go
index 2df94989766963d3e68bf725242e3e322e39a4e6..eec90fb0a2cd8c91706cf5db471c185c264d2a5b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,10 +29,9 @@ import (
pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
pkg3_types "k8s.io/kubernetes/pkg/types"
- pkg6_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
"reflect"
"runtime"
- pkg5_inf "speter.net/go/exp/math/dec/inf"
time "time"
)
@@ -70,10 +69,9 @@ func init() {
var v1 pkg4_resource.Quantity
var v2 pkg1_unversioned.LabelSelector
var v3 pkg3_types.UID
- var v4 pkg6_intstr.IntOrString
- var v5 pkg5_inf.Dec
- var v6 time.Time
- _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
}
}
@@ -198,7 +196,7 @@ func (x *ScaleSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -228,7 +226,7 @@ func (x *ScaleSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
for {
yyj5++
@@ -396,7 +394,7 @@ func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
case "selector":
if r.TryDecodeAsNil() {
@@ -443,7 +441,7 @@ func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Replicas = 0
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Replicas = int32(r.DecodeInt(32))
}
yyj7++
if yyhl7 {
@@ -1048,7 +1046,7 @@ func (x *ReplicationControllerDummy) codecDecodeSelfFromArray(l int, d *codec197
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -1062,18 +1060,14 @@ func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Kind != ""
- yyq2[1] = x.Name != ""
- yyq2[2] = x.APIVersion != ""
- yyq2[3] = x.Subresource != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 0
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -1084,102 +1078,48 @@ func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
+ yy7 := &x.TargetValue
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy7) {
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy7)
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ z.EncFallback(yy7)
}
} else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("value"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.TargetValue
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy9)
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("subresource"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
- }
+ z.EncFallback(yy9)
}
}
if yyr2 || yy2arr2 {
@@ -1191,7 +1131,7 @@ func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *SubresourceReference) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *CustomMetricTarget) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1221,7 +1161,7 @@ func (x *SubresourceReference) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *SubresourceReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1243,29 +1183,26 @@ func (x *SubresourceReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
case "name":
if r.TryDecodeAsNil() {
x.Name = ""
} else {
x.Name = string(r.DecodeString())
}
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- case "subresource":
+ case "value":
if r.TryDecodeAsNil() {
- x.Subresource = ""
+ x.TargetValue = pkg4_resource.Quantity{}
} else {
- x.Subresource = string(r.DecodeString())
+ yyv5 := &x.TargetValue
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv5) {
+ } else if !yym6 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv5)
+ } else {
+ z.DecFallback(yyv5, false)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -1274,36 +1211,20 @@ func (x *SubresourceReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *SubresourceReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
- } else {
- yyb8 = r.CheckBreak()
- }
- if yyb8 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -1313,55 +1234,48 @@ func (x *SubresourceReference) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Name = string(r.DecodeString())
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
- } else {
- yyb8 = r.CheckBreak()
- }
- if yyb8 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Subresource = ""
+ x.TargetValue = pkg4_resource.Quantity{}
} else {
- x.Subresource = string(r.DecodeString())
+ yyv9 := &x.TargetValue
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv9)
+ } else {
+ z.DecFallback(yyv9, false)
+ }
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -1393,21 +1307,29 @@ func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if x.Items == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(x.TargetPercentage))
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
+ }
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("targetPercentage"))
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
+ if x.Items == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(x.TargetPercentage))
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
+ }
}
}
if yyr2 || yy2arr2 {
@@ -1419,7 +1341,7 @@ func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *CPUTargetUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *CustomMetricTargetList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1449,7 +1371,7 @@ func (x *CPUTargetUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *CPUTargetUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1471,12 +1393,18 @@ func (x *CPUTargetUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decode
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "targetPercentage":
+ case "items":
if r.TryDecodeAsNil() {
- x.TargetPercentage = 0
+ x.Items = nil
} else {
- x.TargetPercentage = int(r.DecodeInt(codecSelferBitsize1234))
- }
+ yyv4 := &x.Items
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv4), d)
+ }
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -1484,46 +1412,52 @@ func (x *CPUTargetUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *CPUTargetUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb5 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.TargetPercentage = 0
+ x.Items = nil
} else {
- x.TargetPercentage = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv7 := &x.Items
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv7), d)
+ }
}
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb5 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -1574,7 +1508,7 @@ func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.TargetValue
+ yy7 := &x.CurrentValue
yym8 := z.EncBinary()
_ = yym8
if false {
@@ -1588,7 +1522,7 @@ func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("value"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.TargetValue
+ yy9 := &x.CurrentValue
yym10 := z.EncBinary()
_ = yym10
if false {
@@ -1608,7 +1542,7 @@ func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *CustomMetricTarget) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1638,7 +1572,7 @@ func (x *CustomMetricTarget) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1668,9 +1602,9 @@ func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
case "value":
if r.TryDecodeAsNil() {
- x.TargetValue = pkg4_resource.Quantity{}
+ x.CurrentValue = pkg4_resource.Quantity{}
} else {
- yyv5 := &x.TargetValue
+ yyv5 := &x.CurrentValue
yym6 := z.DecBinary()
_ = yym6
if false {
@@ -1688,7 +1622,7 @@ func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1723,9 +1657,9 @@ func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decode
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.TargetValue = pkg4_resource.Quantity{}
+ x.CurrentValue = pkg4_resource.Quantity{}
} else {
- yyv9 := &x.TargetValue
+ yyv9 := &x.CurrentValue
yym10 := z.DecBinary()
_ = yym10
if false {
@@ -1752,7 +1686,7 @@ func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -1791,7 +1725,7 @@ func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym4
if false {
} else {
- h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
+ h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
}
}
} else {
@@ -1805,7 +1739,7 @@ func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym5
if false {
} else {
- h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
+ h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
}
}
}
@@ -1818,7 +1752,7 @@ func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *CustomMetricTargetList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1848,7 +1782,7 @@ func (x *CustomMetricTargetList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1879,7 +1813,7 @@ func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Deco
_ = yym5
if false {
} else {
- h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv4), d)
+ h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv4), d)
}
}
default:
@@ -1889,7 +1823,7 @@ func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Deco
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -1915,7 +1849,7 @@ func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.De
_ = yym8
if false {
} else {
- h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv7), d)
+ h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv7), d)
}
}
for {
@@ -1934,7 +1868,7 @@ func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.De
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -1948,14 +1882,19 @@ func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = x.Description != ""
+ yyq2[2] = len(x.Versions) != 0
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(5)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -1966,48 +1905,127 @@ func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Description))
+ }
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("description"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Description))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.CurrentValue
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else if z.HasExtensions() && z.EncExt(yy7) {
- } else if !yym8 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy7)
+ if yyq2[2] {
+ if x.Versions == nil {
+ r.EncodeNil()
+ } else {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
+ }
+ }
} else {
- z.EncFallback(yy7)
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("value"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.CurrentValue
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else if z.HasExtensions() && z.EncExt(yy9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy9)
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("versions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Versions == nil {
+ r.EncodeNil()
+ } else {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
} else {
- z.EncFallback(yy9)
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
}
}
if yyr2 || yy2arr2 {
@@ -2019,7 +2037,7 @@ func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *CustomMetricCurrentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2049,7 +2067,7 @@ func (x *CustomMetricCurrentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2071,27 +2089,43 @@ func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.D
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "name":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Name = string(r.DecodeString())
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "value":
+ case "description":
if r.TryDecodeAsNil() {
- x.CurrentValue = pkg4_resource.Quantity{}
+ x.Description = ""
} else {
- yyv5 := &x.CurrentValue
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv5) {
- } else if !yym6 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv5)
- } else {
- z.DecFallback(yyv5, false)
+ x.Description = string(r.DecodeString())
+ }
+ case "versions":
+ if r.TryDecodeAsNil() {
+ x.Versions = nil
+ } else {
+ yyv6 := &x.Versions
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceAPIVersion((*[]APIVersion)(yyv6), d)
}
}
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -2099,71 +2133,117 @@ func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.D
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *CustomMetricCurrentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Name = string(r.DecodeString())
+ yyv11 := &x.ObjectMeta
+ yyv11.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.CurrentValue = pkg4_resource.Quantity{}
+ x.Description = ""
} else {
- yyv9 := &x.CurrentValue
- yym10 := z.DecBinary()
- _ = yym10
+ x.Description = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Versions = nil
+ } else {
+ yyv13 := &x.Versions
+ yym14 := z.DecBinary()
+ _ = yym14
if false {
- } else if z.HasExtensions() && z.DecExt(yyv9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv9)
} else {
- z.DecFallback(yyv9, false)
+ h.decSliceAPIVersion((*[]APIVersion)(yyv13), d)
}
}
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -2177,12 +2257,15 @@ func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -2193,16 +2276,45 @@ func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeMapStart(yynn2)
yynn2 = 0
}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4 := z.EncBinary()
- _ = yym4
+ yym9 := z.EncBinary()
+ _ = yym9
if false {
} else {
- h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
+ h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
}
}
} else {
@@ -2212,11 +2324,61 @@ func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym5 := z.EncBinary()
- _ = yym5
+ yym10 := z.EncBinary()
+ _ = yym10
if false {
} else {
- h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
+ h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -2229,7 +2391,7 @@ func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *CustomMetricCurrentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2259,7 +2421,7 @@ func (x *CustomMetricCurrentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2281,39 +2443,87 @@ func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec19
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "items":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv4 := &x.Items
+ yyv4 := &x.ListMeta
yym5 := z.DecBinary()
_ = yym5
if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
} else {
- h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv4), d)
+ z.DecFallback(yyv4, false)
}
}
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb6 {
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -2321,31 +2531,63 @@ func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv7 := &x.Items
- yym8 := z.DecBinary()
- _ = yym8
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
if false {
} else {
- h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv7), d)
+ h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv13), d)
}
}
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb6 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -2359,16 +2601,15 @@ func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.MinReplicas != nil
- yyq2[3] = x.CPUUtilization != nil
+ yyq2[0] = x.Name != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(1)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -2379,89 +2620,26 @@ func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4 := &x.ScaleRef
- yy4.CodecEncodeSelf(e)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ScaleRef
- yy6.CodecEncodeSelf(e)
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.MinReplicas == nil {
- r.EncodeNil()
- } else {
- yy9 := *x.MinReplicas
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- r.EncodeInt(int64(yy9))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.MinReplicas == nil {
- r.EncodeNil()
- } else {
- yy11 := *x.MinReplicas
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeInt(int64(yy11))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeInt(int64(x.MaxReplicas))
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeInt(int64(x.MaxReplicas))
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- if x.CPUUtilization == nil {
- r.EncodeNil()
+ if yyq2[0] {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- x.CPUUtilization.CodecEncodeSelf(e)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[3] {
+ if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("cpuUtilization"))
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.CPUUtilization == nil {
- r.EncodeNil()
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- x.CPUUtilization.CodecEncodeSelf(e)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
}
@@ -2474,7 +2652,7 @@ func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2504,7 +2682,7 @@ func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2526,45 +2704,11 @@ func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "scaleRef":
- if r.TryDecodeAsNil() {
- x.ScaleRef = SubresourceReference{}
- } else {
- yyv4 := &x.ScaleRef
- yyv4.CodecDecodeSelf(d)
- }
- case "minReplicas":
- if r.TryDecodeAsNil() {
- if x.MinReplicas != nil {
- x.MinReplicas = nil
- }
- } else {
- if x.MinReplicas == nil {
- x.MinReplicas = new(int)
- }
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else {
- *((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
- }
- case "maxReplicas":
- if r.TryDecodeAsNil() {
- x.MaxReplicas = 0
- } else {
- x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "cpuUtilization":
+ case "name":
if r.TryDecodeAsNil() {
- if x.CPUUtilization != nil {
- x.CPUUtilization = nil
- }
+ x.Name = ""
} else {
- if x.CPUUtilization == nil {
- x.CPUUtilization = new(CPUTargetUtilization)
- }
- x.CPUUtilization.CodecDecodeSelf(d)
+ x.Name = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -2573,110 +2717,46 @@ func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb9 {
+ if yyb5 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ScaleRef = SubresourceReference{}
- } else {
- yyv10 := &x.ScaleRef
- yyv10.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ x.Name = ""
} else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.MinReplicas != nil {
- x.MinReplicas = nil
- }
- } else {
- if x.MinReplicas == nil {
- x.MinReplicas = new(int)
- }
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else {
- *((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.MaxReplicas = 0
- } else {
- x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.CPUUtilization != nil {
- x.CPUUtilization = nil
- }
- } else {
- if x.CPUUtilization == nil {
- x.CPUUtilization = new(CPUTargetUtilization)
- }
- x.CPUUtilization.CodecDecodeSelf(d)
+ x.Name = string(r.DecodeString())
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb9 {
+ if yyb5 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj5-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -2690,17 +2770,18 @@ func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.ObservedGeneration != nil
- yyq2[1] = x.LastScaleTime != nil
- yyq2[4] = x.CurrentCPUUtilizationPercentage != nil
+ yyq2[0] = true
+ yyq2[1] = len(x.Data) != 0
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -2712,54 +2793,31 @@ func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- if x.ObservedGeneration == nil {
- r.EncodeNil()
- } else {
- yy4 := *x.ObservedGeneration
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(yy4))
- }
- }
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.ObservedGeneration == nil {
- r.EncodeNil()
- } else {
- yy6 := *x.ObservedGeneration
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeInt(int64(yy6))
- }
- }
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.LastScaleTime == nil {
+ if x.Data == nil {
r.EncodeNil()
} else {
yym9 := z.EncBinary()
_ = yym9
if false {
- } else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
- } else if yym9 {
- z.EncBinaryMarshal(x.LastScaleTime)
- } else if !yym9 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.LastScaleTime)
} else {
- z.EncFallback(x.LastScaleTime)
+ r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
}
}
} else {
@@ -2768,95 +2826,67 @@ func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
+ r.EncodeString(codecSelferC_UTF81234, string("data"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.LastScaleTime == nil {
+ if x.Data == nil {
r.EncodeNil()
} else {
yym10 := z.EncBinary()
_ = yym10
if false {
- } else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
- } else if yym10 {
- z.EncBinaryMarshal(x.LastScaleTime)
- } else if !yym10 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.LastScaleTime)
} else {
- z.EncFallback(x.LastScaleTime)
+ r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
}
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeInt(int64(x.CurrentReplicas))
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeInt(int64(x.CurrentReplicas))
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym15 := z.EncBinary()
- _ = yym15
- if false {
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
} else {
- r.EncodeInt(int64(x.DesiredReplicas))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeInt(int64(x.DesiredReplicas))
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- if x.CurrentCPUUtilizationPercentage == nil {
- r.EncodeNil()
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
} else {
- yy18 := *x.CurrentCPUUtilizationPercentage
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeInt(int64(yy18))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[4] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.CurrentCPUUtilizationPercentage == nil {
- r.EncodeNil()
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
} else {
- yy20 := *x.CurrentCPUUtilizationPercentage
- yym21 := z.EncBinary()
- _ = yym21
- if false {
- } else {
- r.EncodeInt(int64(yy20))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -2869,7 +2899,7 @@ func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2899,7 +2929,7 @@ func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -2921,70 +2951,36 @@ func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec19
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "observedGeneration":
+ case "metadata":
if r.TryDecodeAsNil() {
- if x.ObservedGeneration != nil {
- x.ObservedGeneration = nil
- }
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- if x.ObservedGeneration == nil {
- x.ObservedGeneration = new(int64)
- }
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
- }
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "lastScaleTime":
+ case "data":
if r.TryDecodeAsNil() {
- if x.LastScaleTime != nil {
- x.LastScaleTime = nil
- }
+ x.Data = nil
} else {
- if x.LastScaleTime == nil {
- x.LastScaleTime = new(pkg1_unversioned.Time)
- }
- yym7 := z.DecBinary()
- _ = yym7
+ yyv5 := &x.Data
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
- } else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
- } else if yym7 {
- z.DecBinaryUnmarshal(x.LastScaleTime)
- } else if !yym7 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.LastScaleTime)
} else {
- z.DecFallback(x.LastScaleTime, false)
+ *yyv5 = r.DecodeBytes(*(*[]byte)(yyv5), false, false)
}
}
- case "currentReplicas":
- if r.TryDecodeAsNil() {
- x.CurrentReplicas = 0
- } else {
- x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "desiredReplicas":
+ case "kind":
if r.TryDecodeAsNil() {
- x.DesiredReplicas = 0
+ x.Kind = ""
} else {
- x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Kind = string(r.DecodeString())
}
- case "currentCPUUtilizationPercentage":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- if x.CurrentCPUUtilizationPercentage != nil {
- x.CurrentCPUUtilizationPercentage = nil
- }
+ x.APIVersion = ""
} else {
- if x.CurrentCPUUtilizationPercentage == nil {
- x.CurrentCPUUtilizationPercentage = new(int)
- }
- yym11 := z.DecBinary()
- _ = yym11
- if false {
- } else {
- *((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -2993,145 +2989,101 @@ func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec19
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj12 int
- var yyb12 bool
- var yyhl12 bool = l >= 0
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.ObservedGeneration != nil {
- x.ObservedGeneration = nil
- }
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- if x.ObservedGeneration == nil {
- x.ObservedGeneration = new(int64)
- }
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- *((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
- }
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.LastScaleTime != nil {
- x.LastScaleTime = nil
- }
+ x.Data = nil
} else {
- if x.LastScaleTime == nil {
- x.LastScaleTime = new(pkg1_unversioned.Time)
- }
- yym16 := z.DecBinary()
- _ = yym16
+ yyv11 := &x.Data
+ yym12 := z.DecBinary()
+ _ = yym12
if false {
- } else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
- } else if yym16 {
- z.DecBinaryUnmarshal(x.LastScaleTime)
- } else if !yym16 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.LastScaleTime)
} else {
- z.DecFallback(x.LastScaleTime, false)
+ *yyv11 = r.DecodeBytes(*(*[]byte)(yyv11), false, false)
}
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
- } else {
- yyb12 = r.CheckBreak()
- }
- if yyb12 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.CurrentReplicas = 0
- } else {
- x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.DesiredReplicas = 0
+ x.Kind = ""
} else {
- x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Kind = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.CurrentCPUUtilizationPercentage != nil {
- x.CurrentCPUUtilizationPercentage = nil
- }
+ x.APIVersion = ""
} else {
- if x.CurrentCPUUtilizationPercentage == nil {
- x.CurrentCPUUtilizationPercentage = new(int)
- }
- yym20 := z.DecBinary()
- _ = yym20
- if false {
- } else {
- *((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj12-1, "")
+ z.DecStructFieldNotFound(yyj9-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -3276,7 +3228,7 @@ func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -3306,7 +3258,7 @@ func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -3337,14 +3289,14 @@ func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Dec
}
case "spec":
if r.TryDecodeAsNil() {
- x.Spec = HorizontalPodAutoscalerSpec{}
+ x.Spec = DeploymentSpec{}
} else {
yyv5 := &x.Spec
yyv5.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
- x.Status = HorizontalPodAutoscalerStatus{}
+ x.Status = DeploymentStatus{}
} else {
yyv6 := &x.Status
yyv6.CodecDecodeSelf(d)
@@ -3368,7 +3320,7 @@ func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -3404,7 +3356,7 @@ func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.D
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Spec = HorizontalPodAutoscalerSpec{}
+ x.Spec = DeploymentSpec{}
} else {
yyv11 := &x.Spec
yyv11.CodecDecodeSelf(d)
@@ -3421,7 +3373,7 @@ func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.D
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Status = HorizontalPodAutoscalerStatus{}
+ x.Status = DeploymentStatus{}
} else {
yyv12 := &x.Status
yyv12.CodecDecodeSelf(d)
@@ -3474,7 +3426,7 @@ func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.D
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -3488,15 +3440,19 @@ func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [8]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[0] = x.Replicas != 0
+ yyq2[1] = x.Selector != nil
+ yyq2[3] = true
+ yyq2[4] = x.MinReadySeconds != 0
+ yyq2[5] = x.RevisionHistoryLimit != nil
+ yyq2[6] = x.Paused != false
+ yyq2[7] = x.RollbackTo != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(8)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -3510,106 +3466,196 @@ func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
+ yym4 := z.EncBinary()
+ _ = yym4
if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- z.EncFallback(yy4)
+ r.EncodeInt(int64(x.Replicas))
}
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- z.EncFallback(yy6)
+ r.EncodeInt(int64(x.Replicas))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
} else {
- h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
}
}
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy10 := &x.Template
+ yy10.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
+ yy12 := &x.Template
+ yy12.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yy15 := &x.Strategy
+ yy15.CodecEncodeSelf(e)
+ } else {
r.EncodeNil()
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("strategy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy17 := &x.Strategy
+ yy17.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeInt(int64(x.MinReadySeconds))
+ }
} else {
- yym10 := z.EncBinary()
- _ = yym10
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
if false {
} else {
- h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
+ r.EncodeInt(int64(x.MinReadySeconds))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
+ if yyq2[5] {
+ if x.RevisionHistoryLimit == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ yy23 := *x.RevisionHistoryLimit
+ yym24 := z.EncBinary()
+ _ = yym24
+ if false {
+ } else {
+ r.EncodeInt(int64(yy23))
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
+ if x.RevisionHistoryLimit == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ yy25 := *x.RevisionHistoryLimit
+ yym26 := z.EncBinary()
+ _ = yym26
+ if false {
+ } else {
+ r.EncodeInt(int64(yy25))
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
+ if yyq2[6] {
+ yym28 := z.EncBinary()
+ _ = yym28
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeBool(bool(x.Paused))
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeBool(false)
}
} else {
- if yyq2[3] {
+ if yyq2[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("paused"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
+ yym29 := z.EncBinary()
+ _ = yym29
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeBool(bool(x.Paused))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[7] {
+ if x.RollbackTo == nil {
+ r.EncodeNil()
+ } else {
+ x.RollbackTo.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[7] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RollbackTo == nil {
+ r.EncodeNil()
+ } else {
+ x.RollbackTo.CodecEncodeSelf(e)
}
}
}
@@ -3622,7 +3668,7 @@ func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -3652,7 +3698,7 @@ func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -3674,151 +3720,269 @@ func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
+ case "replicas":
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Replicas = 0
} else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
+ x.Replicas = int32(r.DecodeInt(32))
}
- case "items":
+ case "selector":
if r.TryDecodeAsNil() {
- x.Items = nil
+ if x.Selector != nil {
+ x.Selector = nil
+ }
} else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv6), d)
+ z.DecFallback(x.Selector, false)
}
}
- case "kind":
+ case "template":
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- x.Kind = string(r.DecodeString())
+ yyv7 := &x.Template
+ yyv7.CodecDecodeSelf(d)
}
- case "apiVersion":
+ case "strategy":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Strategy = DeploymentStrategy{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv8 := &x.Strategy
+ yyv8.CodecDecodeSelf(d)
}
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ case "minReadySeconds":
+ if r.TryDecodeAsNil() {
+ x.MinReadySeconds = 0
+ } else {
+ x.MinReadySeconds = int32(r.DecodeInt(32))
+ }
+ case "revisionHistoryLimit":
+ if r.TryDecodeAsNil() {
+ if x.RevisionHistoryLimit != nil {
+ x.RevisionHistoryLimit = nil
+ }
+ } else {
+ if x.RevisionHistoryLimit == nil {
+ x.RevisionHistoryLimit = new(int32)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else {
+ *((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
+ }
+ }
+ case "paused":
+ if r.TryDecodeAsNil() {
+ x.Paused = false
+ } else {
+ x.Paused = bool(r.DecodeBool())
+ }
+ case "rollbackTo":
+ if r.TryDecodeAsNil() {
+ if x.RollbackTo != nil {
+ x.RollbackTo = nil
+ }
+ } else {
+ if x.RollbackTo == nil {
+ x.RollbackTo = new(RollbackConfig)
+ }
+ x.RollbackTo.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj14 int
+ var yyb14 bool
+ var yyhl14 bool = l >= 0
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb10 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Replicas = 0
} else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
+ x.Replicas = int32(r.DecodeInt(32))
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym17 := z.DecBinary()
+ _ = yym17
if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- z.DecFallback(yyv11, false)
+ z.DecFallback(x.Selector, false)
}
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb10 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
+ yyv18 := &x.Template
+ yyv18.CodecDecodeSelf(d)
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Strategy = DeploymentStrategy{}
+ } else {
+ yyv19 := &x.Strategy
+ yyv19.CodecDecodeSelf(d)
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MinReadySeconds = 0
+ } else {
+ x.MinReadySeconds = int32(r.DecodeInt(32))
+ }
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
+ } else {
+ yyb14 = r.CheckBreak()
+ }
+ if yyb14 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.RevisionHistoryLimit != nil {
+ x.RevisionHistoryLimit = nil
+ }
+ } else {
+ if x.RevisionHistoryLimit == nil {
+ x.RevisionHistoryLimit = new(int32)
+ }
+ yym22 := z.DecBinary()
+ _ = yym22
if false {
} else {
- h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv13), d)
+ *((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
}
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb10 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Paused = false
} else {
- x.Kind = string(r.DecodeString())
+ x.Paused = bool(r.DecodeBool())
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb10 {
+ if yyb14 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ if x.RollbackTo != nil {
+ x.RollbackTo = nil
+ }
} else {
- x.APIVersion = string(r.DecodeString())
+ if x.RollbackTo == nil {
+ x.RollbackTo = new(RollbackConfig)
+ }
+ x.RollbackTo.CodecDecodeSelf(d)
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj14++
+ if yyhl14 {
+ yyb14 = yyj14 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb14 = r.CheckBreak()
}
- if yyb10 {
+ if yyb14 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj14-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -3835,16 +3999,14 @@ func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = x.Description != ""
- yyq2[2] = len(x.Versions) != 0
+ yyq2[1] = len(x.UpdatedAnnotations) != 0
yyq2[3] = x.Kind != ""
yyq2[4] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(5)
} else {
- yynn2 = 0
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -3855,78 +4017,66 @@ func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
+ if x.UpdatedAnnotations == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Description))
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("description"))
+ r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Description))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- if x.Versions == nil {
+ if x.UpdatedAnnotations == nil {
r.EncodeNil()
} else {
- yym12 := z.EncBinary()
- _ = yym12
+ yym8 := z.EncBinary()
+ _ = yym8
if false {
} else {
- h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
+ z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
}
}
- } else {
- r.EncodeNil()
}
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy10 := &x.RollbackTo
+ yy10.CodecEncodeSelf(e)
} else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("versions"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Versions == nil {
- r.EncodeNil()
- } else {
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
- }
- }
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy12 := &x.RollbackTo
+ yy12.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
@@ -3987,7 +4137,7 @@ func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DeploymentRollback) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4017,7 +4167,7 @@ func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4039,31 +4189,31 @@ func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "description":
+ case "name":
if r.TryDecodeAsNil() {
- x.Description = ""
+ x.Name = ""
} else {
- x.Description = string(r.DecodeString())
+ x.Name = string(r.DecodeString())
}
- case "versions":
+ case "updatedAnnotations":
if r.TryDecodeAsNil() {
- x.Versions = nil
+ x.UpdatedAnnotations = nil
} else {
- yyv6 := &x.Versions
- yym7 := z.DecBinary()
- _ = yym7
+ yyv5 := &x.UpdatedAnnotations
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
} else {
- h.decSliceAPIVersion((*[]APIVersion)(yyv6), d)
+ z.F.DecMapStringStringX(yyv5, false, d)
}
}
+ case "rollbackTo":
+ if r.TryDecodeAsNil() {
+ x.RollbackTo = RollbackConfig{}
+ } else {
+ yyv7 := &x.RollbackTo
+ yyv7.CodecDecodeSelf(d)
+ }
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -4083,7 +4233,7 @@ func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DeploymentRollback) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4102,10 +4252,9 @@ func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.Name = ""
} else {
- yyv11 := &x.ObjectMeta
- yyv11.CodecDecodeSelf(d)
+ x.Name = string(r.DecodeString())
}
yyj10++
if yyhl10 {
@@ -4119,9 +4268,15 @@ func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Description = ""
+ x.UpdatedAnnotations = nil
} else {
- x.Description = string(r.DecodeString())
+ yyv12 := &x.UpdatedAnnotations
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecMapStringStringX(yyv12, false, d)
+ }
}
yyj10++
if yyhl10 {
@@ -4135,15 +4290,10 @@ func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Versions = nil
+ x.RollbackTo = RollbackConfig{}
} else {
- yyv13 := &x.Versions
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceAPIVersion((*[]APIVersion)(yyv13), d)
- }
+ yyv14 := &x.RollbackTo
+ yyv14.CodecDecodeSelf(d)
}
yyj10++
if yyhl10 {
@@ -4193,7 +4343,7 @@ func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -4207,17 +4357,15 @@ func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[0] = x.Revision != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(1)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -4229,106 +4377,25 @@ func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
+ yym4 := z.EncBinary()
+ _ = yym4
if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- z.EncFallback(yy4)
+ r.EncodeInt(int64(x.Revision))
}
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
- }
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("revision"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeInt(int64(x.Revision))
}
}
}
@@ -4341,7 +4408,7 @@ func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *RollbackConfig) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4371,7 +4438,7 @@ func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4393,42 +4460,11 @@ func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Deco
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
- }
- case "items":
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv6), d)
- }
- }
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "revision":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Revision = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Revision = int64(r.DecodeInt(64))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -4437,107 +4473,46 @@ func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Deco
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *RollbackConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv13), d)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb10 {
+ if yyb5 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Revision = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Revision = int64(r.DecodeInt(64))
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb10 {
+ if yyb5 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj5-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -4554,8 +4529,8 @@ func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Name != ""
- yyq2[1] = x.APIGroup != ""
+ yyq2[0] = x.Type != ""
+ yyq2[1] = x.RollingUpdate != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
@@ -4572,50 +4547,38 @@ func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
+ x.Type.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
+ x.Type.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ if x.RollingUpdate == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
+ x.RollingUpdate.CodecEncodeSelf(e)
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
+ r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
+ if x.RollingUpdate == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
+ x.RollingUpdate.CodecEncodeSelf(e)
}
}
}
@@ -4628,7 +4591,7 @@ func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4658,7 +4621,7 @@ func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4680,17 +4643,22 @@ func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "name":
+ case "type":
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Type = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Type = DeploymentStrategyType(r.DecodeString())
}
- case "apiGroup":
+ case "rollingUpdate":
if r.TryDecodeAsNil() {
- x.APIGroup = ""
+ if x.RollingUpdate != nil {
+ x.RollingUpdate = nil
+ }
} else {
- x.APIGroup = string(r.DecodeString())
+ if x.RollingUpdate == nil {
+ x.RollingUpdate = new(RollingUpdateDeployment)
+ }
+ x.RollingUpdate.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -4699,7 +4667,7 @@ func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4718,9 +4686,9 @@ func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ x.Type = ""
} else {
- x.Name = string(r.DecodeString())
+ x.Type = DeploymentStrategyType(r.DecodeString())
}
yyj6++
if yyhl6 {
@@ -4734,9 +4702,14 @@ func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIGroup = ""
+ if x.RollingUpdate != nil {
+ x.RollingUpdate = nil
+ }
} else {
- x.APIGroup = string(r.DecodeString())
+ if x.RollingUpdate == nil {
+ x.RollingUpdate = new(RollingUpdateDeployment)
+ }
+ x.RollingUpdate.CodecDecodeSelf(d)
}
for {
yyj6++
@@ -4754,7 +4727,33 @@ func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *DeploymentStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -4768,16 +4767,14 @@ func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = len(x.Data) != 0
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[1] = true
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(2)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -4791,32 +4788,48 @@ func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ yy4 := &x.MaxUnavailable
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy4)
+ } else {
+ z.EncFallback(yy4)
+ }
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ yy6 := &x.MaxUnavailable
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy6)
+ } else {
+ z.EncFallback(yy6)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.Data == nil {
- r.EncodeNil()
+ yy9 := &x.MaxSurge
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy9)
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
- }
+ z.EncFallback(yy9)
}
} else {
r.EncodeNil()
@@ -4824,67 +4837,17 @@ func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("data"))
+ r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Data == nil {
- r.EncodeNil()
+ yy11 := &x.MaxSurge
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy11) {
+ } else if !yym12 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy11)
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ z.EncFallback(yy11)
}
}
}
@@ -4897,7 +4860,7 @@ func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4927,7 +4890,7 @@ func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -4949,36 +4912,35 @@ func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Deco
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "data":
+ case "maxUnavailable":
if r.TryDecodeAsNil() {
- x.Data = nil
+ x.MaxUnavailable = pkg5_intstr.IntOrString{}
} else {
- yyv5 := &x.Data
- yym6 := z.DecBinary()
- _ = yym6
+ yyv4 := &x.MaxUnavailable
+ yym5 := z.DecBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4)
} else {
- *yyv5 = r.DecodeBytes(*(*[]byte)(yyv5), false, false)
+ z.DecFallback(yyv4, false)
}
}
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "maxSurge":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.MaxSurge = pkg5_intstr.IntOrString{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv6 := &x.MaxSurge
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -4987,101 +4949,80 @@ func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Deco
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb9 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.MaxUnavailable = pkg5_intstr.IntOrString{}
} else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
+ yyv9 := &x.MaxUnavailable
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv9)
+ } else {
+ z.DecFallback(yyv9, false)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb9 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Data = nil
+ x.MaxSurge = pkg5_intstr.IntOrString{}
} else {
- yyv11 := &x.Data
+ yyv11 := &x.MaxSurge
yym12 := z.DecBinary()
_ = yym12
if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else if !yym12 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv11)
} else {
- *yyv11 = r.DecodeBytes(*(*[]byte)(yyv11), false, false)
+ z.DecFallback(yyv11, false)
}
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb9 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -5098,11 +5039,11 @@ func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[0] = x.ObservedGeneration != 0
+ yyq2[1] = x.Replicas != 0
+ yyq2[2] = x.UpdatedReplicas != 0
+ yyq2[3] = x.AvailableReplicas != 0
+ yyq2[4] = x.UnavailableReplicas != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(5)
@@ -5119,101 +5060,125 @@ func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ObservedGeneration))
+ }
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ObservedGeneration))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.UpdatedReplicas))
+ }
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
+ r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeInt(int64(x.UpdatedReplicas))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ r.EncodeInt(int64(x.AvailableReplicas))
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeInt(0)
}
} else {
if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
+ yym14 := z.EncBinary()
+ _ = yym14
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ r.EncodeInt(int64(x.AvailableReplicas))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
+ yym16 := z.EncBinary()
+ _ = yym16
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeInt(int64(x.UnavailableReplicas))
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeInt(0)
}
} else {
if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
+ yym17 := z.EncBinary()
+ _ = yym17
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeInt(int64(x.UnavailableReplicas))
}
}
}
@@ -5226,7 +5191,7 @@ func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -5256,7 +5221,7 @@ func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -5278,38 +5243,35 @@ func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
+ case "observedGeneration":
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.ObservedGeneration = 0
} else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
+ x.ObservedGeneration = int64(r.DecodeInt(64))
}
- case "spec":
+ case "replicas":
if r.TryDecodeAsNil() {
- x.Spec = DeploymentSpec{}
+ x.Replicas = 0
} else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
+ x.Replicas = int32(r.DecodeInt(32))
}
- case "status":
+ case "updatedReplicas":
if r.TryDecodeAsNil() {
- x.Status = DeploymentStatus{}
+ x.UpdatedReplicas = 0
} else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
+ x.UpdatedReplicas = int32(r.DecodeInt(32))
}
- case "kind":
+ case "availableReplicas":
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.AvailableReplicas = 0
} else {
- x.Kind = string(r.DecodeString())
+ x.AvailableReplicas = int32(r.DecodeInt(32))
}
- case "apiVersion":
+ case "unavailableReplicas":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.UnavailableReplicas = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.UnavailableReplicas = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -5318,7 +5280,7 @@ func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -5337,10 +5299,9 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.ObservedGeneration = 0
} else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
+ x.ObservedGeneration = int64(r.DecodeInt(64))
}
yyj9++
if yyhl9 {
@@ -5354,10 +5315,9 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Spec = DeploymentSpec{}
+ x.Replicas = 0
} else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
+ x.Replicas = int32(r.DecodeInt(32))
}
yyj9++
if yyhl9 {
@@ -5371,10 +5331,9 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Status = DeploymentStatus{}
+ x.UpdatedReplicas = 0
} else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
+ x.UpdatedReplicas = int32(r.DecodeInt(32))
}
yyj9++
if yyhl9 {
@@ -5388,9 +5347,9 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.AvailableReplicas = 0
} else {
- x.Kind = string(r.DecodeString())
+ x.AvailableReplicas = int32(r.DecodeInt(32))
}
yyj9++
if yyhl9 {
@@ -5404,9 +5363,9 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.UnavailableReplicas = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.UnavailableReplicas = int32(r.DecodeInt(32))
}
for {
yyj9++
@@ -5424,7 +5383,7 @@ func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -5438,19 +5397,15 @@ func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [8]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Replicas != 0
- yyq2[1] = x.Selector != nil
- yyq2[3] = true
- yyq2[4] = x.MinReadySeconds != 0
- yyq2[5] = x.RevisionHistoryLimit != nil
- yyq2[6] = x.Paused != false
- yyq2[7] = x.RollbackTo != nil
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(8)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -5464,196 +5419,106 @@ func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- r.EncodeInt(int64(x.Replicas))
+ z.EncFallback(yy4)
}
} else {
- r.EncodeInt(0)
+ r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- r.EncodeInt(int64(x.Replicas))
+ z.EncFallback(yy6)
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.Selector == nil {
- r.EncodeNil()
- } else {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
- }
- } else {
+ if x.Items == nil {
r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("selector"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Selector == nil {
- r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
} else {
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
+ h.encSliceDeployment(([]Deployment)(x.Items), e)
}
}
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy10 := &x.Template
- yy10.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("template"))
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy12 := &x.Template
- yy12.CodecEncodeSelf(e)
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yy15 := &x.Strategy
- yy15.CodecEncodeSelf(e)
- } else {
+ if x.Items == nil {
r.EncodeNil()
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("strategy"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy17 := &x.Strategy
- yy17.CodecEncodeSelf(e)
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceDeployment(([]Deployment)(x.Items), e)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym20 := z.EncBinary()
- _ = yym20
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
if false {
} else {
- r.EncodeInt(int64(x.MinReadySeconds))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- r.EncodeInt(0)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[4] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym21 := z.EncBinary()
- _ = yym21
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
} else {
- r.EncodeInt(int64(x.MinReadySeconds))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[5] {
- if x.RevisionHistoryLimit == nil {
- r.EncodeNil()
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
} else {
- yy23 := *x.RevisionHistoryLimit
- yym24 := z.EncBinary()
- _ = yym24
- if false {
- } else {
- r.EncodeInt(int64(yy23))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[5] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.RevisionHistoryLimit == nil {
- r.EncodeNil()
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
} else {
- yy25 := *x.RevisionHistoryLimit
- yym26 := z.EncBinary()
- _ = yym26
- if false {
- } else {
- r.EncodeInt(int64(yy25))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[6] {
- yym28 := z.EncBinary()
- _ = yym28
- if false {
- } else {
- r.EncodeBool(bool(x.Paused))
- }
- } else {
- r.EncodeBool(false)
- }
- } else {
- if yyq2[6] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("paused"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym29 := z.EncBinary()
- _ = yym29
- if false {
- } else {
- r.EncodeBool(bool(x.Paused))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[7] {
- if x.RollbackTo == nil {
- r.EncodeNil()
- } else {
- x.RollbackTo.CodecEncodeSelf(e)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[7] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.RollbackTo == nil {
- r.EncodeNil()
- } else {
- x.RollbackTo.CodecEncodeSelf(e)
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -5666,7 +5531,7 @@ func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -5696,7 +5561,7 @@ func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -5718,81 +5583,42 @@ func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "replicas":
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "selector":
+ case "metadata":
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
- yym6 := z.DecBinary()
- _ = yym6
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
} else {
- z.DecFallback(x.Selector, false)
+ z.DecFallback(yyv4, false)
}
}
- case "template":
- if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
- } else {
- yyv7 := &x.Template
- yyv7.CodecDecodeSelf(d)
- }
- case "strategy":
- if r.TryDecodeAsNil() {
- x.Strategy = DeploymentStrategy{}
- } else {
- yyv8 := &x.Strategy
- yyv8.CodecDecodeSelf(d)
- }
- case "minReadySeconds":
- if r.TryDecodeAsNil() {
- x.MinReadySeconds = 0
- } else {
- x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "revisionHistoryLimit":
+ case "items":
if r.TryDecodeAsNil() {
- if x.RevisionHistoryLimit != nil {
- x.RevisionHistoryLimit = nil
- }
+ x.Items = nil
} else {
- if x.RevisionHistoryLimit == nil {
- x.RevisionHistoryLimit = new(int)
- }
- yym11 := z.DecBinary()
- _ = yym11
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
if false {
} else {
- *((*int)(x.RevisionHistoryLimit)) = int(r.DecodeInt(codecSelferBitsize1234))
+ h.decSliceDeployment((*[]Deployment)(yyv6), d)
}
}
- case "paused":
+ case "kind":
if r.TryDecodeAsNil() {
- x.Paused = false
+ x.Kind = ""
} else {
- x.Paused = bool(r.DecodeBool())
+ x.Kind = string(r.DecodeString())
}
- case "rollbackTo":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- if x.RollbackTo != nil {
- x.RollbackTo = nil
- }
+ x.APIVersion = ""
} else {
- if x.RollbackTo == nil {
- x.RollbackTo = new(RollbackConfig)
- }
- x.RollbackTo.CodecDecodeSelf(d)
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -5801,186 +5627,107 @@ func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj14 int
- var yyb14 bool
- var yyhl14 bool = l >= 0
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
- } else {
- yyb14 = r.CheckBreak()
- }
- if yyb14 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb14 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
- yym17 := z.DecBinary()
- _ = yym17
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
} else {
- z.DecFallback(x.Selector, false)
+ z.DecFallback(yyv11, false)
}
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb14 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
+ x.Items = nil
} else {
- yyv18 := &x.Template
- yyv18.CodecDecodeSelf(d)
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceDeployment((*[]Deployment)(yyv13), d)
+ }
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb14 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Strategy = DeploymentStrategy{}
+ x.Kind = ""
} else {
- yyv19 := &x.Strategy
- yyv19.CodecDecodeSelf(d)
+ x.Kind = string(r.DecodeString())
}
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb14 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb14 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.MinReadySeconds = 0
- } else {
- x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
+ x.APIVersion = ""
} else {
- yyb14 = r.CheckBreak()
- }
- if yyb14 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
+ x.APIVersion = string(r.DecodeString())
}
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.RevisionHistoryLimit != nil {
- x.RevisionHistoryLimit = nil
- }
- } else {
- if x.RevisionHistoryLimit == nil {
- x.RevisionHistoryLimit = new(int)
- }
- yym22 := z.DecBinary()
- _ = yym22
- if false {
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- *((*int)(x.RevisionHistoryLimit)) = int(r.DecodeInt(codecSelferBitsize1234))
+ yyb10 = r.CheckBreak()
}
- }
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
- } else {
- yyb14 = r.CheckBreak()
- }
- if yyb14 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Paused = false
- } else {
- x.Paused = bool(r.DecodeBool())
- }
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
- } else {
- yyb14 = r.CheckBreak()
- }
- if yyb14 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.RollbackTo != nil {
- x.RollbackTo = nil
- }
- } else {
- if x.RollbackTo == nil {
- x.RollbackTo = new(RollbackConfig)
- }
- x.RollbackTo.CodecDecodeSelf(d)
- }
- for {
- yyj14++
- if yyhl14 {
- yyb14 = yyj14 > l
- } else {
- yyb14 = r.CheckBreak()
- }
- if yyb14 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj14-1, "")
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -5994,17 +5741,15 @@ func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = len(x.UpdatedAnnotations) != 0
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[0] = x.Selector != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -6015,116 +5760,49 @@ func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.UpdatedAnnotations == nil {
+ if yyq2[0] {
+ if x.Selector == nil {
r.EncodeNil()
} else {
- yym7 := z.EncBinary()
- _ = yym7
+ yym4 := z.EncBinary()
+ _ = yym4
if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
} else {
- z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
+ z.EncFallback(x.Selector)
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.UpdatedAnnotations == nil {
+ if x.Selector == nil {
r.EncodeNil()
} else {
- yym8 := z.EncBinary()
- _ = yym8
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
} else {
- z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
+ z.EncFallback(x.Selector)
}
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy10 := &x.RollbackTo
- yy10.CodecEncodeSelf(e)
+ yy7 := &x.Template
+ yy7.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy12 := &x.RollbackTo
- yy12.CodecEncodeSelf(e)
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym18 := z.EncBinary()
- _ = yym18
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
+ yy9 := &x.Template
+ yy9.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -6135,7 +5813,7 @@ func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DeploymentRollback) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6165,7 +5843,7 @@ func (x *DeploymentRollback) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6187,42 +5865,29 @@ func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "name":
- if r.TryDecodeAsNil() {
- x.Name = ""
- } else {
- x.Name = string(r.DecodeString())
- }
- case "updatedAnnotations":
+ case "selector":
if r.TryDecodeAsNil() {
- x.UpdatedAnnotations = nil
+ if x.Selector != nil {
+ x.Selector = nil
+ }
} else {
- yyv5 := &x.UpdatedAnnotations
- yym6 := z.DecBinary()
- _ = yym6
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- z.F.DecMapStringStringX(yyv5, false, d)
+ z.DecFallback(x.Selector, false)
}
}
- case "rollbackTo":
- if r.TryDecodeAsNil() {
- x.RollbackTo = RollbackConfig{}
- } else {
- yyv7 := &x.RollbackTo
- yyv7.CodecDecodeSelf(d)
- }
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "template":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv6 := &x.Template
+ yyv6.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -6231,117 +5896,74 @@ func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DeploymentRollback) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Name = ""
+ if x.Selector != nil {
+ x.Selector = nil
+ }
} else {
- x.Name = string(r.DecodeString())
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.UpdatedAnnotations = nil
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- yyv12 := &x.UpdatedAnnotations
- yym13 := z.DecBinary()
- _ = yym13
- if false {
- } else {
- z.F.DecMapStringStringX(yyv12, false, d)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.RollbackTo = RollbackConfig{}
- } else {
- yyv14 := &x.RollbackTo
- yyv14.CodecDecodeSelf(d)
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
+ yyv10 := &x.Template
+ yyv10.CodecDecodeSelf(d)
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -6355,15 +5977,14 @@ func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Revision != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(3)
} else {
- yynn2 = 0
+ yynn2 = 3
for _, b := range yyq2 {
if b {
yynn2++
@@ -6374,27 +5995,59 @@ func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeInt(int64(x.Revision))
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeInt(0)
+ r.EncodeInt(int64(x.CurrentNumberScheduled))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("revision"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Revision))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentNumberScheduled))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NumberMisscheduled))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(x.NumberMisscheduled))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredNumberScheduled))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredNumberScheduled))
}
}
if yyr2 || yy2arr2 {
@@ -6406,7 +6059,7 @@ func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *RollbackConfig) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6436,7 +6089,7 @@ func (x *RollbackConfig) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6458,11 +6111,23 @@ func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "revision":
+ case "currentNumberScheduled":
if r.TryDecodeAsNil() {
- x.Revision = 0
+ x.CurrentNumberScheduled = 0
} else {
- x.Revision = int64(r.DecodeInt(64))
+ x.CurrentNumberScheduled = int32(r.DecodeInt(32))
+ }
+ case "numberMisscheduled":
+ if r.TryDecodeAsNil() {
+ x.NumberMisscheduled = 0
+ } else {
+ x.NumberMisscheduled = int32(r.DecodeInt(32))
+ }
+ case "desiredNumberScheduled":
+ if r.TryDecodeAsNil() {
+ x.DesiredNumberScheduled = 0
+ } else {
+ x.DesiredNumberScheduled = int32(r.DecodeInt(32))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -6471,46 +6136,78 @@ func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *RollbackConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Revision = 0
+ x.CurrentNumberScheduled = 0
} else {
- x.Revision = int64(r.DecodeInt(64))
+ x.CurrentNumberScheduled = int32(r.DecodeInt(32))
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.NumberMisscheduled = 0
+ } else {
+ x.NumberMisscheduled = int32(r.DecodeInt(32))
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DesiredNumberScheduled = 0
+ } else {
+ x.DesiredNumberScheduled = int32(r.DecodeInt(32))
}
for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb5 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -6524,14 +6221,17 @@ func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Type != ""
- yyq2[1] = x.RollingUpdate != nil
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(5)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -6545,38 +6245,101 @@ func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- x.Type.CodecEncodeSelf(e)
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("type"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- x.Type.CodecEncodeSelf(e)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.RollingUpdate == nil {
- r.EncodeNil()
- } else {
- x.RollingUpdate.CodecEncodeSelf(e)
- }
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.RollingUpdate == nil {
- r.EncodeNil()
- } else {
- x.RollingUpdate.CodecEncodeSelf(e)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -6589,7 +6352,7 @@ func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6619,7 +6382,7 @@ func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6641,22 +6404,38 @@ func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "type":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Type = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Type = DeploymentStrategyType(r.DecodeString())
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "rollingUpdate":
+ case "spec":
if r.TryDecodeAsNil() {
- if x.RollingUpdate != nil {
- x.RollingUpdate = nil
- }
+ x.Spec = DaemonSetSpec{}
} else {
- if x.RollingUpdate == nil {
- x.RollingUpdate = new(RollingUpdateDeployment)
- }
- x.RollingUpdate.CodecDecodeSelf(d)
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = DaemonSetStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -6665,93 +6444,113 @@ func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb6 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Type = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Type = DeploymentStrategyType(r.DecodeString())
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb6 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.RollingUpdate != nil {
- x.RollingUpdate = nil
- }
+ x.Spec = DaemonSetSpec{}
} else {
- if x.RollingUpdate == nil {
- x.RollingUpdate = new(RollingUpdateDeployment)
- }
- x.RollingUpdate.CodecDecodeSelf(d)
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = DaemonSetStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb6 {
+ if yyb9 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj9-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x))
- }
-}
-
-func (x *DeploymentStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- *((*string)(x)) = r.DecodeString()
- }
-}
-
-func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -6765,16 +6564,17 @@ func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -6786,13 +6586,11 @@ func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.MaxUnavailable
+ yy4 := &x.ListMeta
yym5 := z.EncBinary()
_ = yym5
if false {
} else if z.HasExtensions() && z.EncExt(yy4) {
- } else if !yym5 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy4)
} else {
z.EncFallback(yy4)
}
@@ -6802,15 +6600,13 @@ func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.MaxUnavailable
+ yy6 := &x.ListMeta
yym7 := z.EncBinary()
_ = yym7
if false {
} else if z.HasExtensions() && z.EncExt(yy6) {
- } else if !yym7 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy6)
} else {
z.EncFallback(yy6)
}
@@ -6818,34 +6614,78 @@ func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.MaxSurge
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
yym10 := z.EncBinary()
_ = yym10
if false {
- } else if z.HasExtensions() && z.EncExt(yy9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy9)
} else {
- z.EncFallback(yy9)
+ h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[1] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.MaxSurge
- yym12 := z.EncBinary()
- _ = yym12
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
- } else if z.HasExtensions() && z.EncExt(yy11) {
- } else if !yym12 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy11)
} else {
- z.EncFallback(yy11)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -6858,7 +6698,7 @@ func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6888,7 +6728,7 @@ func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -6910,36 +6750,43 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Dec
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "maxUnavailable":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.MaxUnavailable = pkg6_intstr.IntOrString{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv4 := &x.MaxUnavailable
+ yyv4 := &x.ListMeta
yym5 := z.DecBinary()
_ = yym5
if false {
} else if z.HasExtensions() && z.DecExt(yyv4) {
- } else if !yym5 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4)
} else {
z.DecFallback(yyv4, false)
}
}
- case "maxSurge":
+ case "items":
if r.TryDecodeAsNil() {
- x.MaxSurge = pkg6_intstr.IntOrString{}
+ x.Items = nil
} else {
- yyv6 := &x.MaxSurge
+ yyv6 := &x.Items
yym7 := z.DecBinary()
_ = yym7
if false {
- } else if z.HasExtensions() && z.DecExt(yyv6) {
- } else if !yym7 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv6)
} else {
- z.DecFallback(yyv6, false)
+ h.decSliceDaemonSet((*[]DaemonSet)(yyv6), d)
}
}
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -6947,80 +6794,107 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Dec
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.MaxUnavailable = pkg6_intstr.IntOrString{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv9 := &x.MaxUnavailable
- yym10 := z.DecBinary()
- _ = yym10
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
if false {
- } else if z.HasExtensions() && z.DecExt(yyv9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv9)
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
} else {
- z.DecFallback(yyv9, false)
+ z.DecFallback(yyv11, false)
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.MaxSurge = pkg6_intstr.IntOrString{}
+ x.Items = nil
} else {
- yyv11 := &x.MaxSurge
- yym12 := z.DecBinary()
- _ = yym12
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else if !yym12 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv11)
} else {
- z.DecFallback(yyv11, false)
+ h.decSliceDaemonSet((*[]DaemonSet)(yyv13), d)
}
}
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -7034,19 +6908,17 @@ func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.ObservedGeneration != 0
- yyq2[1] = x.Replicas != 0
- yyq2[2] = x.UpdatedReplicas != 0
- yyq2[3] = x.AvailableReplicas != 0
- yyq2[4] = x.UnavailableReplicas != 0
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -7058,125 +6930,106 @@ func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- r.EncodeInt(int64(x.ObservedGeneration))
+ z.EncFallback(yy4)
}
} else {
- r.EncodeInt(0)
+ r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- r.EncodeInt(int64(x.ObservedGeneration))
+ z.EncFallback(yy6)
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
if false {
} else {
- r.EncodeInt(int64(x.Replicas))
+ h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
}
- } else {
- r.EncodeInt(0)
}
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
if false {
} else {
- r.EncodeInt(int64(x.Replicas))
+ h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yym10 := z.EncBinary()
- _ = yym10
+ yym12 := z.EncBinary()
+ _ = yym12
if false {
} else {
- r.EncodeInt(int64(x.UpdatedReplicas))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- r.EncodeInt(0)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym11 := z.EncBinary()
- _ = yym11
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
} else {
- r.EncodeInt(int64(x.UpdatedReplicas))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[3] {
- yym13 := z.EncBinary()
- _ = yym13
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
- r.EncodeInt(int64(x.AvailableReplicas))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
- r.EncodeInt(0)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeInt(int64(x.AvailableReplicas))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
yym16 := z.EncBinary()
_ = yym16
if false {
} else {
- r.EncodeInt(int64(x.UnavailableReplicas))
- }
- } else {
- r.EncodeInt(0)
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- r.EncodeInt(int64(x.UnavailableReplicas))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -7189,7 +7042,7 @@ func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7219,7 +7072,7 @@ func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7241,35 +7094,42 @@ func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "observedGeneration":
- if r.TryDecodeAsNil() {
- x.ObservedGeneration = 0
- } else {
- x.ObservedGeneration = int64(r.DecodeInt(64))
- }
- case "replicas":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Replicas = 0
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
}
- case "updatedReplicas":
+ case "items":
if r.TryDecodeAsNil() {
- x.UpdatedReplicas = 0
+ x.Items = nil
} else {
- x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv6), d)
+ }
}
- case "availableReplicas":
+ case "kind":
if r.TryDecodeAsNil() {
- x.AvailableReplicas = 0
+ x.Kind = ""
} else {
- x.AvailableReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Kind = string(r.DecodeString())
}
- case "unavailableReplicas":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- x.UnavailableReplicas = 0
+ x.APIVersion = ""
} else {
- x.UnavailableReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -7278,110 +7138,107 @@ func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ObservedGeneration = 0
- } else {
- x.ObservedGeneration = int64(r.DecodeInt(64))
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Replicas = 0
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.UpdatedReplicas = 0
+ x.Items = nil
} else {
- x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv13), d)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.AvailableReplicas = 0
+ x.Kind = ""
} else {
- x.AvailableReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Kind = string(r.DecodeString())
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.UnavailableReplicas = 0
+ x.APIVersion = ""
} else {
- x.UnavailableReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -7395,17 +7252,19 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(5)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -7417,14 +7276,8 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
- } else {
- z.EncFallback(yy4)
- }
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
@@ -7433,48 +7286,49 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceDeployment(([]Deployment)(x.Items), e)
- }
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceDeployment(([]Deployment)(x.Items), e)
- }
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -7483,12 +7337,12 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
+ yym20 := z.EncBinary()
+ _ = yym20
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -7497,9 +7351,9 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -7508,12 +7362,12 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[3] {
+ if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
+ yym23 := z.EncBinary()
+ _ = yym23
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -7529,7 +7383,7 @@ func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7559,7 +7413,7 @@ func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7583,28 +7437,24 @@ func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
switch yys3 {
case "metadata":
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "items":
+ case "spec":
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Spec = IngressSpec{}
} else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- h.decSliceDeployment((*[]Deployment)(yyv6), d)
- }
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = IngressStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
}
case "kind":
if r.TryDecodeAsNil() {
@@ -7625,65 +7475,71 @@ func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb10 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb10 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Spec = IngressSpec{}
} else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceDeployment((*[]Deployment)(yyv13), d)
- }
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb10 {
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = IngressStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7693,13 +7549,13 @@ func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb10 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -7710,22 +7566,22 @@ func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.APIVersion = string(r.DecodeString())
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb10 {
+ if yyb9 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj9-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -7739,13 +7595,15 @@ func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Selector != nil
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -7759,16 +7617,13 @@ func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- if x.Selector == nil {
- r.EncodeNil()
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
+ z.EncFallback(yy4)
}
} else {
r.EncodeNil()
@@ -7776,31 +7631,94 @@ func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Selector == nil {
- r.EncodeNil()
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
+ z.EncFallback(yy6)
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.Template
- yy7.CodecEncodeSelf(e)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceIngress(([]Ingress)(x.Items), e)
+ }
+ }
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("template"))
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.Template
- yy9.CodecEncodeSelf(e)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceIngress(([]Ingress)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -7811,7 +7729,7 @@ func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7841,7 +7759,7 @@ func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -7863,29 +7781,42 @@ func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "selector":
+ case "metadata":
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
+ yyv4 := &x.ListMeta
yym5 := z.DecBinary()
_ = yym5
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
} else {
- z.DecFallback(x.Selector, false)
+ z.DecFallback(yyv4, false)
}
}
- case "template":
+ case "items":
if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
+ x.Items = nil
} else {
- yyv6 := &x.Template
- yyv6.CodecDecodeSelf(d)
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceIngress((*[]Ingress)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -7894,74 +7825,107 @@ func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
}
- yym9 := z.DecBinary()
- _ = yym9
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- z.DecFallback(x.Selector, false)
+ h.decSliceIngress((*[]Ingress)(yyv13), d)
}
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
+ x.Kind = ""
} else {
- yyv10 := &x.Template
- yyv10.CodecDecodeSelf(d)
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb7 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -7978,11 +7942,14 @@ func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = x.Backend != nil
+ yyq2[1] = len(x.TLS) != 0
+ yyq2[2] = len(x.Rules) != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(3)
} else {
- yynn2 = 3
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -7993,59 +7960,91 @@ func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ if x.Backend == nil {
+ r.EncodeNil()
+ } else {
+ x.Backend.CodecEncodeSelf(e)
+ }
} else {
- r.EncodeInt(int64(x.CurrentNumberScheduled))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.CurrentNumberScheduled))
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("backend"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Backend == nil {
+ r.EncodeNil()
+ } else {
+ x.Backend.CodecEncodeSelf(e)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ if yyq2[1] {
+ if x.TLS == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
+ }
+ }
} else {
- r.EncodeInt(int64(x.NumberMisscheduled))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeInt(int64(x.NumberMisscheduled))
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("tls"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.TLS == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym10 := z.EncBinary()
- _ = yym10
- if false {
+ if yyq2[2] {
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
+ }
+ }
} else {
- r.EncodeInt(int64(x.DesiredNumberScheduled))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else {
- r.EncodeInt(int64(x.DesiredNumberScheduled))
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rules"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
@@ -8057,7 +8056,7 @@ func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8087,7 +8086,7 @@ func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8109,23 +8108,40 @@ func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "currentNumberScheduled":
+ case "backend":
if r.TryDecodeAsNil() {
- x.CurrentNumberScheduled = 0
+ if x.Backend != nil {
+ x.Backend = nil
+ }
} else {
- x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ if x.Backend == nil {
+ x.Backend = new(IngressBackend)
+ }
+ x.Backend.CodecDecodeSelf(d)
}
- case "numberMisscheduled":
+ case "tls":
if r.TryDecodeAsNil() {
- x.NumberMisscheduled = 0
+ x.TLS = nil
} else {
- x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv5 := &x.TLS
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceIngressTLS((*[]IngressTLS)(yyv5), d)
+ }
}
- case "desiredNumberScheduled":
+ case "rules":
if r.TryDecodeAsNil() {
- x.DesiredNumberScheduled = 0
+ x.Rules = nil
} else {
- x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv7 := &x.Rules
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.decSliceIngressRule((*[]IngressRule)(yyv7), d)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -8134,78 +8150,95 @@ func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb7 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.CurrentNumberScheduled = 0
+ if x.Backend != nil {
+ x.Backend = nil
+ }
} else {
- x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ if x.Backend == nil {
+ x.Backend = new(IngressBackend)
+ }
+ x.Backend.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb7 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.NumberMisscheduled = 0
+ x.TLS = nil
} else {
- x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv11 := &x.TLS
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceIngressTLS((*[]IngressTLS)(yyv11), d)
+ }
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb7 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.DesiredNumberScheduled = 0
+ x.Rules = nil
} else {
- x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv13 := &x.Rules
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceIngressRule((*[]IngressRule)(yyv13), d)
+ }
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb7 {
+ if yyb9 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj9-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -8219,17 +8252,14 @@ func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[0] = len(x.Hosts) != 0
+ yyq2[1] = x.SecretName != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(2)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -8243,101 +8273,58 @@ func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ if x.Hosts == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Hosts, false, e)
+ }
+ }
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("hosts"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ if x.Hosts == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Hosts, false, e)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
+ yym7 := z.EncBinary()
+ _ = yym7
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[3] {
+ if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ r.EncodeString(codecSelferC_UTF81234, string("secretName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
+ yym8 := z.EncBinary()
+ _ = yym8
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
}
}
}
@@ -8350,7 +8337,7 @@ func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressTLS) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8380,7 +8367,7 @@ func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8402,38 +8389,23 @@ func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "spec":
- if r.TryDecodeAsNil() {
- x.Spec = DaemonSetSpec{}
- } else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
- }
- case "status":
- if r.TryDecodeAsNil() {
- x.Status = DaemonSetStatus{}
- } else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
- }
- case "kind":
+ case "hosts":
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Hosts = nil
} else {
- x.Kind = string(r.DecodeString())
+ yyv4 := &x.Hosts
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv4, false, d)
+ }
}
- case "apiVersion":
+ case "secretName":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.SecretName = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.SecretName = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -8442,113 +8414,68 @@ func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressTLS) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Spec = DaemonSetSpec{}
- } else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Status = DaemonSetStatus{}
- } else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Hosts = nil
} else {
- x.Kind = string(r.DecodeString())
+ yyv8 := &x.Hosts
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv8, false, d)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.SecretName = ""
} else {
- x.APIVersion = string(r.DecodeString())
+ x.SecretName = string(r.DecodeString())
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -8562,17 +8489,15 @@ func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(1)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -8584,119 +8509,30 @@ func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
- } else {
- z.EncFallback(yy4)
- }
+ yy4 := &x.LoadBalancer
+ yy4.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
+ yy6 := &x.LoadBalancer
+ yy6.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
- }
- }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
}
}
}
}
-func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8726,7 +8562,7 @@ func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -8748,42 +8584,12 @@ func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
- }
- case "items":
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- h.decSliceDaemonSet((*[]DaemonSet)(yyv6), d)
- }
- }
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "loadBalancer":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv4 := &x.LoadBalancer
+ yyv4.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -8792,107 +8598,47 @@ func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceDaemonSet((*[]DaemonSet)(yyv13), d)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb10 {
+ if yyb5 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv6 := &x.LoadBalancer
+ yyv6.CodecDecodeSelf(d)
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb10 {
+ if yyb5 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj5-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -8906,17 +8652,16 @@ func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[0] = x.Host != ""
+ yyq2[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -8928,111 +8673,67 @@ func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
+ yym4 := z.EncBinary()
+ _ = yym4
if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- z.EncFallback(yy4)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Host))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("host"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- z.EncFallback(yy6)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Host))
}
}
}
+ var yyn6 bool
+ if x.IngressRuleValue.HTTP == nil {
+ yyn6 = true
+ goto LABEL6
+ }
+ LABEL6:
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
+ if yyn6 {
r.EncodeNil()
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.HTTP == nil {
+ r.EncodeNil()
+ } else {
+ x.HTTP.CodecEncodeSelf(e)
+ }
} else {
- h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
+ r.EncodeNil()
}
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("http"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyn6 {
+ r.EncodeNil()
} else {
- h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
+ if x.HTTP == nil {
+ r.EncodeNil()
+ } else {
+ x.HTTP.CodecEncodeSelf(e)
+ }
}
}
}
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -9040,7 +8741,7 @@ func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -9070,7 +8771,7 @@ func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -9092,42 +8793,25 @@ func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
- }
- case "items":
+ case "host":
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Host = ""
} else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv6), d)
- }
+ x.Host = string(r.DecodeString())
}
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
+ case "http":
+ if x.IngressRuleValue.HTTP == nil {
+ x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
}
- case "apiVersion":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ if x.HTTP != nil {
+ x.HTTP = nil
+ }
} else {
- x.APIVersion = string(r.DecodeString())
+ if x.HTTP == nil {
+ x.HTTP = new(HTTPIngressRuleValue)
+ }
+ x.HTTP.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -9136,107 +8820,70 @@ func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv13), d)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ x.Host = ""
} else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
+ x.Host = string(r.DecodeString())
}
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
+ if x.IngressRuleValue.HTTP == nil {
+ x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ if x.HTTP != nil {
+ x.HTTP = nil
+ }
} else {
- x.APIVersion = string(r.DecodeString())
+ if x.HTTP == nil {
+ x.HTTP = new(HTTPIngressRuleValue)
+ }
+ x.HTTP.CodecDecodeSelf(d)
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -9250,17 +8897,13 @@ func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[0] = x.HTTP != nil
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(1)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -9274,127 +8917,49 @@ func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ if x.HTTP == nil {
+ r.EncodeNil()
+ } else {
+ x.HTTP.CodecEncodeSelf(e)
+ }
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ r.EncodeString(codecSelferC_UTF81234, string("http"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ if x.HTTP == nil {
+ r.EncodeNil()
+ } else {
+ x.HTTP.CodecEncodeSelf(e)
+ }
}
}
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
- }
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
}
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
- }
- }
-}
-
-func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+}
+
+func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
x.codecDecodeSelfFromMap(yyl2, d)
}
@@ -9411,7 +8976,7 @@ func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -9433,38 +8998,16 @@ func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "spec":
- if r.TryDecodeAsNil() {
- x.Spec = JobSpec{}
- } else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
- }
- case "status":
- if r.TryDecodeAsNil() {
- x.Status = JobStatus{}
- } else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
- }
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "http":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ if x.HTTP != nil {
+ x.HTTP = nil
+ }
} else {
- x.APIVersion = string(r.DecodeString())
+ if x.HTTP == nil {
+ x.HTTP = new(HTTPIngressRuleValue)
+ }
+ x.HTTP.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -9473,113 +9016,51 @@ func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Spec = JobSpec{}
- } else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Status = JobStatus{}
- } else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb9 {
+ if yyb5 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ if x.HTTP != nil {
+ x.HTTP = nil
+ }
} else {
- x.APIVersion = string(r.DecodeString())
+ if x.HTTP == nil {
+ x.HTTP = new(HTTPIngressRuleValue)
+ }
+ x.HTTP.CodecDecodeSelf(d)
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb9 {
+ if yyb5 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj5-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -9593,15 +9074,12 @@ func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(1)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -9614,112 +9092,33 @@ func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ListMeta
+ if x.Paths == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("paths"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Paths == nil {
+ r.EncodeNil()
+ } else {
yym5 := z.EncBinary()
_ = yym5
if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- z.EncFallback(yy4)
+ h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
}
- } else {
- r.EncodeNil()
}
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceJob(([]Job)(x.Items), e)
- }
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceJob(([]Job)(x.Items), e)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -9727,7 +9126,7 @@ func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -9757,7 +9156,7 @@ func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *HTTPIngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -9779,43 +9178,18 @@ func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
+ case "paths":
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Paths = nil
} else {
- yyv4 := &x.ListMeta
+ yyv4 := &x.Paths
yym5 := z.DecBinary()
_ = yym5
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
- }
- case "items":
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
} else {
- h.decSliceJob((*[]Job)(yyv6), d)
+ h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv4), d)
}
}
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -9823,107 +9197,52 @@ func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Paths = nil
} else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
+ yyv7 := &x.Paths
+ yym8 := z.DecBinary()
+ _ = yym8
if false {
} else {
- h.decSliceJob((*[]Job)(yyv13), d)
+ h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv7), d)
}
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -9937,17 +9256,13 @@ func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [6]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Parallelism != nil
- yyq2[1] = x.Completions != nil
- yyq2[2] = x.ActiveDeadlineSeconds != nil
- yyq2[3] = x.Selector != nil
- yyq2[4] = x.ManualSelector != nil
+ yyq2[0] = x.Path != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(6)
+ r.EncodeArrayStart(2)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -9961,188 +9276,38 @@ func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- if x.Parallelism == nil {
- r.EncodeNil()
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- yy4 := *x.Parallelism
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(yy4))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
+ r.EncodeString(codecSelferC_UTF81234, string("path"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Parallelism == nil {
- r.EncodeNil()
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- yy6 := *x.Parallelism
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeInt(int64(yy6))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.Completions == nil {
- r.EncodeNil()
- } else {
- yy9 := *x.Completions
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- r.EncodeInt(int64(yy9))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("completions"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Completions == nil {
- r.EncodeNil()
- } else {
- yy11 := *x.Completions
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeInt(int64(yy11))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- if x.ActiveDeadlineSeconds == nil {
- r.EncodeNil()
- } else {
- yy14 := *x.ActiveDeadlineSeconds
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeInt(int64(yy14))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.ActiveDeadlineSeconds == nil {
- r.EncodeNil()
- } else {
- yy16 := *x.ActiveDeadlineSeconds
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- r.EncodeInt(int64(yy16))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- if x.Selector == nil {
- r.EncodeNil()
- } else {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("selector"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Selector == nil {
- r.EncodeNil()
- } else {
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
- } else {
- z.EncFallback(x.Selector)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- if x.ManualSelector == nil {
- r.EncodeNil()
- } else {
- yy22 := *x.ManualSelector
- yym23 := z.EncBinary()
- _ = yym23
- if false {
- } else {
- r.EncodeBool(bool(yy22))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("manualSelector"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.ManualSelector == nil {
- r.EncodeNil()
- } else {
- yy24 := *x.ManualSelector
- yym25 := z.EncBinary()
- _ = yym25
- if false {
- } else {
- r.EncodeBool(bool(yy24))
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy27 := &x.Template
- yy27.CodecEncodeSelf(e)
+ yy7 := &x.Backend
+ yy7.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("template"))
+ r.EncodeString(codecSelferC_UTF81234, string("backend"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy29 := &x.Template
- yy29.CodecEncodeSelf(e)
+ yy9 := &x.Backend
+ yy9.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -10153,7 +9318,7 @@ func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -10183,7 +9348,7 @@ func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -10205,93 +9370,18 @@ func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "parallelism":
- if r.TryDecodeAsNil() {
- if x.Parallelism != nil {
- x.Parallelism = nil
- }
- } else {
- if x.Parallelism == nil {
- x.Parallelism = new(int)
- }
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- *((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
- }
- case "completions":
- if r.TryDecodeAsNil() {
- if x.Completions != nil {
- x.Completions = nil
- }
- } else {
- if x.Completions == nil {
- x.Completions = new(int)
- }
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- *((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
- }
- case "activeDeadlineSeconds":
- if r.TryDecodeAsNil() {
- if x.ActiveDeadlineSeconds != nil {
- x.ActiveDeadlineSeconds = nil
- }
- } else {
- if x.ActiveDeadlineSeconds == nil {
- x.ActiveDeadlineSeconds = new(int64)
- }
- yym9 := z.DecBinary()
- _ = yym9
- if false {
- } else {
- *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
- }
- }
- case "selector":
- if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
- } else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
- yym11 := z.DecBinary()
- _ = yym11
- if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
- } else {
- z.DecFallback(x.Selector, false)
- }
- }
- case "manualSelector":
+ case "path":
if r.TryDecodeAsNil() {
- if x.ManualSelector != nil {
- x.ManualSelector = nil
- }
+ x.Path = ""
} else {
- if x.ManualSelector == nil {
- x.ManualSelector = new(bool)
- }
- yym13 := z.DecBinary()
- _ = yym13
- if false {
- } else {
- *((*bool)(x.ManualSelector)) = r.DecodeBool()
- }
+ x.Path = string(r.DecodeString())
}
- case "template":
+ case "backend":
if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
+ x.Backend = IngressBackend{}
} else {
- yyv14 := &x.Template
- yyv14.CodecDecodeSelf(d)
+ yyv5 := &x.Backend
+ yyv5.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -10300,205 +9390,84 @@ func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj15 int
- var yyb15 bool
- var yyhl15 bool = l >= 0
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb15 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Parallelism != nil {
- x.Parallelism = nil
- }
+ x.Path = ""
} else {
- if x.Parallelism == nil {
- x.Parallelism = new(int)
- }
- yym17 := z.DecBinary()
- _ = yym17
- if false {
- } else {
- *((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
+ x.Path = string(r.DecodeString())
}
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb15 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb15 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Completions != nil {
- x.Completions = nil
- }
- } else {
- if x.Completions == nil {
- x.Completions = new(int)
- }
- yym19 := z.DecBinary()
- _ = yym19
- if false {
- } else {
- *((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
- }
- }
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
+ x.Backend = IngressBackend{}
} else {
- yyb15 = r.CheckBreak()
- }
- if yyb15 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
+ yyv8 := &x.Backend
+ yyv8.CodecDecodeSelf(d)
}
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.ActiveDeadlineSeconds != nil {
- x.ActiveDeadlineSeconds = nil
- }
- } else {
- if x.ActiveDeadlineSeconds == nil {
- x.ActiveDeadlineSeconds = new(int64)
- }
- yym21 := z.DecBinary()
- _ = yym21
- if false {
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- *((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
+ yyb6 = r.CheckBreak()
}
- }
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
- } else {
- yyb15 = r.CheckBreak()
- }
- if yyb15 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
+ if yyb6 {
+ break
}
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
- yym23 := z.DecBinary()
- _ = yym23
+ yym1 := z.EncBinary()
+ _ = yym1
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
- } else {
- z.DecFallback(x.Selector, false)
- }
- }
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
- } else {
- yyb15 = r.CheckBreak()
- }
- if yyb15 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.ManualSelector != nil {
- x.ManualSelector = nil
- }
- } else {
- if x.ManualSelector == nil {
- x.ManualSelector = new(bool)
- }
- yym25 := z.DecBinary()
- _ = yym25
- if false {
- } else {
- *((*bool)(x.ManualSelector)) = r.DecodeBool()
- }
- }
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
- } else {
- yyb15 = r.CheckBreak()
- }
- if yyb15 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
- } else {
- yyv26 := &x.Template
- yyv26.CodecDecodeSelf(d)
- }
- for {
- yyj15++
- if yyhl15 {
- yyb15 = yyj15 > l
- } else {
- yyb15 = r.CheckBreak()
- }
- if yyb15 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj15-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
+ } else if z.HasExtensions() && z.EncExt(x) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [6]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = len(x.Conditions) != 0
- yyq2[1] = x.StartTime != nil
- yyq2[2] = x.CompletionTime != nil
- yyq2[3] = x.Active != 0
- yyq2[4] = x.Succeeded != 0
- yyq2[5] = x.Failed != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(6)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 0
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -10509,196 +9478,48 @@ func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- if x.Conditions == nil {
- r.EncodeNil()
- } else {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("conditions"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Conditions == nil {
- r.EncodeNil()
- } else {
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.StartTime == nil {
- r.EncodeNil()
- } else {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(x.StartTime) {
- } else if yym7 {
- z.EncBinaryMarshal(x.StartTime)
- } else if !yym7 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.StartTime)
- } else {
- z.EncFallback(x.StartTime)
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("startTime"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.StartTime == nil {
- r.EncodeNil()
- } else {
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else if z.HasExtensions() && z.EncExt(x.StartTime) {
- } else if yym8 {
- z.EncBinaryMarshal(x.StartTime)
- } else if !yym8 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.StartTime)
- } else {
- z.EncFallback(x.StartTime)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- if x.CompletionTime == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
- } else if yym10 {
- z.EncBinaryMarshal(x.CompletionTime)
- } else if !yym10 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.CompletionTime)
- } else {
- z.EncFallback(x.CompletionTime)
- }
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
}
} else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.CompletionTime == nil {
- r.EncodeNil()
- } else {
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
- } else if yym11 {
- z.EncBinaryMarshal(x.CompletionTime)
- } else if !yym11 && z.IsJSONHandle() {
- z.EncJSONMarshal(x.CompletionTime)
- } else {
- z.EncFallback(x.CompletionTime)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeInt(int64(x.Active))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- r.EncodeInt(0)
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("active"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
- } else {
- r.EncodeInt(int64(x.Active))
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeInt(int64(x.Succeeded))
- }
+ yy7 := &x.ServicePort
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy7) {
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy7)
} else {
- r.EncodeInt(0)
+ z.EncFallback(yy7)
}
} else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- r.EncodeInt(int64(x.Succeeded))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[5] {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeInt(int64(x.Failed))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.ServicePort
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy9)
} else {
- r.EncodeInt(0)
- }
- } else {
- if yyq2[5] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("failed"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeInt(int64(x.Failed))
- }
+ z.EncFallback(yy9)
}
}
if yyr2 || yy2arr2 {
@@ -10710,7 +9531,7 @@ func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -10740,7 +9561,7 @@ func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -10762,78 +9583,27 @@ func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "conditions":
- if r.TryDecodeAsNil() {
- x.Conditions = nil
- } else {
- yyv4 := &x.Conditions
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- h.decSliceJobCondition((*[]JobCondition)(yyv4), d)
- }
- }
- case "startTime":
+ case "serviceName":
if r.TryDecodeAsNil() {
- if x.StartTime != nil {
- x.StartTime = nil
- }
+ x.ServiceName = ""
} else {
- if x.StartTime == nil {
- x.StartTime = new(pkg1_unversioned.Time)
- }
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.DecExt(x.StartTime) {
- } else if yym7 {
- z.DecBinaryUnmarshal(x.StartTime)
- } else if !yym7 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.StartTime)
- } else {
- z.DecFallback(x.StartTime, false)
- }
+ x.ServiceName = string(r.DecodeString())
}
- case "completionTime":
+ case "servicePort":
if r.TryDecodeAsNil() {
- if x.CompletionTime != nil {
- x.CompletionTime = nil
- }
+ x.ServicePort = pkg5_intstr.IntOrString{}
} else {
- if x.CompletionTime == nil {
- x.CompletionTime = new(pkg1_unversioned.Time)
- }
- yym9 := z.DecBinary()
- _ = yym9
+ yyv5 := &x.ServicePort
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
- } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
- } else if yym9 {
- z.DecBinaryUnmarshal(x.CompletionTime)
- } else if !yym9 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.CompletionTime)
+ } else if z.HasExtensions() && z.DecExt(yyv5) {
+ } else if !yym6 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv5)
} else {
- z.DecFallback(x.CompletionTime, false)
+ z.DecFallback(yyv5, false)
}
}
- case "active":
- if r.TryDecodeAsNil() {
- x.Active = 0
- } else {
- x.Active = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "succeeded":
- if r.TryDecodeAsNil() {
- x.Succeeded = 0
- } else {
- x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "failed":
- if r.TryDecodeAsNil() {
- x.Failed = 0
- } else {
- x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
- }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -10841,188 +9611,71 @@ func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj13 int
- var yyb13 bool
- var yyhl13 bool = l >= 0
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb13 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb13 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Conditions = nil
+ x.ServiceName = ""
} else {
- yyv14 := &x.Conditions
- yym15 := z.DecBinary()
- _ = yym15
- if false {
- } else {
- h.decSliceJobCondition((*[]JobCondition)(yyv14), d)
- }
- }
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
- } else {
- yyb13 = r.CheckBreak()
- }
- if yyb13 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.StartTime != nil {
- x.StartTime = nil
- }
- } else {
- if x.StartTime == nil {
- x.StartTime = new(pkg1_unversioned.Time)
- }
- yym17 := z.DecBinary()
- _ = yym17
- if false {
- } else if z.HasExtensions() && z.DecExt(x.StartTime) {
- } else if yym17 {
- z.DecBinaryUnmarshal(x.StartTime)
- } else if !yym17 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.StartTime)
- } else {
- z.DecFallback(x.StartTime, false)
- }
+ x.ServiceName = string(r.DecodeString())
}
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb13 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb13 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.CompletionTime != nil {
- x.CompletionTime = nil
- }
+ x.ServicePort = pkg5_intstr.IntOrString{}
} else {
- if x.CompletionTime == nil {
- x.CompletionTime = new(pkg1_unversioned.Time)
- }
- yym19 := z.DecBinary()
- _ = yym19
+ yyv9 := &x.ServicePort
+ yym10 := z.DecBinary()
+ _ = yym10
if false {
- } else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
- } else if yym19 {
- z.DecBinaryUnmarshal(x.CompletionTime)
- } else if !yym19 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(x.CompletionTime)
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv9)
} else {
- z.DecFallback(x.CompletionTime, false)
+ z.DecFallback(yyv9, false)
}
}
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
- } else {
- yyb13 = r.CheckBreak()
- }
- if yyb13 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Active = 0
- } else {
- x.Active = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
- } else {
- yyb13 = r.CheckBreak()
- }
- if yyb13 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Succeeded = 0
- } else {
- x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
- } else {
- yyb13 = r.CheckBreak()
- }
- if yyb13 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Failed = 0
- } else {
- x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
- }
for {
- yyj13++
- if yyhl13 {
- yyb13 = yyj13 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb13 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb13 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj13-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x))
- }
-}
-
-func (x *JobConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- *((*string)(x)) = r.DecodeString()
- }
-}
-
-func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -11036,18 +9689,19 @@ func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [6]bool
+ var yyq2 [5]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
yyq2[2] = true
- yyq2[3] = true
- yyq2[4] = x.Reason != ""
- yyq2[5] = x.Message != ""
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(6)
+ r.EncodeArrayStart(5)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -11058,106 +9712,88 @@ func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- x.Type.CodecEncodeSelf(e)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("type"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- x.Type.CodecEncodeSelf(e)
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yysf7 := &x.Status
- yysf7.CodecEncodeSelf(e)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yysf8 := &x.Status
- yysf8.CodecEncodeSelf(e)
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yy10 := &x.LastProbeTime
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else if z.HasExtensions() && z.EncExt(yy10) {
- } else if yym11 {
- z.EncBinaryMarshal(yy10)
- } else if !yym11 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy10)
- } else {
- z.EncFallback(yy10)
- }
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy12 := &x.LastProbeTime
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else if z.HasExtensions() && z.EncExt(yy12) {
- } else if yym13 {
- z.EncBinaryMarshal(yy12)
- } else if !yym13 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy12)
- } else {
- z.EncFallback(yy12)
- }
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[3] {
- yy15 := &x.LastTransitionTime
- yym16 := z.EncBinary()
- _ = yym16
+ yym19 := z.EncBinary()
+ _ = yym19
if false {
- } else if z.HasExtensions() && z.EncExt(yy15) {
- } else if yym16 {
- z.EncBinaryMarshal(yy15)
- } else if !yym16 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy15)
} else {
- z.EncFallback(yy15)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- r.EncodeNil()
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy17 := &x.LastTransitionTime
- yym18 := z.EncBinary()
- _ = yym18
+ yym20 := z.EncBinary()
+ _ = yym20
if false {
- } else if z.HasExtensions() && z.EncExt(yy17) {
- } else if yym18 {
- z.EncBinaryMarshal(yy17)
- } else if !yym18 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy17)
} else {
- z.EncFallback(yy17)
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[4] {
- yym20 := z.EncBinary()
- _ = yym20
+ yym22 := z.EncBinary()
+ _ = yym22
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
@@ -11165,38 +9801,13 @@ func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym21 := z.EncBinary()
- _ = yym21
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[5] {
yym23 := z.EncBinary()
_ = yym23
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Message))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[5] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("message"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym24 := z.EncBinary()
- _ = yym24
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -11209,7 +9820,7 @@ func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -11239,7 +9850,7 @@ func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -11261,63 +9872,38 @@ func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "type":
- if r.TryDecodeAsNil() {
- x.Type = ""
- } else {
- x.Type = JobConditionType(r.DecodeString())
- }
- case "status":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Status = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Status = pkg2_api.ConditionStatus(r.DecodeString())
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "lastProbeTime":
+ case "spec":
if r.TryDecodeAsNil() {
- x.LastProbeTime = pkg1_unversioned.Time{}
+ x.Spec = ReplicaSetSpec{}
} else {
- yyv6 := &x.LastProbeTime
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv6) {
- } else if yym7 {
- z.DecBinaryUnmarshal(yyv6)
- } else if !yym7 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv6)
- } else {
- z.DecFallback(yyv6, false)
- }
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
}
- case "lastTransitionTime":
+ case "status":
if r.TryDecodeAsNil() {
- x.LastTransitionTime = pkg1_unversioned.Time{}
+ x.Status = ReplicaSetStatus{}
} else {
- yyv8 := &x.LastTransitionTime
- yym9 := z.DecBinary()
- _ = yym9
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv8) {
- } else if yym9 {
- z.DecBinaryUnmarshal(yyv8)
- } else if !yym9 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv8)
- } else {
- z.DecFallback(yyv8, false)
- }
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
}
- case "reason":
+ case "kind":
if r.TryDecodeAsNil() {
- x.Reason = ""
+ x.Kind = ""
} else {
- x.Reason = string(r.DecodeString())
+ x.Kind = string(r.DecodeString())
}
- case "message":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- x.Message = ""
+ x.APIVersion = ""
} else {
- x.Message = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -11326,148 +9912,113 @@ func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ReplicaSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj12 int
- var yyb12 bool
- var yyhl12 bool = l >= 0
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Type = ""
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.Type = JobConditionType(r.DecodeString())
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Status = ""
+ x.Spec = ReplicaSetSpec{}
} else {
- x.Status = pkg2_api.ConditionStatus(r.DecodeString())
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.LastProbeTime = pkg1_unversioned.Time{}
+ x.Status = ReplicaSetStatus{}
} else {
- yyv15 := &x.LastProbeTime
- yym16 := z.DecBinary()
- _ = yym16
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv15) {
- } else if yym16 {
- z.DecBinaryUnmarshal(yyv15)
- } else if !yym16 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv15)
- } else {
- z.DecFallback(yyv15, false)
- }
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
- } else {
- yyb12 = r.CheckBreak()
- }
- if yyb12 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.LastTransitionTime = pkg1_unversioned.Time{}
- } else {
- yyv17 := &x.LastTransitionTime
- yym18 := z.DecBinary()
- _ = yym18
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv17) {
- } else if yym18 {
- z.DecBinaryUnmarshal(yyv17)
- } else if !yym18 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv17)
- } else {
- z.DecFallback(yyv17, false)
- }
- }
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Reason = ""
+ x.Kind = ""
} else {
- x.Reason = string(r.DecodeString())
+ x.Kind = string(r.DecodeString())
}
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Message = ""
+ x.APIVersion = ""
} else {
- x.Message = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj12++
- if yyhl12 {
- yyb12 = yyj12 > l
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
} else {
- yyb12 = r.CheckBreak()
+ yyb9 = r.CheckBreak()
}
- if yyb12 {
+ if yyb9 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj12-1, "")
+ z.DecStructFieldNotFound(yyj9-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -11481,19 +10032,17 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -11505,8 +10054,14 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
} else {
r.EncodeNil()
}
@@ -11515,49 +10070,48 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
+ if x.Items == nil {
r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
} else {
- r.EncodeNil()
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
+ }
}
} else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -11566,12 +10120,12 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[3] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -11580,9 +10134,9 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -11591,12 +10145,12 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[4] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
+ yym16 := z.EncBinary()
+ _ = yym16
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -11612,7 +10166,7 @@ func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -11642,7 +10196,7 @@ func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -11666,24 +10220,28 @@ func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
switch yys3 {
case "metadata":
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "spec":
- if r.TryDecodeAsNil() {
- x.Spec = IngressSpec{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
}
- case "status":
+ case "items":
if r.TryDecodeAsNil() {
- x.Status = IngressStatus{}
+ x.Items = nil
} else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceReplicaSet((*[]ReplicaSet)(yyv6), d)
+ }
}
case "kind":
if r.TryDecodeAsNil() {
@@ -11704,113 +10262,107 @@ func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Spec = IngressSpec{}
+ x.Items = nil
} else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceReplicaSet((*[]ReplicaSet)(yyv13), d)
+ }
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Status = IngressStatus{}
+ x.Kind = ""
} else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
+ x.Kind = string(r.DecodeString())
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.APIVersion = ""
} else {
- x.Kind = string(r.DecodeString())
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb9 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -11824,15 +10376,14 @@ func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[1] = x.Selector != nil
+ yyq2[2] = true
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(3)
} else {
yynn2 = 1
for _, b := range yyq2 {
@@ -11845,108 +10396,73 @@ func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
- } else {
- z.EncFallback(yy4)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceIngress(([]Ingress)(x.Items), e)
- }
+ r.EncodeInt(int64(x.Replicas))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceIngress(([]Ingress)(x.Items), e)
- }
+ r.EncodeInt(int64(x.Replicas))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
+ if x.Selector == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
+ if yyq2[2] {
+ yy10 := &x.Template
+ yy10.CodecEncodeSelf(e)
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[3] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("template"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
+ yy12 := &x.Template
+ yy12.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
@@ -11958,7 +10474,7 @@ func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -11988,7 +10504,7 @@ func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -12010,42 +10526,35 @@ func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
+ case "replicas":
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Replicas = 0
} else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
+ x.Replicas = int32(r.DecodeInt(32))
}
- case "items":
+ case "selector":
if r.TryDecodeAsNil() {
- x.Items = nil
+ if x.Selector != nil {
+ x.Selector = nil
+ }
} else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- h.decSliceIngress((*[]Ingress)(yyv6), d)
+ z.DecFallback(x.Selector, false)
}
}
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
+ case "template":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv7 := &x.Template
+ yyv7.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -12054,107 +10563,90 @@ func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb10 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Replicas = 0
} else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
+ x.Replicas = int32(r.DecodeInt(32))
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb10 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ if x.Selector != nil {
+ x.Selector = nil
+ }
} else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
+ if x.Selector == nil {
+ x.Selector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym11 := z.DecBinary()
+ _ = yym11
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- h.decSliceIngress((*[]Ingress)(yyv13), d)
+ z.DecFallback(x.Selector, false)
}
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb10 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Template = pkg2_api.PodTemplateSpec{}
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv12 := &x.Template
+ yyv12.CodecDecodeSelf(d)
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb10 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -12171,14 +10663,13 @@ func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [3]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Backend != nil
- yyq2[1] = len(x.TLS) != 0
- yyq2[2] = len(x.Rules) != 0
+ yyq2[1] = x.FullyLabeledReplicas != 0
+ yyq2[2] = x.ObservedGeneration != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(3)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -12189,90 +10680,70 @@ func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- if x.Backend == nil {
- r.EncodeNil()
- } else {
- x.Backend.CodecEncodeSelf(e)
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeNil()
+ r.EncodeInt(int64(x.Replicas))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("backend"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Backend == nil {
- r.EncodeNil()
- } else {
- x.Backend.CodecEncodeSelf(e)
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("replicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Replicas))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.TLS == nil {
- r.EncodeNil()
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
} else {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
- }
+ r.EncodeInt(int64(x.FullyLabeledReplicas))
}
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("tls"))
+ r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.TLS == nil {
- r.EncodeNil()
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
} else {
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
- }
+ r.EncodeInt(int64(x.FullyLabeledReplicas))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- if x.Rules == nil {
- r.EncodeNil()
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
- }
+ r.EncodeInt(int64(x.ObservedGeneration))
}
} else {
- r.EncodeNil()
+ r.EncodeInt(0)
}
} else {
if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rules"))
+ r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Rules == nil {
- r.EncodeNil()
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
} else {
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else {
- h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
- }
+ r.EncodeInt(int64(x.ObservedGeneration))
}
}
}
@@ -12285,7 +10756,7 @@ func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -12315,7 +10786,7 @@ func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -12337,40 +10808,23 @@ func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "backend":
+ case "replicas":
if r.TryDecodeAsNil() {
- if x.Backend != nil {
- x.Backend = nil
- }
+ x.Replicas = 0
} else {
- if x.Backend == nil {
- x.Backend = new(IngressBackend)
- }
- x.Backend.CodecDecodeSelf(d)
+ x.Replicas = int32(r.DecodeInt(32))
}
- case "tls":
+ case "fullyLabeledReplicas":
if r.TryDecodeAsNil() {
- x.TLS = nil
+ x.FullyLabeledReplicas = 0
} else {
- yyv5 := &x.TLS
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else {
- h.decSliceIngressTLS((*[]IngressTLS)(yyv5), d)
- }
+ x.FullyLabeledReplicas = int32(r.DecodeInt(32))
}
- case "rules":
+ case "observedGeneration":
if r.TryDecodeAsNil() {
- x.Rules = nil
+ x.ObservedGeneration = 0
} else {
- yyv7 := &x.Rules
- yym8 := z.DecBinary()
- _ = yym8
- if false {
- } else {
- h.decSliceIngressRule((*[]IngressRule)(yyv7), d)
- }
+ x.ObservedGeneration = int64(r.DecodeInt(64))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -12379,95 +10833,78 @@ func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Backend != nil {
- x.Backend = nil
- }
+ x.Replicas = 0
} else {
- if x.Backend == nil {
- x.Backend = new(IngressBackend)
- }
- x.Backend.CodecDecodeSelf(d)
+ x.Replicas = int32(r.DecodeInt(32))
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.TLS = nil
+ x.FullyLabeledReplicas = 0
} else {
- yyv11 := &x.TLS
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else {
- h.decSliceIngressTLS((*[]IngressTLS)(yyv11), d)
- }
+ x.FullyLabeledReplicas = int32(r.DecodeInt(32))
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Rules = nil
+ x.ObservedGeneration = 0
} else {
- yyv13 := &x.Rules
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceIngressRule((*[]IngressRule)(yyv13), d)
- }
+ x.ObservedGeneration = int64(r.DecodeInt(64))
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -12481,14 +10918,16 @@ func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = len(x.Hosts) != 0
- yyq2[1] = x.SecretName != ""
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -12502,58 +10941,84 @@ func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- if x.Hosts == nil {
- r.EncodeNil()
- } else {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- z.F.EncSliceStringV(x.Hosts, false, e)
- }
- }
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hosts"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Hosts == nil {
- r.EncodeNil()
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
} else {
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- z.F.EncSliceStringV(x.Hosts, false, e)
- }
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[1] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("secretName"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
+ yym18 := z.EncBinary()
+ _ = yym18
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
@@ -12566,7 +11031,7 @@ func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IngressTLS) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *PodSecurityPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -12596,7 +11061,7 @@ func (x *IngressTLS) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -12618,23 +11083,31 @@ func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "hosts":
+ case "metadata":
if r.TryDecodeAsNil() {
- x.Hosts = nil
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- yyv4 := &x.Hosts
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- z.F.DecSliceStringX(yyv4, false, d)
- }
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "secretName":
+ case "spec":
if r.TryDecodeAsNil() {
- x.SecretName = ""
+ x.Spec = PodSecurityPolicySpec{}
} else {
- x.SecretName = string(r.DecodeString())
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -12643,68 +11116,96 @@ func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IngressTLS) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Hosts = nil
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- yyv8 := &x.Hosts
- yym9 := z.DecBinary()
- _ = yym9
- if false {
- } else {
- z.F.DecSliceStringX(yyv8, false, d)
- }
+ yyv9 := &x.ObjectMeta
+ yyv9.CodecDecodeSelf(d)
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.SecretName = ""
+ x.Spec = PodSecurityPolicySpec{}
} else {
- x.SecretName = string(r.DecodeString())
+ yyv10 := &x.Spec
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb7 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -12718,15 +11219,24 @@ func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
+ yyq2[0] = x.Privileged != false
+ yyq2[1] = len(x.DefaultAddCapabilities) != 0
+ yyq2[2] = len(x.RequiredDropCapabilities) != 0
+ yyq2[3] = len(x.AllowedCapabilities) != 0
+ yyq2[4] = len(x.Volumes) != 0
+ yyq2[5] = x.HostNetwork != false
+ yyq2[6] = len(x.HostPorts) != 0
+ yyq2[7] = x.HostPID != false
+ yyq2[8] = x.HostIPC != false
+ yyq2[13] = x.ReadOnlyRootFilesystem != false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ r.EncodeArrayStart(14)
} else {
- yynn2 = 0
+ yynn2 = 4
for _, b := range yyq2 {
if b {
yynn2++
@@ -12738,431 +11248,334 @@ func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.LoadBalancer
- yy4.CodecEncodeSelf(e)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Privileged))
+ }
} else {
- r.EncodeNil()
+ r.EncodeBool(false)
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
+ r.EncodeString(codecSelferC_UTF81234, string("privileged"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.LoadBalancer
- yy6.CodecEncodeSelf(e)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Privileged))
+ }
}
}
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.DefaultAddCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.DefaultAddCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
+ }
+ }
+ }
}
- }
- }
-}
-
-func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ if x.RequiredDropCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *IngressStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.RequiredDropCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
+ }
+ }
+ }
}
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "loadBalancer":
- if r.TryDecodeAsNil() {
- x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ if x.AllowedCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- yyv4 := &x.LoadBalancer
- yyv4.CodecDecodeSelf(d)
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.AllowedCapabilities == nil {
+ r.EncodeNil()
+ } else {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
+ }
+ }
+ }
}
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
- } else {
- yyb5 = r.CheckBreak()
- }
- if yyb5 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
- } else {
- yyv6 := &x.LoadBalancer
- yyv6.CodecDecodeSelf(d)
- }
- for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
- } else {
- yyb5 = r.CheckBreak()
- }
- if yyb5 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *IngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.Host != ""
- yyq2[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
- var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.Volumes == nil {
+ r.EncodeNil()
+ } else {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ h.encSliceFSType(([]FSType)(x.Volumes), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("volumes"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Volumes == nil {
+ r.EncodeNil()
+ } else {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ h.encSliceFSType(([]FSType)(x.Volumes), e)
+ }
}
}
- r.EncodeMapStart(yynn2)
- yynn2 = 0
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
+ if yyq2[5] {
+ yym19 := z.EncBinary()
+ _ = yym19
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Host))
+ r.EncodeBool(bool(x.HostNetwork))
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeBool(false)
}
} else {
- if yyq2[0] {
+ if yyq2[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("host"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
+ yym20 := z.EncBinary()
+ _ = yym20
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Host))
+ r.EncodeBool(bool(x.HostNetwork))
}
}
}
- var yyn6 bool
- if x.IngressRuleValue.HTTP == nil {
- yyn6 = true
- goto LABEL6
- }
- LABEL6:
if yyr2 || yy2arr2 {
- if yyn6 {
- r.EncodeNil()
- } else {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- if x.HTTP == nil {
- r.EncodeNil()
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[6] {
+ if x.HostPorts == nil {
+ r.EncodeNil()
+ } else {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
} else {
- x.HTTP.CodecEncodeSelf(e)
+ h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
}
- } else {
- r.EncodeNil()
}
+ } else {
+ r.EncodeNil()
}
} else {
- if yyq2[1] {
+ if yyq2[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("http"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if yyn6 {
+ if x.HostPorts == nil {
r.EncodeNil()
} else {
- if x.HTTP == nil {
- r.EncodeNil()
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
} else {
- x.HTTP.CodecEncodeSelf(e)
+ h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
}
}
}
}
if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[7] {
+ yym25 := z.EncBinary()
+ _ = yym25
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostPID))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ if yyq2[7] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym26 := z.EncBinary()
+ _ = yym26
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostPID))
+ }
+ }
}
- }
- }
-}
-
-func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[8] {
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostIPC))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
} else {
- x.codecDecodeSelfFromMap(yyl2, d)
+ if yyq2[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostIPC))
+ }
+ }
}
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy31 := &x.SELinux
+ yy31.CodecEncodeSelf(e)
} else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
- } else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
- }
- }
-}
-
-func (x *IngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy33 := &x.SELinux
+ yy33.CodecEncodeSelf(e)
}
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "host":
- if r.TryDecodeAsNil() {
- x.Host = ""
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy36 := &x.RunAsUser
+ yy36.CodecEncodeSelf(e)
} else {
- x.Host = string(r.DecodeString())
- }
- case "http":
- if x.IngressRuleValue.HTTP == nil {
- x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy38 := &x.RunAsUser
+ yy38.CodecEncodeSelf(e)
}
- if r.TryDecodeAsNil() {
- if x.HTTP != nil {
- x.HTTP = nil
- }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy41 := &x.SupplementalGroups
+ yy41.CodecEncodeSelf(e)
} else {
- if x.HTTP == nil {
- x.HTTP = new(HTTPIngressRuleValue)
- }
- x.HTTP.CodecDecodeSelf(d)
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy43 := &x.SupplementalGroups
+ yy43.CodecEncodeSelf(e)
}
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Host = ""
- } else {
- x.Host = string(r.DecodeString())
- }
- if x.IngressRuleValue.HTTP == nil {
- x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
- }
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- if x.HTTP != nil {
- x.HTTP = nil
- }
- } else {
- if x.HTTP == nil {
- x.HTTP = new(HTTPIngressRuleValue)
- }
- x.HTTP.CodecDecodeSelf(d)
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
- }
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
- } else {
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = x.HTTP != nil
- var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy46 := &x.FSGroup
+ yy46.CodecEncodeSelf(e)
} else {
- yynn2 = 0
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy48 := &x.FSGroup
+ yy48.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- if x.HTTP == nil {
- r.EncodeNil()
+ if yyq2[13] {
+ yym51 := z.EncBinary()
+ _ = yym51
+ if false {
} else {
- x.HTTP.CodecEncodeSelf(e)
+ r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
}
} else {
- r.EncodeNil()
+ r.EncodeBool(false)
}
} else {
- if yyq2[0] {
+ if yyq2[13] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("http"))
+ r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.HTTP == nil {
- r.EncodeNil()
+ yym52 := z.EncBinary()
+ _ = yym52
+ if false {
} else {
- x.HTTP.CodecEncodeSelf(e)
+ r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
}
}
}
@@ -13175,7 +11588,7 @@ func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *PodSecurityPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13205,7 +11618,7 @@ func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13227,16 +11640,123 @@ func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "http":
+ case "privileged":
if r.TryDecodeAsNil() {
- if x.HTTP != nil {
- x.HTTP = nil
+ x.Privileged = false
+ } else {
+ x.Privileged = bool(r.DecodeBool())
+ }
+ case "defaultAddCapabilities":
+ if r.TryDecodeAsNil() {
+ x.DefaultAddCapabilities = nil
+ } else {
+ yyv5 := &x.DefaultAddCapabilities
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv5), d)
}
+ }
+ case "requiredDropCapabilities":
+ if r.TryDecodeAsNil() {
+ x.RequiredDropCapabilities = nil
} else {
- if x.HTTP == nil {
- x.HTTP = new(HTTPIngressRuleValue)
+ yyv7 := &x.RequiredDropCapabilities
+ yym8 := z.DecBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv7), d)
}
- x.HTTP.CodecDecodeSelf(d)
+ }
+ case "allowedCapabilities":
+ if r.TryDecodeAsNil() {
+ x.AllowedCapabilities = nil
+ } else {
+ yyv9 := &x.AllowedCapabilities
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv9), d)
+ }
+ }
+ case "volumes":
+ if r.TryDecodeAsNil() {
+ x.Volumes = nil
+ } else {
+ yyv11 := &x.Volumes
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceFSType((*[]FSType)(yyv11), d)
+ }
+ }
+ case "hostNetwork":
+ if r.TryDecodeAsNil() {
+ x.HostNetwork = false
+ } else {
+ x.HostNetwork = bool(r.DecodeBool())
+ }
+ case "hostPorts":
+ if r.TryDecodeAsNil() {
+ x.HostPorts = nil
+ } else {
+ yyv14 := &x.HostPorts
+ yym15 := z.DecBinary()
+ _ = yym15
+ if false {
+ } else {
+ h.decSliceHostPortRange((*[]HostPortRange)(yyv14), d)
+ }
+ }
+ case "hostPID":
+ if r.TryDecodeAsNil() {
+ x.HostPID = false
+ } else {
+ x.HostPID = bool(r.DecodeBool())
+ }
+ case "hostIPC":
+ if r.TryDecodeAsNil() {
+ x.HostIPC = false
+ } else {
+ x.HostIPC = bool(r.DecodeBool())
+ }
+ case "seLinux":
+ if r.TryDecodeAsNil() {
+ x.SELinux = SELinuxStrategyOptions{}
+ } else {
+ yyv18 := &x.SELinux
+ yyv18.CodecDecodeSelf(d)
+ }
+ case "runAsUser":
+ if r.TryDecodeAsNil() {
+ x.RunAsUser = RunAsUserStrategyOptions{}
+ } else {
+ yyv19 := &x.RunAsUser
+ yyv19.CodecDecodeSelf(d)
+ }
+ case "supplementalGroups":
+ if r.TryDecodeAsNil() {
+ x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
+ } else {
+ yyv20 := &x.SupplementalGroups
+ yyv20.CodecDecodeSelf(d)
+ }
+ case "fsGroup":
+ if r.TryDecodeAsNil() {
+ x.FSGroup = FSGroupStrategyOptions{}
+ } else {
+ yyv21 := &x.FSGroup
+ yyv21.CodecDecodeSelf(d)
+ }
+ case "readOnlyRootFilesystem":
+ if r.TryDecodeAsNil() {
+ x.ReadOnlyRootFilesystem = false
+ } else {
+ x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -13245,233 +11765,288 @@ func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj5 int
- var yyb5 bool
- var yyhl5 bool = l >= 0
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ var yyj23 int
+ var yyb23 bool
+ var yyhl23 bool = l >= 0
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb5 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb5 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.HTTP != nil {
- x.HTTP = nil
- }
+ x.Privileged = false
} else {
- if x.HTTP == nil {
- x.HTTP = new(HTTPIngressRuleValue)
- }
- x.HTTP.CodecDecodeSelf(d)
+ x.Privileged = bool(r.DecodeBool())
}
- for {
- yyj5++
- if yyhl5 {
- yyb5 = yyj5 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DefaultAddCapabilities = nil
+ } else {
+ yyv25 := &x.DefaultAddCapabilities
+ yym26 := z.DecBinary()
+ _ = yym26
+ if false {
} else {
- yyb5 = r.CheckBreak()
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv25), d)
}
- if yyb5 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj5-1, "")
}
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- if x == nil {
- r.EncodeNil()
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yym1 := z.EncBinary()
- _ = yym1
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RequiredDropCapabilities = nil
+ } else {
+ yyv27 := &x.RequiredDropCapabilities
+ yym28 := z.DecBinary()
+ _ = yym28
if false {
- } else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2 := !z.EncBinary()
- yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [1]bool
- _, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(1)
- } else {
- yynn2 = 1
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Paths == nil {
- r.EncodeNil()
- } else {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
- }
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("paths"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Paths == nil {
- r.EncodeNil()
- } else {
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- z.EncSendContainerState(codecSelfer_containerMapEnd1234)
- }
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv27), d)
}
}
-}
-
-func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyct2 := r.ContainerType()
- if yyct2 == codecSelferValueTypeMap1234 {
- yyl2 := r.ReadMapStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
- } else {
- x.codecDecodeSelfFromMap(yyl2, d)
- }
- } else if yyct2 == codecSelferValueTypeArray1234 {
- yyl2 := r.ReadArrayStart()
- if yyl2 == 0 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- } else {
- x.codecDecodeSelfFromArray(yyl2, d)
- }
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.AllowedCapabilities = nil
+ } else {
+ yyv29 := &x.AllowedCapabilities
+ yym30 := z.DecBinary()
+ _ = yym30
+ if false {
} else {
- panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv29), d)
}
}
-}
-
-func (x *HTTPIngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yys3Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3Slc
- var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Volumes = nil
+ } else {
+ yyv31 := &x.Volumes
+ yym32 := z.DecBinary()
+ _ = yym32
+ if false {
} else {
- if r.CheckBreak() {
- break
- }
+ h.decSliceFSType((*[]FSType)(yyv31), d)
}
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "paths":
- if r.TryDecodeAsNil() {
- x.Paths = nil
- } else {
- yyv4 := &x.Paths
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else {
- h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv4), d)
- }
- }
- default:
- z.DecStructFieldNotFound(-1, yys3)
- } // end switch yys3
- } // end for yyj3
- z.DecSendContainerState(codecSelfer_containerMapEnd1234)
-}
-
-func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb6 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Paths = nil
+ x.HostNetwork = false
} else {
- yyv7 := &x.Paths
- yym8 := z.DecBinary()
- _ = yym8
+ x.HostNetwork = bool(r.DecodeBool())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.HostPorts = nil
+ } else {
+ yyv34 := &x.HostPorts
+ yym35 := z.DecBinary()
+ _ = yym35
if false {
} else {
- h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv7), d)
+ h.decSliceHostPortRange((*[]HostPortRange)(yyv34), d)
}
}
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.HostPID = false
+ } else {
+ x.HostPID = bool(r.DecodeBool())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.HostIPC = false
+ } else {
+ x.HostIPC = bool(r.DecodeBool())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SELinux = SELinuxStrategyOptions{}
+ } else {
+ yyv38 := &x.SELinux
+ yyv38.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RunAsUser = RunAsUserStrategyOptions{}
+ } else {
+ yyv39 := &x.RunAsUser
+ yyv39.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
+ } else {
+ yyv40 := &x.SupplementalGroups
+ yyv40.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.FSGroup = FSGroupStrategyOptions{}
+ } else {
+ yyv41 := &x.FSGroup
+ yyv41.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ReadOnlyRootFilesystem = false
+ } else {
+ x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
+ }
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb6 {
+ if yyb23 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj23-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -13488,12 +12063,11 @@ func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Path != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 2
for _, b := range yyq2 {
if b {
yynn2++
@@ -13504,39 +12078,41 @@ func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
- }
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeInt(int64(x.Min))
}
} else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("path"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Path))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("min"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Min))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.Backend
- yy7.CodecEncodeSelf(e)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Max))
+ }
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("backend"))
+ r.EncodeString(codecSelferC_UTF81234, string("max"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.Backend
- yy9.CodecEncodeSelf(e)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(x.Max))
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -13547,7 +12123,7 @@ func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *HostPortRange) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13577,7 +12153,7 @@ func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13599,18 +12175,17 @@ func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "path":
+ case "min":
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.Min = 0
} else {
- x.Path = string(r.DecodeString())
+ x.Min = int(r.DecodeInt(codecSelferBitsize1234))
}
- case "backend":
+ case "max":
if r.TryDecodeAsNil() {
- x.Backend = IngressBackend{}
+ x.Max = 0
} else {
- yyv5 := &x.Backend
- yyv5.CodecDecodeSelf(d)
+ x.Max = int(r.DecodeInt(codecSelferBitsize1234))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -13619,7 +12194,7 @@ func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *HostPortRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13638,9 +12213,9 @@ func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Path = ""
+ x.Min = 0
} else {
- x.Path = string(r.DecodeString())
+ x.Min = int(r.DecodeInt(codecSelferBitsize1234))
}
yyj6++
if yyhl6 {
@@ -13654,28 +12229,53 @@ func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Backend = IngressBackend{}
+ x.Max = 0
+ } else {
+ x.Max = int(r.DecodeInt(codecSelferBitsize1234))
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *FSType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyv8 := &x.Backend
- yyv8.CodecDecodeSelf(d)
- }
- for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- break
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ *((*string)(x)) = r.DecodeString()
}
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -13692,11 +12292,12 @@ func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[1] = x.SELinuxOptions != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -13707,48 +12308,34 @@ func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
- }
+ x.Rule.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
- }
+ x.Rule.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy7 := &x.ServicePort
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else if z.HasExtensions() && z.EncExt(yy7) {
- } else if !yym8 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy7)
+ if yyq2[1] {
+ if x.SELinuxOptions == nil {
+ r.EncodeNil()
+ } else {
+ x.SELinuxOptions.CodecEncodeSelf(e)
+ }
} else {
- z.EncFallback(yy7)
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy9 := &x.ServicePort
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else if z.HasExtensions() && z.EncExt(yy9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy9)
- } else {
- z.EncFallback(yy9)
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.SELinuxOptions == nil {
+ r.EncodeNil()
+ } else {
+ x.SELinuxOptions.CodecEncodeSelf(e)
+ }
}
}
if yyr2 || yy2arr2 {
@@ -13760,7 +12347,7 @@ func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *SELinuxStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13790,7 +12377,7 @@ func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -13812,26 +12399,22 @@ func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "serviceName":
+ case "rule":
if r.TryDecodeAsNil() {
- x.ServiceName = ""
+ x.Rule = ""
} else {
- x.ServiceName = string(r.DecodeString())
+ x.Rule = SELinuxStrategy(r.DecodeString())
}
- case "servicePort":
+ case "seLinuxOptions":
if r.TryDecodeAsNil() {
- x.ServicePort = pkg6_intstr.IntOrString{}
+ if x.SELinuxOptions != nil {
+ x.SELinuxOptions = nil
+ }
} else {
- yyv5 := &x.ServicePort
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv5) {
- } else if !yym6 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv5)
- } else {
- z.DecFallback(yyv5, false)
+ if x.SELinuxOptions == nil {
+ x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
}
+ x.SELinuxOptions.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -13840,71 +12423,93 @@ func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *SELinuxStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj7 int
- var yyb7 bool
- var yyhl7 bool = l >= 0
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ServiceName = ""
+ x.Rule = ""
} else {
- x.ServiceName = string(r.DecodeString())
+ x.Rule = SELinuxStrategy(r.DecodeString())
}
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ServicePort = pkg6_intstr.IntOrString{}
+ if x.SELinuxOptions != nil {
+ x.SELinuxOptions = nil
+ }
} else {
- yyv9 := &x.ServicePort
- yym10 := z.DecBinary()
- _ = yym10
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv9) {
- } else if !yym10 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv9)
- } else {
- z.DecFallback(yyv9, false)
+ if x.SELinuxOptions == nil {
+ x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
}
+ x.SELinuxOptions.CodecDecodeSelf(d)
}
for {
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb7 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb7 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj7-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *SELinuxStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -13918,125 +12523,62 @@ func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [5]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[1] = true
- yyq2[2] = true
- yyq2[3] = x.Kind != ""
- yyq2[4] = x.APIVersion != ""
+ yyq2[1] = len(x.Ranges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(5)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy14 := &x.Status
- yy14.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("status"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy16 := &x.Status
- yy16.CodecEncodeSelf(e)
+ }
}
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
+ x.Rule.CodecEncodeSelf(e)
} else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Rule.CodecEncodeSelf(e)
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- yym22 := z.EncBinary()
- _ = yym22
- if false {
+ if yyq2[1] {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[4] {
+ if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("ranges"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
- if false {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
}
}
@@ -14049,7 +12591,7 @@ func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *RunAsUserStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14079,7 +12621,7 @@ func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14101,38 +12643,23 @@ func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
- }
- case "spec":
- if r.TryDecodeAsNil() {
- x.Spec = ReplicaSetSpec{}
- } else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
- }
- case "status":
- if r.TryDecodeAsNil() {
- x.Status = ReplicaSetStatus{}
- } else {
- yyv6 := &x.Status
- yyv6.CodecDecodeSelf(d)
- }
- case "kind":
+ case "rule":
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Rule = ""
} else {
- x.Kind = string(r.DecodeString())
+ x.Rule = RunAsUserStrategy(r.DecodeString())
}
- case "apiVersion":
+ case "ranges":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Ranges = nil
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv5 := &x.Ranges
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv5), d)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -14141,113 +12668,68 @@ func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ReplicaSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj9 int
- var yyb9 bool
- var yyhl9 bool = l >= 0
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
- } else {
- yyv10 := &x.ObjectMeta
- yyv10.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Spec = ReplicaSetSpec{}
- } else {
- yyv11 := &x.Spec
- yyv11.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
- } else {
- yyb9 = r.CheckBreak()
- }
- if yyb9 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Status = ReplicaSetStatus{}
- } else {
- yyv12 := &x.Status
- yyv12.CodecDecodeSelf(d)
- }
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Rule = ""
} else {
- x.Kind = string(r.DecodeString())
+ x.Rule = RunAsUserStrategy(r.DecodeString())
}
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Ranges = nil
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv9 := &x.Ranges
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv9), d)
+ }
}
for {
- yyj9++
- if yyhl9 {
- yyb9 = yyj9 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb9 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb9 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj9-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -14261,129 +12743,58 @@ func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
- var yynn2 int
- if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
- } else {
- yynn2 = 1
- for _, b := range yyq2 {
- if b {
- yynn2++
- }
- }
- r.EncodeMapStart(yynn2)
- yynn2 = 0
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
- } else {
- z.EncFallback(yy4)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
}
}
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
} else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
- }
+ r.EncodeInt(int64(x.Min))
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
+ r.EncodeString(codecSelferC_UTF81234, string("min"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
} else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
- }
+ r.EncodeInt(int64(x.Min))
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeInt(int64(x.Max))
}
} else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("max"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
+ r.EncodeInt(int64(x.Max))
}
}
if yyr2 || yy2arr2 {
@@ -14395,7 +12806,7 @@ func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *IDRange) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14425,7 +12836,7 @@ func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14447,42 +12858,17 @@ func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
- }
- case "items":
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
- if false {
- } else {
- h.decSliceReplicaSet((*[]ReplicaSet)(yyv6), d)
- }
- }
- case "kind":
+ case "min":
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Min = 0
} else {
- x.Kind = string(r.DecodeString())
+ x.Min = int64(r.DecodeInt(64))
}
- case "apiVersion":
+ case "max":
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Max = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Max = int64(r.DecodeInt(64))
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -14491,107 +12877,88 @@ func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ReplicaSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *IDRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
- } else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Items = nil
- } else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
- if false {
- } else {
- h.decSliceReplicaSet((*[]ReplicaSet)(yyv13), d)
- }
- }
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Min = 0
} else {
- x.Kind = string(r.DecodeString())
+ x.Min = int64(r.DecodeInt(64))
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Max = 0
} else {
- x.APIVersion = string(r.DecodeString())
+ x.Max = int64(r.DecodeInt(64))
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb6 = r.CheckBreak()
}
- if yyb10 {
+ if yyb6 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj6-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *RunAsUserStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *FSGroupStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -14605,16 +12972,16 @@ func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
- const yyr2 bool = false
- yyq2[1] = x.Selector != nil
- yyq2[2] = true
+ const yyr2 bool = false
+ yyq2[0] = x.Rule != ""
+ yyq2[1] = len(x.Ranges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -14625,35 +12992,30 @@ func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ x.Rule.CodecEncodeSelf(e)
} else {
- r.EncodeInt(int64(x.Replicas))
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Rule.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.Selector == nil {
+ if x.Ranges == nil {
r.EncodeNil()
} else {
yym7 := z.EncBinary()
_ = yym7
if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
} else {
- z.EncFallback(x.Selector)
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
}
}
} else {
@@ -14662,38 +13024,20 @@ func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ r.EncodeString(codecSelferC_UTF81234, string("ranges"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Selector == nil {
+ if x.Ranges == nil {
r.EncodeNil()
} else {
yym8 := z.EncBinary()
_ = yym8
if false {
- } else if z.HasExtensions() && z.EncExt(x.Selector) {
} else {
- z.EncFallback(x.Selector)
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
}
}
}
}
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yy10 := &x.Template
- yy10.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("template"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy12 := &x.Template
- yy12.CodecEncodeSelf(e)
- }
- }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -14703,7 +13047,7 @@ func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14733,7 +13077,7 @@ func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -14755,36 +13099,24 @@ func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "replicas":
+ case "rule":
if r.TryDecodeAsNil() {
- x.Replicas = 0
+ x.Rule = ""
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Rule = FSGroupStrategyType(r.DecodeString())
}
- case "selector":
+ case "ranges":
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.Ranges = nil
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
+ yyv5 := &x.Ranges
yym6 := z.DecBinary()
_ = yym6
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- z.DecFallback(x.Selector, false)
+ h.decSliceIDRange((*[]IDRange)(yyv5), d)
}
}
- case "template":
- if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
- } else {
- yyv7 := &x.Template
- yyv7.CodecDecodeSelf(d)
- }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -14792,90 +13124,94 @@ func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ReplicaSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Replicas = 0
+ x.Rule = ""
} else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Rule = FSGroupStrategyType(r.DecodeString())
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.Selector != nil {
- x.Selector = nil
- }
+ x.Ranges = nil
} else {
- if x.Selector == nil {
- x.Selector = new(pkg1_unversioned.LabelSelector)
- }
- yym11 := z.DecBinary()
- _ = yym11
+ yyv9 := &x.Ranges
+ yym10 := z.DecBinary()
+ _ = yym10
if false {
- } else if z.HasExtensions() && z.DecExt(x.Selector) {
} else {
- z.DecFallback(x.Selector, false)
+ h.decSliceIDRange((*[]IDRange)(yyv9), d)
}
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
- } else {
- yyb8 = r.CheckBreak()
- }
- if yyb8 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Template = pkg2_api.PodTemplateSpec{}
- } else {
- yyv12 := &x.Template
- yyv12.CodecDecodeSelf(d)
- }
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb8 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *FSGroupStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *SupplementalGroupsStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -14889,16 +13225,16 @@ func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [3]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.FullyLabeledReplicas != 0
- yyq2[2] = x.ObservedGeneration != 0
+ yyq2[0] = x.Rule != ""
+ yyq2[1] = len(x.Ranges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(3)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -14909,70 +13245,49 @@ func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("replicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Replicas))
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeInt(int64(x.FullyLabeledReplicas))
- }
+ if yyq2[0] {
+ x.Rule.CodecEncodeSelf(e)
} else {
- r.EncodeInt(0)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[1] {
+ if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeInt(int64(x.FullyLabeledReplicas))
- }
+ x.Rule.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
+ if yyq2[1] {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(x.ObservedGeneration))
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
} else {
- r.EncodeInt(0)
+ r.EncodeNil()
}
} else {
- if yyq2[2] {
+ if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
+ r.EncodeString(codecSelferC_UTF81234, string("ranges"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym11 := z.EncBinary()
- _ = yym11
- if false {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeInt(int64(x.ObservedGeneration))
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
}
}
@@ -14985,7 +13300,7 @@ func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *SupplementalGroupsStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15015,7 +13330,7 @@ func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15037,23 +13352,23 @@ func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "replicas":
- if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- case "fullyLabeledReplicas":
+ case "rule":
if r.TryDecodeAsNil() {
- x.FullyLabeledReplicas = 0
+ x.Rule = ""
} else {
- x.FullyLabeledReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
}
- case "observedGeneration":
+ case "ranges":
if r.TryDecodeAsNil() {
- x.ObservedGeneration = 0
+ x.Ranges = nil
} else {
- x.ObservedGeneration = int64(r.DecodeInt(64))
+ yyv5 := &x.Ranges
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv5), d)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -15062,7 +13377,7 @@ func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15081,25 +13396,9 @@ func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Replicas = 0
- } else {
- x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
- }
- yyj7++
- if yyhl7 {
- yyb7 = yyj7 > l
- } else {
- yyb7 = r.CheckBreak()
- }
- if yyb7 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.FullyLabeledReplicas = 0
+ x.Rule = ""
} else {
- x.FullyLabeledReplicas = int(r.DecodeInt(codecSelferBitsize1234))
+ x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
}
yyj7++
if yyhl7 {
@@ -15113,9 +13412,15 @@ func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObservedGeneration = 0
+ x.Ranges = nil
} else {
- x.ObservedGeneration = int64(r.DecodeInt(64))
+ yyv9 := &x.Ranges
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv9), d)
+ }
}
for {
yyj7++
@@ -15133,7 +13438,33 @@ func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *SupplementalGroupsStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -15151,14 +13482,13 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = true
- yyq2[1] = true
yyq2[2] = x.Kind != ""
yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(4)
} else {
- yynn2 = 0
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -15170,8 +13500,14 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ObjectMeta
- yy4.CodecEncodeSelf(e)
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
} else {
r.EncodeNil()
}
@@ -15180,32 +13516,48 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ObjectMeta
- yy6.CodecEncodeSelf(e)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yy9 := &x.Spec
- yy9.CodecEncodeSelf(e)
- } else {
+ if x.Items == nil {
r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ }
}
} else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("spec"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy11 := &x.Spec
- yy11.CodecEncodeSelf(e)
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- yym14 := z.EncBinary()
- _ = yym14
+ yym12 := z.EncBinary()
+ _ = yym12
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -15218,8 +13570,8 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym15 := z.EncBinary()
- _ = yym15
+ yym13 := z.EncBinary()
+ _ = yym13
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -15229,8 +13581,8 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[3] {
- yym17 := z.EncBinary()
- _ = yym17
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -15243,8 +13595,8 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym18 := z.EncBinary()
- _ = yym18
+ yym16 := z.EncBinary()
+ _ = yym16
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -15260,7 +13612,7 @@ func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *PodSecurityPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15290,7 +13642,7 @@ func (x *PodSecurityPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15314,17 +13666,28 @@ func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
switch yys3 {
case "metadata":
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv4 := &x.ObjectMeta
- yyv4.CodecDecodeSelf(d)
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
}
- case "spec":
+ case "items":
if r.TryDecodeAsNil() {
- x.Spec = PodSecurityPolicySpec{}
+ x.Items = nil
} else {
- yyv5 := &x.Spec
- yyv5.CodecDecodeSelf(d)
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv6), d)
+ }
}
case "kind":
if r.TryDecodeAsNil() {
@@ -15345,54 +13708,65 @@ func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj8 int
- var yyb8 bool
- var yyhl8 bool = l >= 0
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ObjectMeta = pkg2_api.ObjectMeta{}
+ x.ListMeta = pkg1_unversioned.ListMeta{}
} else {
- yyv9 := &x.ObjectMeta
- yyv9.CodecDecodeSelf(d)
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Spec = PodSecurityPolicySpec{}
+ x.Items = nil
} else {
- yyv10 := &x.Spec
- yyv10.CodecDecodeSelf(d)
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv13), d)
+ }
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -15402,13 +13776,13 @@ func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
} else {
x.Kind = string(r.DecodeString())
}
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -15419,22 +13793,22 @@ func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
x.APIVersion = string(r.DecodeString())
}
for {
- yyj8++
- if yyhl8 {
- yyb8 = yyj8 > l
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
} else {
- yyb8 = r.CheckBreak()
+ yyb10 = r.CheckBreak()
}
- if yyb8 {
+ if yyb10 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj8-1, "")
+ z.DecStructFieldNotFound(yyj10-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -15448,21 +13822,16 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [9]bool
+ var yyq2 [4]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = x.Privileged != false
- yyq2[1] = len(x.Capabilities) != 0
- yyq2[2] = len(x.Volumes) != 0
- yyq2[3] = x.HostNetwork != false
- yyq2[4] = len(x.HostPorts) != 0
- yyq2[5] = x.HostPID != false
- yyq2[6] = x.HostIPC != false
- yyq2[7] = true
- yyq2[8] = true
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(9)
+ r.EncodeArrayStart(4)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -15476,236 +13845,87 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yym4 := z.EncBinary()
- _ = yym4
- if false {
- } else {
- r.EncodeBool(bool(x.Privileged))
- }
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
} else {
- r.EncodeBool(false)
+ r.EncodeNil()
}
} else {
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("privileged"))
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeBool(bool(x.Privileged))
- }
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.Capabilities == nil {
- r.EncodeNil()
- } else {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- h.encSliceapi_Capability(([]pkg2_api.Capability)(x.Capabilities), e)
- }
- }
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("capabilities"))
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Capabilities == nil {
- r.EncodeNil()
- } else {
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- h.encSliceapi_Capability(([]pkg2_api.Capability)(x.Capabilities), e)
- }
- }
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- if x.Volumes == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSliceFSType(([]FSType)(x.Volumes), e)
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("volumes"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Volumes == nil {
- r.EncodeNil()
- } else {
- yym11 := z.EncBinary()
- _ = yym11
- if false {
- } else {
- h.encSliceFSType(([]FSType)(x.Volumes), e)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeBool(bool(x.HostNetwork))
- }
- } else {
- r.EncodeBool(false)
- }
- } else {
- if yyq2[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym14 := z.EncBinary()
_ = yym14
if false {
} else {
- r.EncodeBool(bool(x.HostNetwork))
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[4] {
- if x.HostPorts == nil {
- r.EncodeNil()
- } else {
- yym16 := z.EncBinary()
- _ = yym16
- if false {
- } else {
- h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.HostPorts == nil {
- r.EncodeNil()
- } else {
- yym17 := z.EncBinary()
- _ = yym17
- if false {
- } else {
- h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
- }
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[5] {
- yym19 := z.EncBinary()
- _ = yym19
- if false {
- } else {
- r.EncodeBool(bool(x.HostPID))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
} else {
- r.EncodeBool(false)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[5] {
+ if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym20 := z.EncBinary()
- _ = yym20
+ yym15 := z.EncBinary()
+ _ = yym15
if false {
} else {
- r.EncodeBool(bool(x.HostPID))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[6] {
- yym22 := z.EncBinary()
- _ = yym22
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
if false {
} else {
- r.EncodeBool(bool(x.HostIPC))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
- r.EncodeBool(false)
+ r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[6] {
+ if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
+ yym18 := z.EncBinary()
+ _ = yym18
if false {
} else {
- r.EncodeBool(bool(x.HostIPC))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[7] {
- yy25 := &x.SELinux
- yy25.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[7] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy27 := &x.SELinux
- yy27.CodecEncodeSelf(e)
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[8] {
- yy30 := &x.RunAsUser
- yy30.CodecEncodeSelf(e)
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[8] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy32 := &x.RunAsUser
- yy32.CodecEncodeSelf(e)
- }
- }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -15715,7 +13935,7 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *PodSecurityPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -15745,101 +13965,53 @@ func (x *PodSecurityPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
var yys3Slc = z.DecScratchBuffer() // default slice to decode into
_ = yys3Slc
var yyhl3 bool = l >= 0
- for yyj3 := 0; ; yyj3++ {
- if yyhl3 {
- if yyj3 >= l {
- break
- }
- } else {
- if r.CheckBreak() {
- break
- }
- }
- z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3Slc = r.DecodeBytes(yys3Slc, true, true)
- yys3 := string(yys3Slc)
- z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3 {
- case "privileged":
- if r.TryDecodeAsNil() {
- x.Privileged = false
- } else {
- x.Privileged = bool(r.DecodeBool())
- }
- case "capabilities":
- if r.TryDecodeAsNil() {
- x.Capabilities = nil
- } else {
- yyv5 := &x.Capabilities
- yym6 := z.DecBinary()
- _ = yym6
- if false {
- } else {
- h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv5), d)
- }
- }
- case "volumes":
- if r.TryDecodeAsNil() {
- x.Volumes = nil
- } else {
- yyv7 := &x.Volumes
- yym8 := z.DecBinary()
- _ = yym8
- if false {
- } else {
- h.decSliceFSType((*[]FSType)(yyv7), d)
- }
- }
- case "hostNetwork":
- if r.TryDecodeAsNil() {
- x.HostNetwork = false
- } else {
- x.HostNetwork = bool(r.DecodeBool())
- }
- case "hostPorts":
- if r.TryDecodeAsNil() {
- x.HostPorts = nil
- } else {
- yyv10 := &x.HostPorts
- yym11 := z.DecBinary()
- _ = yym11
- if false {
- } else {
- h.decSliceHostPortRange((*[]HostPortRange)(yyv10), d)
- }
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
}
- case "hostPID":
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
if r.TryDecodeAsNil() {
- x.HostPID = false
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.HostPID = bool(r.DecodeBool())
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
}
- case "hostIPC":
+ case "spec":
if r.TryDecodeAsNil() {
- x.HostIPC = false
+ x.Spec = NetworkPolicySpec{}
} else {
- x.HostIPC = bool(r.DecodeBool())
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
}
- case "seLinux":
+ case "kind":
if r.TryDecodeAsNil() {
- x.SELinux = SELinuxStrategyOptions{}
+ x.Kind = ""
} else {
- yyv14 := &x.SELinux
- yyv14.CodecDecodeSelf(d)
+ x.Kind = string(r.DecodeString())
}
- case "runAsUser":
+ case "apiVersion":
if r.TryDecodeAsNil() {
- x.RunAsUser = RunAsUserStrategyOptions{}
+ x.APIVersion = ""
} else {
- yyv15 := &x.RunAsUser
- yyv15.CodecDecodeSelf(d)
+ x.APIVersion = string(r.DecodeString())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -15848,194 +14020,96 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj16 int
- var yyb16 bool
- var yyhl16 bool = l >= 0
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
- } else {
- yyb16 = r.CheckBreak()
- }
- if yyb16 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Privileged = false
- } else {
- x.Privileged = bool(r.DecodeBool())
- }
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
- } else {
- yyb16 = r.CheckBreak()
- }
- if yyb16 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Capabilities = nil
- } else {
- yyv18 := &x.Capabilities
- yym19 := z.DecBinary()
- _ = yym19
- if false {
- } else {
- h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv18), d)
- }
- }
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
- } else {
- yyb16 = r.CheckBreak()
- }
- if yyb16 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.Volumes = nil
- } else {
- yyv20 := &x.Volumes
- yym21 := z.DecBinary()
- _ = yym21
- if false {
- } else {
- h.decSliceFSType((*[]FSType)(yyv20), d)
- }
- }
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
- } else {
- yyb16 = r.CheckBreak()
- }
- if yyb16 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.HostNetwork = false
- } else {
- x.HostNetwork = bool(r.DecodeBool())
- }
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
- } else {
- yyb16 = r.CheckBreak()
- }
- if yyb16 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.HostPorts = nil
- } else {
- yyv23 := &x.HostPorts
- yym24 := z.DecBinary()
- _ = yym24
- if false {
- } else {
- h.decSliceHostPortRange((*[]HostPortRange)(yyv23), d)
- }
- }
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb16 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostPID = false
+ x.ObjectMeta = pkg2_api.ObjectMeta{}
} else {
- x.HostPID = bool(r.DecodeBool())
+ yyv9 := &x.ObjectMeta
+ yyv9.CodecDecodeSelf(d)
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb16 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostIPC = false
+ x.Spec = NetworkPolicySpec{}
} else {
- x.HostIPC = bool(r.DecodeBool())
+ yyv10 := &x.Spec
+ yyv10.CodecDecodeSelf(d)
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb16 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.SELinux = SELinuxStrategyOptions{}
+ x.Kind = ""
} else {
- yyv27 := &x.SELinux
- yyv27.CodecDecodeSelf(d)
+ x.Kind = string(r.DecodeString())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb16 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.RunAsUser = RunAsUserStrategyOptions{}
+ x.APIVersion = ""
} else {
- yyv28 := &x.RunAsUser
- yyv28.CodecDecodeSelf(d)
+ x.APIVersion = string(r.DecodeString())
}
for {
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb16 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj16-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -16052,11 +14126,12 @@ func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[1] = len(x.Ingress) != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 2
+ yynn2 = 1
for _, b := range yyq2 {
if b {
yynn2++
@@ -16067,40 +14142,58 @@ func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
+ yy4 := &x.PodSelector
+ yym5 := z.EncBinary()
+ _ = yym5
if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
} else {
- r.EncodeInt(int64(x.Min))
+ z.EncFallback(yy4)
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("min"))
+ r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
+ yy6 := &x.PodSelector
+ yym7 := z.EncBinary()
+ _ = yym7
if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
} else {
- r.EncodeInt(int64(x.Min))
+ z.EncFallback(yy6)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ if yyq2[1] {
+ if x.Ingress == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
+ }
+ }
} else {
- r.EncodeInt(int64(x.Max))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("max"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeInt(int64(x.Max))
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ingress"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Ingress == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
@@ -16112,7 +14205,7 @@ func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *HostPortRange) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16142,7 +14235,7 @@ func (x *HostPortRange) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16164,17 +14257,30 @@ func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "min":
+ case "podSelector":
if r.TryDecodeAsNil() {
- x.Min = 0
+ x.PodSelector = pkg1_unversioned.LabelSelector{}
} else {
- x.Min = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv4 := &x.PodSelector
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
}
- case "max":
+ case "ingress":
if r.TryDecodeAsNil() {
- x.Max = 0
+ x.Ingress = nil
} else {
- x.Max = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv6 := &x.Ingress
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv6), d)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -16183,88 +14289,75 @@ func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *HostPortRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Min = 0
+ x.PodSelector = pkg1_unversioned.LabelSelector{}
} else {
- x.Min = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv9 := &x.PodSelector
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else {
+ z.DecFallback(yyv9, false)
+ }
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Max = 0
+ x.Ingress = nil
} else {
- x.Max = int(r.DecodeInt(codecSelferBitsize1234))
+ yyv11 := &x.Ingress
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv11), d)
+ }
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x))
- }
-}
-
-func (x *FSType) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- *((*string)(x)) = r.DecodeString()
- }
-}
-
-func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicyIngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -16281,12 +14374,13 @@ func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = x.SELinuxOptions != nil
+ yyq2[0] = len(x.Ports) != 0
+ yyq2[1] = len(x.From) != 0
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -16297,20 +14391,49 @@ func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- x.Rule.CodecEncodeSelf(e)
+ if yyq2[0] {
+ if x.Ports == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rule"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- x.Rule.CodecEncodeSelf(e)
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ports"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Ports == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
+ }
+ }
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.SELinuxOptions == nil {
+ if x.From == nil {
r.EncodeNil()
} else {
- x.SELinuxOptions.CodecEncodeSelf(e)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
+ }
}
} else {
r.EncodeNil()
@@ -16318,12 +14441,17 @@ func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
+ r.EncodeString(codecSelferC_UTF81234, string("from"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.SELinuxOptions == nil {
+ if x.From == nil {
r.EncodeNil()
} else {
- x.SELinuxOptions.CodecEncodeSelf(e)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
+ }
}
}
}
@@ -16336,7 +14464,7 @@ func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *SELinuxStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicyIngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16366,7 +14494,7 @@ func (x *SELinuxStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyIngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16388,22 +14516,29 @@ func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Deco
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "rule":
+ case "ports":
if r.TryDecodeAsNil() {
- x.Rule = ""
+ x.Ports = nil
} else {
- x.Rule = SELinuxStrategy(r.DecodeString())
+ yyv4 := &x.Ports
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv4), d)
+ }
}
- case "seLinuxOptions":
+ case "from":
if r.TryDecodeAsNil() {
- if x.SELinuxOptions != nil {
- x.SELinuxOptions = nil
- }
+ x.From = nil
} else {
- if x.SELinuxOptions == nil {
- x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
+ yyv6 := &x.From
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv6), d)
}
- x.SELinuxOptions.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -16412,93 +14547,74 @@ func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Deco
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *SELinuxStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyIngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Rule = ""
+ x.Ports = nil
} else {
- x.Rule = SELinuxStrategy(r.DecodeString())
+ yyv9 := &x.Ports
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv9), d)
+ }
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- if x.SELinuxOptions != nil {
- x.SELinuxOptions = nil
- }
+ x.From = nil
} else {
- if x.SELinuxOptions == nil {
- x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
+ yyv11 := &x.From
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv11), d)
}
- x.SELinuxOptions.CodecDecodeSelf(d)
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x))
- }
-}
-
-func (x *SELinuxStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- *((*string)(x)) = r.DecodeString()
- }
-}
-
-func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicyPort) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -16515,12 +14631,13 @@ func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[1] = len(x.Ranges) != 0
+ yyq2[0] = x.Protocol != nil
+ yyq2[1] = x.Port != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -16531,24 +14648,45 @@ func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- x.Rule.CodecEncodeSelf(e)
+ if yyq2[0] {
+ if x.Protocol == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.Protocol
+ yysf5 := &yy4
+ yysf5.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("rule"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- x.Rule.CodecEncodeSelf(e)
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("protocol"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Protocol == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.Protocol
+ yysf7 := &yy6
+ yysf7.CodecEncodeSelf(e)
+ }
+ }
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.Ranges == nil {
+ if x.Port == nil {
r.EncodeNil()
} else {
- yym7 := z.EncBinary()
- _ = yym7
+ yym9 := z.EncBinary()
+ _ = yym9
if false {
+ } else if z.HasExtensions() && z.EncExt(x.Port) {
+ } else if !yym9 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.Port)
} else {
- h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ z.EncFallback(x.Port)
}
}
} else {
@@ -16557,16 +14695,19 @@ func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("ranges"))
+ r.EncodeString(codecSelferC_UTF81234, string("port"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Ranges == nil {
+ if x.Port == nil {
r.EncodeNil()
} else {
- yym8 := z.EncBinary()
- _ = yym8
+ yym10 := z.EncBinary()
+ _ = yym10
if false {
+ } else if z.HasExtensions() && z.EncExt(x.Port) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.Port)
} else {
- h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ z.EncFallback(x.Port)
}
}
}
@@ -16580,7 +14721,7 @@ func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *RunAsUserStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicyPort) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16610,7 +14751,7 @@ func (x *RunAsUserStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16632,22 +14773,34 @@ func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.De
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "rule":
+ case "protocol":
if r.TryDecodeAsNil() {
- x.Rule = ""
+ if x.Protocol != nil {
+ x.Protocol = nil
+ }
} else {
- x.Rule = RunAsUserStrategy(r.DecodeString())
+ if x.Protocol == nil {
+ x.Protocol = new(pkg2_api.Protocol)
+ }
+ x.Protocol.CodecDecodeSelf(d)
}
- case "ranges":
+ case "port":
if r.TryDecodeAsNil() {
- x.Ranges = nil
+ if x.Port != nil {
+ x.Port = nil
+ }
} else {
- yyv5 := &x.Ranges
+ if x.Port == nil {
+ x.Port = new(pkg5_intstr.IntOrString)
+ }
yym6 := z.DecBinary()
_ = yym6
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Port) {
+ } else if !yym6 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.Port)
} else {
- h.decSliceIDRange((*[]IDRange)(yyv5), d)
+ z.DecFallback(x.Port, false)
}
}
default:
@@ -16657,7 +14810,7 @@ func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.De
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16676,9 +14829,14 @@ func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Rule = ""
+ if x.Protocol != nil {
+ x.Protocol = nil
+ }
} else {
- x.Rule = RunAsUserStrategy(r.DecodeString())
+ if x.Protocol == nil {
+ x.Protocol = new(pkg2_api.Protocol)
+ }
+ x.Protocol.CodecDecodeSelf(d)
}
yyj7++
if yyhl7 {
@@ -16692,14 +14850,21 @@ func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Ranges = nil
+ if x.Port != nil {
+ x.Port = nil
+ }
} else {
- yyv9 := &x.Ranges
+ if x.Port == nil {
+ x.Port = new(pkg5_intstr.IntOrString)
+ }
yym10 := z.DecBinary()
_ = yym10
if false {
+ } else if z.HasExtensions() && z.DecExt(x.Port) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.Port)
} else {
- h.decSliceIDRange((*[]IDRange)(yyv9), d)
+ z.DecFallback(x.Port, false)
}
}
for {
@@ -16718,7 +14883,7 @@ func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicyPeer) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -16735,11 +14900,13 @@ func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
+ yyq2[0] = x.PodSelector != nil
+ yyq2[1] = x.NamespaceSelector != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
} else {
- yynn2 = 2
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -16750,40 +14917,72 @@ func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4 := z.EncBinary()
- _ = yym4
- if false {
+ if yyq2[0] {
+ if x.PodSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.PodSelector) {
+ } else {
+ z.EncFallback(x.PodSelector)
+ }
+ }
} else {
- r.EncodeInt(int64(x.Min))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("min"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else {
- r.EncodeInt(int64(x.Min))
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.PodSelector) {
+ } else {
+ z.EncFallback(x.PodSelector)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym7 := z.EncBinary()
- _ = yym7
- if false {
+ if yyq2[1] {
+ if x.NamespaceSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
+ } else {
+ z.EncFallback(x.NamespaceSelector)
+ }
+ }
} else {
- r.EncodeInt(int64(x.Max))
+ r.EncodeNil()
}
} else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("max"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeInt(int64(x.Max))
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("namespaceSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.NamespaceSelector == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
+ } else {
+ z.EncFallback(x.NamespaceSelector)
+ }
+ }
}
}
if yyr2 || yy2arr2 {
@@ -16795,7 +14994,7 @@ func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *IDRange) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicyPeer) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16825,7 +15024,7 @@ func (x *IDRange) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyPeer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -16847,17 +15046,39 @@ func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "min":
+ case "podSelector":
if r.TryDecodeAsNil() {
- x.Min = 0
+ if x.PodSelector != nil {
+ x.PodSelector = nil
+ }
} else {
- x.Min = int64(r.DecodeInt(64))
+ if x.PodSelector == nil {
+ x.PodSelector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.PodSelector) {
+ } else {
+ z.DecFallback(x.PodSelector, false)
+ }
}
- case "max":
+ case "namespaceSelector":
if r.TryDecodeAsNil() {
- x.Max = 0
+ if x.NamespaceSelector != nil {
+ x.NamespaceSelector = nil
+ }
} else {
- x.Max = int64(r.DecodeInt(64))
+ if x.NamespaceSelector == nil {
+ x.NamespaceSelector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
+ } else {
+ z.DecFallback(x.NamespaceSelector, false)
+ }
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -16866,88 +15087,84 @@ func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *IDRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyPeer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Min = 0
+ if x.PodSelector != nil {
+ x.PodSelector = nil
+ }
} else {
- x.Min = int64(r.DecodeInt(64))
+ if x.PodSelector == nil {
+ x.PodSelector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.PodSelector) {
+ } else {
+ z.DecFallback(x.PodSelector, false)
+ }
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Max = 0
+ if x.NamespaceSelector != nil {
+ x.NamespaceSelector = nil
+ }
} else {
- x.Max = int64(r.DecodeInt(64))
+ if x.NamespaceSelector == nil {
+ x.NamespaceSelector = new(pkg1_unversioned.LabelSelector)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
+ } else {
+ z.DecFallback(x.NamespaceSelector, false)
+ }
}
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb8 = r.CheckBreak()
}
- if yyb6 {
+ if yyb8 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj8-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- yym1 := z.EncBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.EncExt(x) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x))
- }
-}
-
-func (x *RunAsUserStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
- yym1 := z.DecBinary()
- _ = yym1
- if false {
- } else if z.HasExtensions() && z.DecExt(x) {
- } else {
- *((*string)(x)) = r.DecodeString()
- }
-}
-
-func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *NetworkPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17018,7 +15235,7 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym9
if false {
} else {
- h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
}
}
} else {
@@ -17032,7 +15249,7 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym10
if false {
} else {
- h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
}
}
}
@@ -17095,7 +15312,7 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *NetworkPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17125,7 +15342,7 @@ func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17169,7 +15386,7 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decod
_ = yym7
if false {
} else {
- h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv6), d)
+ h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv6), d)
}
}
case "kind":
@@ -17191,7 +15408,7 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *NetworkPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17240,7 +15457,7 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Dec
_ = yym14
if false {
} else {
- h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv13), d)
+ h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv13), d)
}
}
yyj10++
@@ -17273,25 +15490,144 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if r.TryDecodeAsNil() {
x.APIVersion = ""
} else {
- x.APIVersion = string(r.DecodeString())
- }
- for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []CustomMetricTarget{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]CustomMetricTarget, yyrl1)
+ }
+ } else {
+ yyv1 = make([]CustomMetricTarget, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, CustomMetricTarget{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, CustomMetricTarget{}) // var yyz1 CustomMetricTarget
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
}
- if yyb10 {
- break
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []CustomMetricTarget{}
+ yyc1 = true
}
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
}
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
}
-func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17304,7 +15640,7 @@ func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *c
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurrentStatus, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17315,7 +15651,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []CustomMetricTarget{}
+ yyv1 = []CustomMetricCurrentStatus{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17330,15 +15666,15 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]CustomMetricTarget, yyrl1)
+ yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
}
} else {
- yyv1 = make([]CustomMetricTarget, yyrl1)
+ yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17353,7 +15689,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17362,10 +15698,10 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, CustomMetricTarget{})
+ yyv1 = append(yyv1, CustomMetricCurrentStatus{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17379,13 +15715,13 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, CustomMetricTarget{}) // var yyz1 CustomMetricTarget
+ yyv1 = append(yyv1, CustomMetricCurrentStatus{}) // var yyz1 CustomMetricCurrentStatus
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17400,7 +15736,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []CustomMetricTarget{}
+ yyv1 = []CustomMetricCurrentStatus{}
yyc1 = true
}
}
@@ -17410,7 +15746,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
}
}
-func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17423,7 +15759,7 @@ func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurre
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurrentStatus, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17434,7 +15770,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []CustomMetricCurrentStatus{}
+ yyv1 = []APIVersion{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17449,15 +15785,15 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ yyv1 = make([]APIVersion, yyrl1)
}
} else {
- yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ yyv1 = make([]APIVersion, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17472,7 +15808,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = APIVersion{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17481,10 +15817,10 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, CustomMetricCurrentStatus{})
+ yyv1 = append(yyv1, APIVersion{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = APIVersion{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17498,13 +15834,13 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, CustomMetricCurrentStatus{}) // var yyz1 CustomMetricCurrentStatus
+ yyv1 = append(yyv1, APIVersion{}) // var yyz1 APIVersion
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = APIVersion{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17519,7 +15855,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []CustomMetricCurrentStatus{}
+ yyv1 = []APIVersion{}
yyc1 = true
}
}
@@ -17529,7 +15865,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
}
}
-func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutoscaler, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17542,7 +15878,7 @@ func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutosc
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutoscaler, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17553,7 +15889,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HorizontalPodAutoscaler{}
+ yyv1 = []ThirdPartyResource{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17568,15 +15904,15 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 320)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ yyv1 = make([]ThirdPartyResource, yyrl1)
}
} else {
- yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ yyv1 = make([]ThirdPartyResource, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17591,7 +15927,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17600,10 +15936,10 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HorizontalPodAutoscaler{})
+ yyv1 = append(yyv1, ThirdPartyResource{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17617,13 +15953,13 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HorizontalPodAutoscaler{}) // var yyz1 HorizontalPodAutoscaler
+ yyv1 = append(yyv1, ThirdPartyResource{}) // var yyz1 ThirdPartyResource
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17638,7 +15974,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HorizontalPodAutoscaler{}
+ yyv1 = []ThirdPartyResource{}
yyc1 = true
}
}
@@ -17648,7 +15984,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
}
}
-func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17661,7 +15997,7 @@ func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17672,7 +16008,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []APIVersion{}
+ yyv1 = []Deployment{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17687,15 +16023,15 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 768)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]APIVersion, yyrl1)
+ yyv1 = make([]Deployment, yyrl1)
}
} else {
- yyv1 = make([]APIVersion, yyrl1)
+ yyv1 = make([]Deployment, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17710,7 +16046,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17719,10 +16055,10 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, APIVersion{})
+ yyv1 = append(yyv1, Deployment{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17736,13 +16072,13 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, APIVersion{}) // var yyz1 APIVersion
+ yyv1 = append(yyv1, Deployment{}) // var yyz1 Deployment
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17757,7 +16093,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []APIVersion{}
+ yyv1 = []Deployment{}
yyc1 = true
}
}
@@ -17767,7 +16103,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17780,7 +16116,7 @@ func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *c
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17791,7 +16127,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ThirdPartyResource{}
+ yyv1 = []DaemonSet{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17806,15 +16142,15 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 232)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 696)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ThirdPartyResource, yyrl1)
+ yyv1 = make([]DaemonSet, yyrl1)
}
} else {
- yyv1 = make([]ThirdPartyResource, yyrl1)
+ yyv1 = make([]DaemonSet, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17829,7 +16165,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17838,10 +16174,10 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ThirdPartyResource{})
+ yyv1 = append(yyv1, DaemonSet{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17855,13 +16191,13 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ThirdPartyResource{}) // var yyz1 ThirdPartyResource
+ yyv1 = append(yyv1, DaemonSet{}) // var yyz1 DaemonSet
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17876,7 +16212,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ThirdPartyResource{}
+ yyv1 = []DaemonSet{}
yyc1 = true
}
}
@@ -17886,7 +16222,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
}
}
-func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -17899,7 +16235,7 @@ func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -17910,7 +16246,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Deployment{}
+ yyv1 = []ThirdPartyResourceData{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -17925,15 +16261,15 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 632)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Deployment, yyrl1)
+ yyv1 = make([]ThirdPartyResourceData, yyrl1)
}
} else {
- yyv1 = make([]Deployment, yyrl1)
+ yyv1 = make([]ThirdPartyResourceData, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -17948,7 +16284,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -17957,10 +16293,10 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Deployment{})
+ yyv1 = append(yyv1, ThirdPartyResourceData{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -17974,13 +16310,13 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Deployment{}) // var yyz1 Deployment
+ yyv1 = append(yyv1, ThirdPartyResourceData{}) // var yyz1 ThirdPartyResourceData
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -17995,7 +16331,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Deployment{}
+ yyv1 = []ThirdPartyResourceData{}
yyc1 = true
}
}
@@ -18005,7 +16341,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18018,7 +16354,7 @@ func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder)
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18029,7 +16365,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []DaemonSet{}
+ yyv1 = []Ingress{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18044,15 +16380,15 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 552)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 320)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]DaemonSet, yyrl1)
+ yyv1 = make([]Ingress, yyrl1)
}
} else {
- yyv1 = make([]DaemonSet, yyrl1)
+ yyv1 = make([]Ingress, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18067,7 +16403,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18076,10 +16412,10 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, DaemonSet{})
+ yyv1 = append(yyv1, Ingress{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18093,13 +16429,13 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, DaemonSet{}) // var yyz1 DaemonSet
+ yyv1 = append(yyv1, Ingress{}) // var yyz1 Ingress
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18114,7 +16450,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []DaemonSet{}
+ yyv1 = []Ingress{}
yyc1 = true
}
}
@@ -18124,7 +16460,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
}
}
-func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18137,7 +16473,7 @@ func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceDa
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18148,7 +16484,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ThirdPartyResourceData{}
+ yyv1 = []IngressTLS{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18163,15 +16499,15 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ThirdPartyResourceData, yyrl1)
+ yyv1 = make([]IngressTLS, yyrl1)
}
} else {
- yyv1 = make([]ThirdPartyResourceData, yyrl1)
+ yyv1 = make([]IngressTLS, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18186,7 +16522,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18195,10 +16531,10 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ThirdPartyResourceData{})
+ yyv1 = append(yyv1, IngressTLS{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18212,13 +16548,13 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ThirdPartyResourceData{}) // var yyz1 ThirdPartyResourceData
+ yyv1 = append(yyv1, IngressTLS{}) // var yyz1 IngressTLS
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18233,7 +16569,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ThirdPartyResourceData{}
+ yyv1 = []IngressTLS{}
yyc1 = true
}
}
@@ -18243,7 +16579,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
}
}
-func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18256,7 +16592,7 @@ func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18267,7 +16603,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Job{}
+ yyv1 = []IngressRule{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18282,15 +16618,15 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 624)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Job, yyrl1)
+ yyv1 = make([]IngressRule, yyrl1)
}
} else {
- yyv1 = make([]Job, yyrl1)
+ yyv1 = make([]IngressRule, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18305,7 +16641,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18314,10 +16650,10 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Job{})
+ yyv1 = append(yyv1, IngressRule{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18331,13 +16667,13 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Job{}) // var yyz1 Job
+ yyv1 = append(yyv1, IngressRule{}) // var yyz1 IngressRule
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18352,7 +16688,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Job{}
+ yyv1 = []IngressRule{}
yyc1 = true
}
}
@@ -18362,7 +16698,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18375,7 +16711,7 @@ func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Enc
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18386,7 +16722,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []JobCondition{}
+ yyv1 = []HTTPIngressPath{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18401,15 +16737,15 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]JobCondition, yyrl1)
+ yyv1 = make([]HTTPIngressPath, yyrl1)
}
} else {
- yyv1 = make([]JobCondition, yyrl1)
+ yyv1 = make([]HTTPIngressPath, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18424,7 +16760,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18433,10 +16769,10 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, JobCondition{})
+ yyv1 = append(yyv1, HTTPIngressPath{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18450,13 +16786,13 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, JobCondition{}) // var yyz1 JobCondition
+ yyv1 = append(yyv1, HTTPIngressPath{}) // var yyz1 HTTPIngressPath
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18471,7 +16807,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []JobCondition{}
+ yyv1 = []HTTPIngressPath{}
yyc1 = true
}
}
@@ -18481,7 +16817,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
}
}
-func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18494,7 +16830,7 @@ func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18505,7 +16841,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Ingress{}
+ yyv1 = []ReplicaSet{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18520,15 +16856,15 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 272)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 704)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Ingress, yyrl1)
+ yyv1 = make([]ReplicaSet, yyrl1)
}
} else {
- yyv1 = make([]Ingress, yyrl1)
+ yyv1 = make([]ReplicaSet, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18543,7 +16879,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18552,10 +16888,10 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Ingress{})
+ yyv1 = append(yyv1, ReplicaSet{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18569,13 +16905,13 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Ingress{}) // var yyz1 Ingress
+ yyv1 = append(yyv1, ReplicaSet{}) // var yyz1 ReplicaSet
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18590,7 +16926,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Ingress{}
+ yyv1 = []ReplicaSet{}
yyc1 = true
}
}
@@ -18600,20 +16936,20 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceapi_Capability(v []pkg2_api.Capability, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy2 := &yyv1
- yy2.CodecEncodeSelf(e)
+ yysf2 := &yyv1
+ yysf2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18624,7 +16960,7 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IngressTLS{}
+ yyv1 = []pkg2_api.Capability{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18637,23 +16973,18 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrg1 := len(yyv1) > 0
- yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IngressTLS, yyrl1)
+ yyv1 = make([]pkg2_api.Capability, yyrl1)
}
} else {
- yyv1 = make([]IngressTLS, yyrl1)
+ yyv1 = make([]pkg2_api.Capability, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
- if yyrg1 {
- copy(yyv1, yyv21)
- }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -18662,22 +16993,20 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ""
} else {
- yyv2 := &yyv1[yyj1]
- yyv2.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IngressTLS{})
+ yyv1 = append(yyv1, "")
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ""
} else {
- yyv3 := &yyv1[yyj1]
- yyv3.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
}
}
@@ -18688,16 +17017,15 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IngressTLS{}) // var yyz1 IngressTLS
+ yyv1 = append(yyv1, "") // var yyz1 pkg2_api.Capability
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ""
} else {
- yyv4 := &yyv1[yyj1]
- yyv4.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
}
} else {
@@ -18709,7 +17037,7 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IngressTLS{}
+ yyv1 = []pkg2_api.Capability{}
yyc1 = true
}
}
@@ -18719,20 +17047,19 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy2 := &yyv1
- yy2.CodecEncodeSelf(e)
+ yyv1.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18743,7 +17070,7 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IngressRule{}
+ yyv1 = []FSType{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18756,23 +17083,18 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrg1 := len(yyv1) > 0
- yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IngressRule, yyrl1)
+ yyv1 = make([]FSType, yyrl1)
}
} else {
- yyv1 = make([]IngressRule, yyrl1)
+ yyv1 = make([]FSType, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
- if yyrg1 {
- copy(yyv1, yyv21)
- }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -18781,22 +17103,20 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv2 := &yyv1[yyj1]
- yyv2.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IngressRule{})
+ yyv1 = append(yyv1, "")
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv3 := &yyv1[yyj1]
- yyv3.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
}
@@ -18807,16 +17127,15 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IngressRule{}) // var yyz1 IngressRule
+ yyv1 = append(yyv1, "") // var yyz1 FSType
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv4 := &yyv1[yyj1]
- yyv4.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
} else {
@@ -18828,7 +17147,7 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IngressRule{}
+ yyv1 = []FSType{}
yyc1 = true
}
}
@@ -18838,7 +17157,7 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
}
}
-func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18851,7 +17170,7 @@ func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec19
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18862,7 +17181,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HTTPIngressPath{}
+ yyv1 = []HostPortRange{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18877,15 +17196,15 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HTTPIngressPath, yyrl1)
+ yyv1 = make([]HostPortRange, yyrl1)
}
} else {
- yyv1 = make([]HTTPIngressPath, yyrl1)
+ yyv1 = make([]HostPortRange, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18900,7 +17219,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18909,10 +17228,10 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HTTPIngressPath{})
+ yyv1 = append(yyv1, HostPortRange{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18926,13 +17245,13 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HTTPIngressPath{}) // var yyz1 HTTPIngressPath
+ yyv1 = append(yyv1, HostPortRange{}) // var yyz1 HostPortRange
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18947,7 +17266,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HTTPIngressPath{}
+ yyv1 = []HostPortRange{}
yyc1 = true
}
}
@@ -18957,7 +17276,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
}
}
-func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18970,7 +17289,7 @@ func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18981,7 +17300,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ReplicaSet{}
+ yyv1 = []IDRange{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18996,15 +17315,15 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 560)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ReplicaSet, yyrl1)
+ yyv1 = make([]IDRange, yyrl1)
}
} else {
- yyv1 = make([]ReplicaSet, yyrl1)
+ yyv1 = make([]IDRange, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19019,7 +17338,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19028,10 +17347,10 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ReplicaSet{})
+ yyv1 = append(yyv1, IDRange{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19045,13 +17364,13 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ReplicaSet{}) // var yyz1 ReplicaSet
+ yyv1 = append(yyv1, IDRange{}) // var yyz1 IDRange
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19066,7 +17385,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ReplicaSet{}
+ yyv1 = []IDRange{}
yyc1 = true
}
}
@@ -19076,20 +17395,20 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceapi_Capability(v []pkg2_api.Capability, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yysf2 := &yyv1
- yysf2.CodecEncodeSelf(e)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19100,7 +17419,7 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []pkg2_api.Capability{}
+ yyv1 = []PodSecurityPolicy{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19113,18 +17432,23 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 536)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]pkg2_api.Capability, yyrl1)
+ yyv1 = make([]PodSecurityPolicy, yyrl1)
}
} else {
- yyv1 = make([]pkg2_api.Capability, yyrl1)
+ yyv1 = make([]PodSecurityPolicy, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -19133,20 +17457,22 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, "")
+ yyv1 = append(yyv1, PodSecurityPolicy{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
}
}
@@ -19157,15 +17483,16 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, "") // var yyz1 pkg2_api.Capability
+ yyv1 = append(yyv1, PodSecurityPolicy{}) // var yyz1 PodSecurityPolicy
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_api.Capability(r.DecodeString())
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
}
} else {
@@ -19177,7 +17504,7 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []pkg2_api.Capability{}
+ yyv1 = []PodSecurityPolicy{}
yyc1 = true
}
}
@@ -19187,19 +17514,20 @@ func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *cod
}
}
-func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyIngressRule(v []NetworkPolicyIngressRule, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv1.CodecEncodeSelf(e)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyIngressRule(v *[]NetworkPolicyIngressRule, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19210,7 +17538,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []FSType{}
+ yyv1 = []NetworkPolicyIngressRule{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19223,18 +17551,23 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]FSType, yyrl1)
+ yyv1 = make([]NetworkPolicyIngressRule, yyrl1)
}
} else {
- yyv1 = make([]FSType, yyrl1)
+ yyv1 = make([]NetworkPolicyIngressRule, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -19243,20 +17576,22 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, "")
+ yyv1 = append(yyv1, NetworkPolicyIngressRule{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
}
}
@@ -19267,15 +17602,16 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, "") // var yyz1 FSType
+ yyv1 = append(yyv1, NetworkPolicyIngressRule{}) // var yyz1 NetworkPolicyIngressRule
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
}
} else {
@@ -19287,7 +17623,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []FSType{}
+ yyv1 = []NetworkPolicyIngressRule{}
yyc1 = true
}
}
@@ -19297,7 +17633,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyPort(v []NetworkPolicyPort, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19310,7 +17646,7 @@ func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.E
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyPort(v *[]NetworkPolicyPort, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19321,7 +17657,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HostPortRange{}
+ yyv1 = []NetworkPolicyPort{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19341,10 +17677,10 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HostPortRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPort, yyrl1)
}
} else {
- yyv1 = make([]HostPortRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPort, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19359,7 +17695,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19368,10 +17704,10 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HostPortRange{})
+ yyv1 = append(yyv1, NetworkPolicyPort{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19385,13 +17721,13 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HostPortRange{}) // var yyz1 HostPortRange
+ yyv1 = append(yyv1, NetworkPolicyPort{}) // var yyz1 NetworkPolicyPort
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19406,7 +17742,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HostPortRange{}
+ yyv1 = []NetworkPolicyPort{}
yyc1 = true
}
}
@@ -19416,7 +17752,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
}
}
-func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyPeer(v []NetworkPolicyPeer, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19429,7 +17765,7 @@ func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyPeer(v *[]NetworkPolicyPeer, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19440,7 +17776,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IDRange{}
+ yyv1 = []NetworkPolicyPeer{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19460,10 +17796,10 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IDRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPeer, yyrl1)
}
} else {
- yyv1 = make([]IDRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPeer, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19478,7 +17814,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19487,10 +17823,10 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IDRange{})
+ yyv1 = append(yyv1, NetworkPolicyPeer{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19504,13 +17840,13 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IDRange{}) // var yyz1 IDRange
+ yyv1 = append(yyv1, NetworkPolicyPeer{}) // var yyz1 NetworkPolicyPeer
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19525,7 +17861,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IDRange{}
+ yyv1 = []NetworkPolicyPeer{}
yyc1 = true
}
}
@@ -19535,7 +17871,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicy(v []NetworkPolicy, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19548,7 +17884,7 @@ func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *cod
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicy(v *[]NetworkPolicy, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19559,7 +17895,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []PodSecurityPolicy{}
+ yyv1 = []NetworkPolicy{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19574,15 +17910,15 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]PodSecurityPolicy, yyrl1)
+ yyv1 = make([]NetworkPolicy, yyrl1)
}
} else {
- yyv1 = make([]PodSecurityPolicy, yyrl1)
+ yyv1 = make([]NetworkPolicy, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19597,7 +17933,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19606,10 +17942,10 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, PodSecurityPolicy{})
+ yyv1 = append(yyv1, NetworkPolicy{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19623,13 +17959,13 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, PodSecurityPolicy{}) // var yyz1 PodSecurityPolicy
+ yyv1 = append(yyv1, NetworkPolicy{}) // var yyz1 NetworkPolicy
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19644,7 +17980,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []PodSecurityPolicy{}
+ yyv1 = []NetworkPolicy{}
yyc1 = true
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/types.go
similarity index 73%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/types.go
index 3383d7d21196a2129f489246bb8ca29108f745e3..9db03ab7ce8c6d6cfc0358d82bccbf163890c4c3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/types.go
@@ -38,16 +38,16 @@ import (
// describes the attributes of a scale subresource
type ScaleSpec struct {
// desired number of instances for the scaled object.
- Replicas int `json:"replicas,omitempty"`
+ Replicas int32 `json:"replicas,omitempty"`
}
// represents the current status of a scale subresource.
type ScaleStatus struct {
// actual number of observed instances of the scaled object.
- Replicas int `json:"replicas"`
+ Replicas int32 `json:"replicas"`
// label query over pods that should match the replicas count.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
Selector *unversioned.LabelSelector `json:"selector,omitempty"`
}
@@ -56,13 +56,13 @@ type ScaleStatus struct {
// represents a scaling request for a resource.
type Scale struct {
unversioned.TypeMeta `json:",inline"`
- // Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
api.ObjectMeta `json:"metadata,omitempty"`
- // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
Spec ScaleSpec `json:"spec,omitempty"`
- // current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
Status ScaleStatus `json:"status,omitempty"`
}
@@ -71,24 +71,6 @@ type ReplicationControllerDummy struct {
unversioned.TypeMeta `json:",inline"`
}
-// SubresourceReference contains enough information to let you inspect or modify the referred subresource.
-type SubresourceReference struct {
- // Kind of the referent; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds"
- Kind string `json:"kind,omitempty"`
- // Name of the referent; More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name,omitempty"`
- // API version of the referent
- APIVersion string `json:"apiVersion,omitempty"`
- // Subresource name of the referent
- Subresource string `json:"subresource,omitempty"`
-}
-
-type CPUTargetUtilization struct {
- // fraction of the requested CPU that should be utilized/used,
- // e.g. 70 means that 70% of the requested CPU should be in use.
- TargetPercentage int `json:"targetPercentage"`
-}
-
// Alpha-level support for Custom Metrics in HPA (as annotations).
type CustomMetricTarget struct {
// Custom Metric name.
@@ -112,64 +94,7 @@ type CustomMetricCurrentStatusList struct {
Items []CustomMetricCurrentStatus `json:"items"`
}
-// specification of a horizontal pod autoscaler.
-type HorizontalPodAutoscalerSpec struct {
- // reference to Scale subresource; horizontal pod autoscaler will learn the current resource consumption from its status,
- // and will set the desired number of pods by modifying its spec.
- ScaleRef SubresourceReference `json:"scaleRef"`
- // lower limit for the number of pods that can be set by the autoscaler, default 1.
- MinReplicas *int `json:"minReplicas,omitempty"`
- // upper limit for the number of pods that can be set by the autoscaler. It cannot be smaller than MinReplicas.
- MaxReplicas int `json:"maxReplicas"`
- // target average CPU utilization (represented as a percentage of requested CPU) over all the pods;
- // if not specified it defaults to the target CPU utilization at 80% of the requested resources.
- CPUUtilization *CPUTargetUtilization `json:"cpuUtilization,omitempty"`
-}
-
-// current status of a horizontal pod autoscaler
-type HorizontalPodAutoscalerStatus struct {
- // most recent generation observed by this autoscaler.
- ObservedGeneration *int64 `json:"observedGeneration,omitempty"`
-
- // last time the HorizontalPodAutoscaler scaled the number of pods;
- // used by the autoscaler to control how often the number of pods is changed.
- LastScaleTime *unversioned.Time `json:"lastScaleTime,omitempty"`
-
- // current number of replicas of pods managed by this autoscaler.
- CurrentReplicas int `json:"currentReplicas"`
-
- // desired number of replicas of pods managed by this autoscaler.
- DesiredReplicas int `json:"desiredReplicas"`
-
- // 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.
- CurrentCPUUtilizationPercentage *int `json:"currentCPUUtilizationPercentage,omitempty"`
-}
-
-// +genclient=true
-
-// configuration of a horizontal pod autoscaler.
-type HorizontalPodAutoscaler struct {
- unversioned.TypeMeta `json:",inline"`
- api.ObjectMeta `json:"metadata,omitempty"`
-
- // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
- Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty"`
-
- // current information about the autoscaler.
- Status HorizontalPodAutoscalerStatus `json:"status,omitempty"`
-}
-
-// list of horizontal pod autoscaler objects.
-type HorizontalPodAutoscalerList struct {
- unversioned.TypeMeta `json:",inline"`
- unversioned.ListMeta `json:"metadata,omitempty"`
-
- // list of horizontal pod autoscaler objects.
- Items []HorizontalPodAutoscaler `json:"items"`
-}
-
-// +genclient=true
+// +genclient=true,nonNamespaced=true
// A ThirdPartyResource is a generic representation of a resource, it is used by add-ons and plugins to add new resource
// types to the API. It consists of one or more Versions of the api.
@@ -201,9 +126,6 @@ type ThirdPartyResourceList struct {
type APIVersion struct {
// Name of this version (e.g. 'v1').
Name string `json:"name,omitempty"`
-
- // The API group to add this object into, default 'experimental'.
- APIGroup string `json:"apiGroup,omitempty"`
}
// An internal object, used for versioned storage in etcd. Not exposed to the end user.
@@ -232,7 +154,7 @@ type Deployment struct {
type DeploymentSpec struct {
// Number of desired pods. This is a pointer to distinguish between explicit
// zero and not specified. Defaults to 1.
- Replicas int `json:"replicas,omitempty"`
+ Replicas int32 `json:"replicas,omitempty"`
// Label selector for pods. Existing ReplicaSets whose pods are
// selected by this will be the ones affected by this deployment.
@@ -247,11 +169,11 @@ type DeploymentSpec struct {
// 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)
- MinReadySeconds int `json:"minReadySeconds,omitempty"`
+ MinReadySeconds int32 `json:"minReadySeconds,omitempty"`
// The number of old ReplicaSets to retain to allow rollback.
// This is a pointer to distinguish between explicit zero and not specified.
- RevisionHistoryLimit *int `json:"revisionHistoryLimit,omitempty"`
+ RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"`
// Indicates that the deployment is paused and will not be processed by the
// deployment controller.
@@ -337,16 +259,16 @@ type DeploymentStatus struct {
ObservedGeneration int64 `json:"observedGeneration,omitempty"`
// Total number of non-terminated pods targeted by this deployment (their labels match the selector).
- Replicas int `json:"replicas,omitempty"`
+ Replicas int32 `json:"replicas,omitempty"`
// Total number of non-terminated pods targeted by this deployment that have the desired template spec.
- UpdatedReplicas int `json:"updatedReplicas,omitempty"`
+ UpdatedReplicas int32 `json:"updatedReplicas,omitempty"`
// Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.
- AvailableReplicas int `json:"availableReplicas,omitempty"`
+ AvailableReplicas int32 `json:"availableReplicas,omitempty"`
// Total number of unavailable pods targeted by this deployment.
- UnavailableReplicas int `json:"unavailableReplicas,omitempty"`
+ UnavailableReplicas int32 `json:"unavailableReplicas,omitempty"`
}
type DeploymentList struct {
@@ -408,14 +330,14 @@ type DaemonSetSpec struct {
// Selector is a label query over pods that are managed by the daemon set.
// Must match in order to be controlled.
// If empty, defaulted to labels on Pod template.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
Selector *unversioned.LabelSelector `json:"selector,omitempty"`
// Template is the 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: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
Template api.PodTemplateSpec `json:"template"`
// TODO(madhusudancs): Uncomment while implementing DaemonSet updates.
@@ -445,15 +367,15 @@ const (
type DaemonSetStatus struct {
// CurrentNumberScheduled is the number of nodes that are running at least 1
// daemon pod and are supposed to run the daemon pod.
- CurrentNumberScheduled int `json:"currentNumberScheduled"`
+ CurrentNumberScheduled int32 `json:"currentNumberScheduled"`
// NumberMisscheduled is the number of nodes that are running the daemon pod, but are
// not supposed to run the daemon pod.
- NumberMisscheduled int `json:"numberMisscheduled"`
+ NumberMisscheduled int32 `json:"numberMisscheduled"`
// DesiredNumberScheduled is the total number of nodes that should be running the daemon
// pod (including nodes correctly running the daemon pod).
- DesiredNumberScheduled int `json:"desiredNumberScheduled"`
+ DesiredNumberScheduled int32 `json:"desiredNumberScheduled"`
}
// +genclient=true
@@ -462,18 +384,18 @@ type DaemonSetStatus struct {
type DaemonSet struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
api.ObjectMeta `json:"metadata,omitempty"`
// Spec defines the desired behavior of this daemon set.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
Spec DaemonSetSpec `json:"spec,omitempty"`
// Status is 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
Status DaemonSetStatus `json:"status,omitempty"`
}
@@ -481,7 +403,7 @@ type DaemonSet struct {
type DaemonSetList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
unversioned.ListMeta `json:"metadata,omitempty"`
// Items is a list of daemon sets.
@@ -491,7 +413,7 @@ type DaemonSetList struct {
type ThirdPartyResourceDataList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
unversioned.ListMeta `json:"metadata,omitempty"`
// Items is a list of third party objects
Items []ThirdPartyResourceData `json:"items"`
@@ -499,127 +421,6 @@ type ThirdPartyResourceDataList struct {
// +genclient=true
-// Job represents the configuration of a single job.
-type Job struct {
- unversioned.TypeMeta `json:",inline"`
- // Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- api.ObjectMeta `json:"metadata,omitempty"`
-
- // Spec is a structure defining the expected behavior of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec JobSpec `json:"spec,omitempty"`
-
- // Status is a structure describing current status of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status JobStatus `json:"status,omitempty"`
-}
-
-// JobList is a collection of jobs.
-type JobList struct {
- unversioned.TypeMeta `json:",inline"`
- // Standard list metadata
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
-
- // Items is the list of Job.
- Items []Job `json:"items"`
-}
-
-// JobSpec describes how the job execution will look like.
-type JobSpec struct {
-
- // Parallelism 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.
- Parallelism *int `json:"parallelism,omitempty"`
-
- // Completions 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.
- Completions *int `json:"completions,omitempty"`
-
- // Optional duration in seconds relative to the startTime that the job may be active
- // before the system tries to terminate it; value must be positive integer
- ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`
-
- // Selector is a label query over pods that should match the pod count.
- // Normally, the system sets this field for you.
- Selector *unversioned.LabelSelector `json:"selector,omitempty"`
-
- // 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.
- ManualSelector *bool `json:"manualSelector,omitempty"`
-
- // Template is the object that describes the pod that will be created when
- // executing a job.
- Template api.PodTemplateSpec `json:"template"`
-}
-
-// JobStatus represents the current state of a Job.
-type JobStatus struct {
-
- // Conditions represent the latest available observations of an object's current state.
- Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
-
- // StartTime represents time when the job was acknowledged by the Job Manager.
- // It is not guaranteed to be set in happens-before order across separate operations.
- // It is represented in RFC3339 form and is in UTC.
- StartTime *unversioned.Time `json:"startTime,omitempty"`
-
- // CompletionTime 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.
- CompletionTime *unversioned.Time `json:"completionTime,omitempty"`
-
- // Active is the number of actively running pods.
- Active int `json:"active,omitempty"`
-
- // Succeeded is the number of pods which reached Phase Succeeded.
- Succeeded int `json:"succeeded,omitempty"`
-
- // Failed is the number of pods which reached Phase Failed.
- Failed int `json:"failed,omitempty"`
-}
-
-type JobConditionType string
-
-// These are valid conditions of a job.
-const (
- // JobComplete means the job has completed its execution.
- JobComplete JobConditionType = "Complete"
- // JobFailed means the job has failed its execution.
- JobFailed JobConditionType = "Failed"
-)
-
-// JobCondition describes current state of a job.
-type JobCondition struct {
- // Type of job condition, Complete or Failed.
- Type JobConditionType `json:"type"`
- // Status of the condition, one of True, False, Unknown.
- Status api.ConditionStatus `json:"status"`
- // Last time the condition was checked.
- LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
- // Last time the condition transit from one status to another.
- LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
- // (brief) reason for the condition's last transition.
- Reason string `json:"reason,omitempty"`
- // Human readable message indicating details about last transition.
- Message string `json:"message,omitempty"`
-}
-
-// +genclient=true
-
// 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
@@ -627,15 +428,15 @@ type JobCondition struct {
type Ingress struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
api.ObjectMeta `json:"metadata,omitempty"`
// Spec is the desired state of the Ingress.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
Spec IngressSpec `json:"spec,omitempty"`
// Status is the current state of the Ingress.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
Status IngressStatus `json:"status,omitempty"`
}
@@ -643,7 +444,7 @@ type Ingress struct {
type IngressList struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
unversioned.ListMeta `json:"metadata,omitempty"`
// Items is the list of Ingress.
@@ -798,12 +599,12 @@ type ReplicaSetList struct {
// a Template set.
type ReplicaSetSpec struct {
// Replicas is the number of desired replicas.
- Replicas int `json:"replicas"`
+ Replicas int32 `json:"replicas"`
// Selector is a label query over pods that should match the replica count.
// Must match in order to be controlled.
// If empty, defaulted to labels on pod template.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
Selector *unversioned.LabelSelector `json:"selector,omitempty"`
// Template is the object that describes the pod that will be created if
@@ -814,15 +615,17 @@ type ReplicaSetSpec struct {
// ReplicaSetStatus represents the current status of a ReplicaSet.
type ReplicaSetStatus struct {
// Replicas is the number of actual replicas.
- Replicas int `json:"replicas"`
+ Replicas int32 `json:"replicas"`
// The number of pods that have labels matching the labels of the pod template of the replicaset.
- FullyLabeledReplicas int `json:"fullyLabeledReplicas,omitempty"`
+ FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`
// ObservedGeneration is the most recent generation observed by the controller.
ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}
+// +genclient=true,nonNamespaced=true
+
// PodSecurityPolicy governs the ability to make requests that affect the SecurityContext
// that will be applied to a pod and container.
type PodSecurityPolicy struct {
@@ -837,8 +640,17 @@ type PodSecurityPolicy struct {
type PodSecurityPolicySpec struct {
// Privileged determines if a pod can request to be run as privileged.
Privileged bool `json:"privileged,omitempty"`
- // Capabilities is a list of capabilities that can be added.
- Capabilities []api.Capability `json:"capabilities,omitempty"`
+ // 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 capabiility in both
+ // DefaultAddCapabilities and RequiredDropCapabilities.
+ DefaultAddCapabilities []api.Capability `json:"defaultAddCapabilities,omitempty"`
+ // RequiredDropCapabilities are the capabilities that will be dropped from the container. These
+ // are required to be dropped and cannot be added.
+ RequiredDropCapabilities []api.Capability `json:"requiredDropCapabilities,omitempty"`
+ // 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.
+ AllowedCapabilities []api.Capability `json:"allowedCapabilities,omitempty"`
// Volumes is a white list of allowed volume plugins. Empty indicates that all plugins
// may be used.
Volumes []FSType `json:"volumes,omitempty"`
@@ -851,9 +663,19 @@ type PodSecurityPolicySpec struct {
// HostIPC determines if the policy allows the use of HostIPC in the pod spec.
HostIPC bool `json:"hostIPC,omitempty"`
// SELinux is the strategy that will dictate the allowable labels that may be set.
- SELinux SELinuxStrategyOptions `json:"seLinux,omitempty"`
+ SELinux SELinuxStrategyOptions `json:"seLinux"`
// RunAsUser is the strategy that will dictate the allowable RunAsUser values that may be set.
- RunAsUser RunAsUserStrategyOptions `json:"runAsUser,omitempty"`
+ RunAsUser RunAsUserStrategyOptions `json:"runAsUser"`
+ // SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext.
+ SupplementalGroups SupplementalGroupsStrategyOptions `json:"supplementalGroups"`
+ // FSGroup is the strategy that will dictate what fs group is used by the SecurityContext.
+ FSGroup FSGroupStrategyOptions `json:"fsGroup"`
+ // 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.
+ ReadOnlyRootFilesystem bool `json:"readOnlyRootFilesystem,omitempty"`
}
// HostPortRange defines a range of host ports that will be enabled by a policy
@@ -869,6 +691,9 @@ type HostPortRange struct {
type FSType string
var (
+ AzureFile FSType = "azureFile"
+ Flocker FSType = "flocker"
+ FlexVolume FSType = "flexVolume"
HostPath FSType = "hostPath"
EmptyDir FSType = "emptyDir"
GCEPersistentDisk FSType = "gcePersistentDisk"
@@ -884,6 +709,9 @@ var (
CephFS FSType = "cephFS"
DownwardAPI FSType = "downwardAPI"
FC FSType = "fc"
+ ConfigMap FSType = "configMap"
+ VsphereVolume FSType = "vsphereVolume"
+ All FSType = "*"
)
// SELinuxStrategyOptions defines the strategy type and any options used to create the strategy.
@@ -891,7 +719,7 @@ type SELinuxStrategyOptions struct {
// Rule is the strategy that will dictate the allowable labels that may be set.
Rule SELinuxStrategy `json:"rule"`
// seLinuxOptions required to run as; required for MustRunAs
- // More info: http://releases.k8s.io/release-1.2/docs/design/security_context.md#security-context
+ // More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md#security-context
SELinuxOptions *api.SELinuxOptions `json:"seLinuxOptions,omitempty"`
}
@@ -935,6 +763,46 @@ const (
RunAsUserStrategyRunAsAny RunAsUserStrategy = "RunAsAny"
)
+// FSGroupStrategyOptions defines the strategy type and options used to create the strategy.
+type FSGroupStrategyOptions struct {
+ // Rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
+ Rule FSGroupStrategyType `json:"rule,omitempty"`
+ // 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.
+ Ranges []IDRange `json:"ranges,omitempty"`
+}
+
+// FSGroupStrategyType denotes strategy types for generating FSGroup values for a
+// SecurityContext
+type FSGroupStrategyType string
+
+const (
+ // container must have FSGroup of X applied.
+ FSGroupStrategyMustRunAs FSGroupStrategyType = "MustRunAs"
+ // container may make requests for any FSGroup labels.
+ FSGroupStrategyRunAsAny FSGroupStrategyType = "RunAsAny"
+)
+
+// SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy.
+type SupplementalGroupsStrategyOptions struct {
+ // Rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
+ Rule SupplementalGroupsStrategyType `json:"rule,omitempty"`
+ // 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.
+ Ranges []IDRange `json:"ranges,omitempty"`
+}
+
+// SupplementalGroupsStrategyType denotes strategy types for determining valid supplemental
+// groups for a SecurityContext.
+type SupplementalGroupsStrategyType string
+
+const (
+ // container must run as a particular gid.
+ SupplementalGroupsStrategyMustRunAs SupplementalGroupsStrategyType = "MustRunAs"
+ // container may make requests for any gid.
+ SupplementalGroupsStrategyRunAsAny SupplementalGroupsStrategyType = "RunAsAny"
+)
+
// PodSecurityPolicyList is a list of PodSecurityPolicy objects.
type PodSecurityPolicyList struct {
unversioned.TypeMeta `json:",inline"`
@@ -942,3 +810,89 @@ type PodSecurityPolicyList struct {
Items []PodSecurityPolicy `json:"items"`
}
+
+type NetworkPolicy struct {
+ unversioned.TypeMeta `json:",inline"`
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Specification of the desired behavior for this NetworkPolicy.
+ Spec NetworkPolicySpec `json:"spec,omitempty"`
+}
+
+type NetworkPolicySpec struct {
+ // 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.
+ PodSelector unversioned.LabelSelector `json:"podSelector"`
+
+ // List of ingress rules to be applied to the selected pods.
+ // Traffic is allowed to a pod if namespace.networkPolicy.ingress.isolation is undefined and cluster policy allows it,
+ // 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 affect ingress isolation.
+ // If this field is present and contains at least one rule, this policy allows any traffic
+ // which matches at least one of the ingress rules in this list.
+ Ingress []NetworkPolicyIngressRule `json:"ingress,omitempty"`
+}
+
+// This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from.
+type NetworkPolicyIngressRule struct {
+ // 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 not provided, this rule matches all ports (traffic not restricted by port).
+ // If this field is empty, this rule matches no ports (no traffic matches).
+ // 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.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ Ports []NetworkPolicyPort `json:"ports,omitempty"`
+
+ // 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 not provided, this rule matches all sources (traffic not restricted by source).
+ // If this field is empty, this rule matches no sources (no traffic matches).
+ // If this field is present and contains at least on item, this rule allows traffic only if the
+ // traffic matches at least one item in the from list.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ From []NetworkPolicyPeer `json:"from,omitempty"`
+}
+
+type NetworkPolicyPort struct {
+ // Optional. The protocol (TCP or UDP) which traffic must match.
+ // If not specified, this field defaults to TCP.
+ Protocol *api.Protocol `json:"protocol,omitempty"`
+
+ // If specified, 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.
+ Port *intstr.IntOrString `json:"port,omitempty"`
+}
+
+type NetworkPolicyPeer struct {
+ // Exactly one of the following must be specified.
+
+ // This is a label selector which selects Pods in this namespace.
+ // This field follows standard label selector semantics.
+ // If not provided, this selector selects no pods.
+ // If present but empty, this selector selects all pods in this namespace.
+ PodSelector *unversioned.LabelSelector `json:"podSelector,omitempty"`
+
+ // Selects Namespaces using cluster scoped-labels. This
+ // matches all pods in all namespaces selected by this label selector.
+ // This field follows standard label selector semantics.
+ // If omitted, this selector selects no namespaces.
+ // If present but empty, this selector selects all namespaces.
+ NamespaceSelector *unversioned.LabelSelector `json:"namespaceSelector,omitempty"`
+}
+
+// NetworkPolicyList is a list of NetworkPolicy objects.
+type NetworkPolicyList struct {
+ unversioned.TypeMeta `json:",inline"`
+ unversioned.ListMeta `json:"metadata,omitempty"`
+
+ Items []NetworkPolicy `json:"items"`
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go
similarity index 73%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go
index 5f4841cb4314b5085ccaf382a11f3e562c67317d..ad5c91c90e504543105c8b0b2995c8efab756626 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion.go
@@ -18,11 +18,12 @@ package v1beta1
import (
"fmt"
- "reflect"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
v1 "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/autoscaling"
+ "k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime"
@@ -32,8 +33,6 @@ import (
func addConversionFuncs(scheme *runtime.Scheme) {
// Add non-generated conversion functions
err := scheme.AddConversionFuncs(
- Convert_api_PodSpec_To_v1_PodSpec,
- Convert_v1_PodSpec_To_api_PodSpec,
Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus,
Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus,
Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec,
@@ -44,8 +43,14 @@ func addConversionFuncs(scheme *runtime.Scheme) {
Convert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment,
Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec,
Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec,
- Convert_extensions_JobSpec_To_v1beta1_JobSpec,
- Convert_v1beta1_JobSpec_To_extensions_JobSpec,
+ // autoscaling
+ Convert_autoscaling_CrossVersionObjectReference_To_v1beta1_SubresourceReference,
+ Convert_v1beta1_SubresourceReference_To_autoscaling_CrossVersionObjectReference,
+ Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec,
+ Convert_v1beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec,
+ // batch
+ Convert_batch_JobSpec_To_v1beta1_JobSpec,
+ Convert_v1beta1_JobSpec_To_batch_JobSpec,
)
if err != nil {
// If one of the conversion functions is malformed, detect it immediately.
@@ -84,21 +89,7 @@ func addConversionFuncs(scheme *runtime.Scheme) {
}
}
-// The following two PodSpec conversions functions where copied from pkg/api/conversion.go
-// for the generated functions to work properly.
-// This should be fixed: https://github.com/kubernetes/kubernetes/issues/12977
-func Convert_api_PodSpec_To_v1_PodSpec(in *api.PodSpec, out *v1.PodSpec, s conversion.Scope) error {
- return v1.Convert_api_PodSpec_To_v1_PodSpec(in, out, s)
-}
-
-func Convert_v1_PodSpec_To_api_PodSpec(in *v1.PodSpec, out *api.PodSpec, s conversion.Scope) error {
- return v1.Convert_v1_PodSpec_To_api_PodSpec(in, out, s)
-}
-
func Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus(in *extensions.ScaleStatus, out *ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ScaleStatus))(in)
- }
out.Replicas = int32(in.Replicas)
out.Selector = nil
@@ -118,10 +109,7 @@ func Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus(in *extensions.ScaleS
}
func Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus(in *ScaleStatus, out *extensions.ScaleStatus, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ScaleStatus))(in)
- }
- out.Replicas = int(in.Replicas)
+ out.Replicas = in.Replicas
// Normally when 2 fields map to the same internal value we favor the old field, since
// old clients can't be expected to know about new fields but clients that know about the
@@ -148,11 +136,7 @@ func Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus(in *ScaleStatus, out
}
func Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec(in *extensions.DeploymentSpec, out *DeploymentSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentSpec))(in)
- }
- out.Replicas = new(int32)
- *out.Replicas = int32(in.Replicas)
+ out.Replicas = &in.Replicas
if in.Selector != nil {
out.Selector = new(LabelSelector)
if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in.Selector, out.Selector, s); err != nil {
@@ -183,11 +167,8 @@ func Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec(in *extensions.
}
func Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(in *DeploymentSpec, out *extensions.DeploymentSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentSpec))(in)
- }
if in.Replicas != nil {
- out.Replicas = int(*in.Replicas)
+ out.Replicas = *in.Replicas
}
if in.Selector != nil {
@@ -204,11 +185,8 @@ func Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(in *DeploymentS
if err := Convert_v1beta1_DeploymentStrategy_To_extensions_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
return err
}
- if in.RevisionHistoryLimit != nil {
- out.RevisionHistoryLimit = new(int)
- *out.RevisionHistoryLimit = int(*in.RevisionHistoryLimit)
- }
- out.MinReadySeconds = int(in.MinReadySeconds)
+ out.RevisionHistoryLimit = in.RevisionHistoryLimit
+ out.MinReadySeconds = in.MinReadySeconds
out.Paused = in.Paused
if in.RollbackTo != nil {
out.RollbackTo = new(extensions.RollbackConfig)
@@ -220,9 +198,6 @@ func Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(in *DeploymentS
}
func Convert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *extensions.DeploymentStrategy, out *DeploymentStrategy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.DeploymentStrategy))(in)
- }
out.Type = DeploymentStrategyType(in.Type)
if in.RollingUpdate != nil {
out.RollingUpdate = new(RollingUpdateDeployment)
@@ -236,9 +211,6 @@ func Convert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *ext
}
func Convert_v1beta1_DeploymentStrategy_To_extensions_DeploymentStrategy(in *DeploymentStrategy, out *extensions.DeploymentStrategy, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*DeploymentStrategy))(in)
- }
out.Type = extensions.DeploymentStrategyType(in.Type)
if in.RollingUpdate != nil {
out.RollingUpdate = new(extensions.RollingUpdateDeployment)
@@ -252,9 +224,6 @@ func Convert_v1beta1_DeploymentStrategy_To_extensions_DeploymentStrategy(in *Dep
}
func Convert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *extensions.RollingUpdateDeployment, out *RollingUpdateDeployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.RollingUpdateDeployment))(in)
- }
if out.MaxUnavailable == nil {
out.MaxUnavailable = &intstr.IntOrString{}
}
@@ -271,9 +240,6 @@ func Convert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployme
}
func Convert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment(in *RollingUpdateDeployment, out *extensions.RollingUpdateDeployment, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*RollingUpdateDeployment))(in)
- }
if err := s.Convert(in.MaxUnavailable, &out.MaxUnavailable, 0); err != nil {
return err
}
@@ -284,9 +250,6 @@ func Convert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployme
}
func Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in *extensions.ReplicaSetSpec, out *ReplicaSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.ReplicaSetSpec))(in)
- }
out.Replicas = new(int32)
*out.Replicas = int32(in.Replicas)
if in.Selector != nil {
@@ -305,11 +268,8 @@ func Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in *extensions.
}
func Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec(in *ReplicaSetSpec, out *extensions.ReplicaSetSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*ReplicaSetSpec))(in)
- }
if in.Replicas != nil {
- out.Replicas = int(*in.Replicas)
+ out.Replicas = *in.Replicas
}
if in.Selector != nil {
out.Selector = new(unversioned.LabelSelector)
@@ -325,28 +285,10 @@ func Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec(in *ReplicaSetS
return nil
}
-func Convert_extensions_JobSpec_To_v1beta1_JobSpec(in *extensions.JobSpec, out *JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*extensions.JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int32)
- *out.Parallelism = int32(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int32)
- *out.Completions = int32(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
+func Convert_batch_JobSpec_To_v1beta1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
// unable to generate simple pointer conversion for unversioned.LabelSelector -> v1beta1.LabelSelector
if in.Selector != nil {
out.Selector = new(LabelSelector)
@@ -371,34 +313,16 @@ func Convert_extensions_JobSpec_To_v1beta1_JobSpec(in *extensions.JobSpec, out *
}
// END non-standard conversion
- if err := Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
return err
}
return nil
}
-func Convert_v1beta1_JobSpec_To_extensions_JobSpec(in *JobSpec, out *extensions.JobSpec, s conversion.Scope) error {
- if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
- defaulting.(func(*JobSpec))(in)
- }
- if in.Parallelism != nil {
- out.Parallelism = new(int)
- *out.Parallelism = int(*in.Parallelism)
- } else {
- out.Parallelism = nil
- }
- if in.Completions != nil {
- out.Completions = new(int)
- *out.Completions = int(*in.Completions)
- } else {
- out.Completions = nil
- }
- if in.ActiveDeadlineSeconds != nil {
- out.ActiveDeadlineSeconds = new(int64)
- *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds
- } else {
- out.ActiveDeadlineSeconds = nil
- }
+func Convert_v1beta1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
+ out.Parallelism = in.Parallelism
+ out.Completions = in.Completions
+ out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
// unable to generate simple pointer conversion for v1beta1.LabelSelector -> unversioned.LabelSelector
if in.Selector != nil {
out.Selector = new(unversioned.LabelSelector)
@@ -423,8 +347,58 @@ func Convert_v1beta1_JobSpec_To_extensions_JobSpec(in *JobSpec, out *extensions.
}
// END non-standard conversion
- if err := Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_autoscaling_CrossVersionObjectReference_To_v1beta1_SubresourceReference(in *autoscaling.CrossVersionObjectReference, out *SubresourceReference, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ out.Subresource = "scale"
+ return nil
+}
+
+func Convert_v1beta1_SubresourceReference_To_autoscaling_CrossVersionObjectReference(in *SubresourceReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ if err := Convert_autoscaling_CrossVersionObjectReference_To_v1beta1_SubresourceReference(&in.ScaleTargetRef, &out.ScaleRef, s); err != nil {
+ return err
+ }
+ if in.MinReplicas != nil {
+ out.MinReplicas = new(int32)
+ *out.MinReplicas = *in.MinReplicas
+ } else {
+ out.MinReplicas = nil
+ }
+ out.MaxReplicas = in.MaxReplicas
+ if in.TargetCPUUtilizationPercentage != nil {
+ out.CPUUtilization = &CPUTargetUtilization{TargetPercentage: *in.TargetCPUUtilizationPercentage}
+ }
+ return nil
+}
+
+func Convert_v1beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
+ if err := Convert_v1beta1_SubresourceReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleRef, &out.ScaleTargetRef, s); err != nil {
return err
}
+ if in.MinReplicas != nil {
+ out.MinReplicas = new(int32)
+ *out.MinReplicas = int32(*in.MinReplicas)
+ } else {
+ out.MinReplicas = nil
+ }
+ out.MaxReplicas = int32(in.MaxReplicas)
+ if in.CPUUtilization != nil {
+ out.TargetCPUUtilizationPercentage = new(int32)
+ *out.TargetCPUUtilizationPercentage = int32(in.CPUUtilization.TargetPercentage)
+ }
return nil
}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..445394f16a59c27a6c4d67fec8f1814d56487039
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/conversion_generated.go
@@ -0,0 +1,2469 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
+ extensions "k8s.io/kubernetes/pkg/apis/extensions"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1beta1_APIVersion_To_extensions_APIVersion,
+ Convert_extensions_APIVersion_To_v1beta1_APIVersion,
+ Convert_v1beta1_CustomMetricCurrentStatus_To_extensions_CustomMetricCurrentStatus,
+ Convert_extensions_CustomMetricCurrentStatus_To_v1beta1_CustomMetricCurrentStatus,
+ Convert_v1beta1_CustomMetricCurrentStatusList_To_extensions_CustomMetricCurrentStatusList,
+ Convert_extensions_CustomMetricCurrentStatusList_To_v1beta1_CustomMetricCurrentStatusList,
+ Convert_v1beta1_CustomMetricTarget_To_extensions_CustomMetricTarget,
+ Convert_extensions_CustomMetricTarget_To_v1beta1_CustomMetricTarget,
+ Convert_v1beta1_CustomMetricTargetList_To_extensions_CustomMetricTargetList,
+ Convert_extensions_CustomMetricTargetList_To_v1beta1_CustomMetricTargetList,
+ Convert_v1beta1_DaemonSet_To_extensions_DaemonSet,
+ Convert_extensions_DaemonSet_To_v1beta1_DaemonSet,
+ Convert_v1beta1_DaemonSetList_To_extensions_DaemonSetList,
+ Convert_extensions_DaemonSetList_To_v1beta1_DaemonSetList,
+ Convert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec,
+ Convert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec,
+ Convert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus,
+ Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus,
+ Convert_v1beta1_Deployment_To_extensions_Deployment,
+ Convert_extensions_Deployment_To_v1beta1_Deployment,
+ Convert_v1beta1_DeploymentList_To_extensions_DeploymentList,
+ Convert_extensions_DeploymentList_To_v1beta1_DeploymentList,
+ Convert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback,
+ Convert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback,
+ Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec,
+ Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec,
+ Convert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus,
+ Convert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus,
+ Convert_v1beta1_DeploymentStrategy_To_extensions_DeploymentStrategy,
+ Convert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy,
+ Convert_v1beta1_FSGroupStrategyOptions_To_extensions_FSGroupStrategyOptions,
+ Convert_extensions_FSGroupStrategyOptions_To_v1beta1_FSGroupStrategyOptions,
+ Convert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath,
+ Convert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath,
+ Convert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue,
+ Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue,
+ Convert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler,
+ Convert_autoscaling_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler,
+ Convert_v1beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList,
+ Convert_autoscaling_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList,
+ Convert_v1beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec,
+ Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec,
+ Convert_v1beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus,
+ Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus,
+ Convert_v1beta1_HostPortRange_To_extensions_HostPortRange,
+ Convert_extensions_HostPortRange_To_v1beta1_HostPortRange,
+ Convert_v1beta1_IDRange_To_extensions_IDRange,
+ Convert_extensions_IDRange_To_v1beta1_IDRange,
+ Convert_v1beta1_Ingress_To_extensions_Ingress,
+ Convert_extensions_Ingress_To_v1beta1_Ingress,
+ Convert_v1beta1_IngressBackend_To_extensions_IngressBackend,
+ Convert_extensions_IngressBackend_To_v1beta1_IngressBackend,
+ Convert_v1beta1_IngressList_To_extensions_IngressList,
+ Convert_extensions_IngressList_To_v1beta1_IngressList,
+ Convert_v1beta1_IngressRule_To_extensions_IngressRule,
+ Convert_extensions_IngressRule_To_v1beta1_IngressRule,
+ Convert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue,
+ Convert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue,
+ Convert_v1beta1_IngressSpec_To_extensions_IngressSpec,
+ Convert_extensions_IngressSpec_To_v1beta1_IngressSpec,
+ Convert_v1beta1_IngressStatus_To_extensions_IngressStatus,
+ Convert_extensions_IngressStatus_To_v1beta1_IngressStatus,
+ Convert_v1beta1_IngressTLS_To_extensions_IngressTLS,
+ Convert_extensions_IngressTLS_To_v1beta1_IngressTLS,
+ Convert_v1beta1_Job_To_batch_Job,
+ Convert_batch_Job_To_v1beta1_Job,
+ Convert_v1beta1_JobCondition_To_batch_JobCondition,
+ Convert_batch_JobCondition_To_v1beta1_JobCondition,
+ Convert_v1beta1_JobList_To_batch_JobList,
+ Convert_batch_JobList_To_v1beta1_JobList,
+ Convert_v1beta1_JobSpec_To_batch_JobSpec,
+ Convert_batch_JobSpec_To_v1beta1_JobSpec,
+ Convert_v1beta1_JobStatus_To_batch_JobStatus,
+ Convert_batch_JobStatus_To_v1beta1_JobStatus,
+ Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector,
+ Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector,
+ Convert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement,
+ Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement,
+ Convert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy,
+ Convert_extensions_NetworkPolicy_To_v1beta1_NetworkPolicy,
+ Convert_v1beta1_NetworkPolicyIngressRule_To_extensions_NetworkPolicyIngressRule,
+ Convert_extensions_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule,
+ Convert_v1beta1_NetworkPolicyList_To_extensions_NetworkPolicyList,
+ Convert_extensions_NetworkPolicyList_To_v1beta1_NetworkPolicyList,
+ Convert_v1beta1_NetworkPolicyPeer_To_extensions_NetworkPolicyPeer,
+ Convert_extensions_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer,
+ Convert_v1beta1_NetworkPolicyPort_To_extensions_NetworkPolicyPort,
+ Convert_extensions_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort,
+ Convert_v1beta1_NetworkPolicySpec_To_extensions_NetworkPolicySpec,
+ Convert_extensions_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec,
+ Convert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy,
+ Convert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy,
+ Convert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList,
+ Convert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList,
+ Convert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec,
+ Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec,
+ Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet,
+ Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet,
+ Convert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList,
+ Convert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList,
+ Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec,
+ Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec,
+ Convert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus,
+ Convert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus,
+ Convert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy,
+ Convert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy,
+ Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig,
+ Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig,
+ Convert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment,
+ Convert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment,
+ Convert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions,
+ Convert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions,
+ Convert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions,
+ Convert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions,
+ Convert_v1beta1_Scale_To_extensions_Scale,
+ Convert_extensions_Scale_To_v1beta1_Scale,
+ Convert_v1beta1_ScaleSpec_To_extensions_ScaleSpec,
+ Convert_extensions_ScaleSpec_To_v1beta1_ScaleSpec,
+ Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus,
+ Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus,
+ Convert_v1beta1_SupplementalGroupsStrategyOptions_To_extensions_SupplementalGroupsStrategyOptions,
+ Convert_extensions_SupplementalGroupsStrategyOptions_To_v1beta1_SupplementalGroupsStrategyOptions,
+ Convert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource,
+ Convert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource,
+ Convert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData,
+ Convert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData,
+ Convert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList,
+ Convert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList,
+ Convert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList,
+ Convert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1beta1_APIVersion_To_extensions_APIVersion(in *APIVersion, out *extensions.APIVersion, s conversion.Scope) error {
+ out.Name = in.Name
+ return nil
+}
+
+func Convert_v1beta1_APIVersion_To_extensions_APIVersion(in *APIVersion, out *extensions.APIVersion, s conversion.Scope) error {
+ return autoConvert_v1beta1_APIVersion_To_extensions_APIVersion(in, out, s)
+}
+
+func autoConvert_extensions_APIVersion_To_v1beta1_APIVersion(in *extensions.APIVersion, out *APIVersion, s conversion.Scope) error {
+ out.Name = in.Name
+ return nil
+}
+
+func Convert_extensions_APIVersion_To_v1beta1_APIVersion(in *extensions.APIVersion, out *APIVersion, s conversion.Scope) error {
+ return autoConvert_extensions_APIVersion_To_v1beta1_APIVersion(in, out, s)
+}
+
+func autoConvert_v1beta1_CustomMetricCurrentStatus_To_extensions_CustomMetricCurrentStatus(in *CustomMetricCurrentStatus, out *extensions.CustomMetricCurrentStatus, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.CurrentValue, &out.CurrentValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_CustomMetricCurrentStatus_To_extensions_CustomMetricCurrentStatus(in *CustomMetricCurrentStatus, out *extensions.CustomMetricCurrentStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_CustomMetricCurrentStatus_To_extensions_CustomMetricCurrentStatus(in, out, s)
+}
+
+func autoConvert_extensions_CustomMetricCurrentStatus_To_v1beta1_CustomMetricCurrentStatus(in *extensions.CustomMetricCurrentStatus, out *CustomMetricCurrentStatus, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.CurrentValue, &out.CurrentValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_CustomMetricCurrentStatus_To_v1beta1_CustomMetricCurrentStatus(in *extensions.CustomMetricCurrentStatus, out *CustomMetricCurrentStatus, s conversion.Scope) error {
+ return autoConvert_extensions_CustomMetricCurrentStatus_To_v1beta1_CustomMetricCurrentStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_CustomMetricCurrentStatusList_To_extensions_CustomMetricCurrentStatusList(in *CustomMetricCurrentStatusList, out *extensions.CustomMetricCurrentStatusList, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.CustomMetricCurrentStatus, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_CustomMetricCurrentStatus_To_extensions_CustomMetricCurrentStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_CustomMetricCurrentStatusList_To_extensions_CustomMetricCurrentStatusList(in *CustomMetricCurrentStatusList, out *extensions.CustomMetricCurrentStatusList, s conversion.Scope) error {
+ return autoConvert_v1beta1_CustomMetricCurrentStatusList_To_extensions_CustomMetricCurrentStatusList(in, out, s)
+}
+
+func autoConvert_extensions_CustomMetricCurrentStatusList_To_v1beta1_CustomMetricCurrentStatusList(in *extensions.CustomMetricCurrentStatusList, out *CustomMetricCurrentStatusList, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]CustomMetricCurrentStatus, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_CustomMetricCurrentStatus_To_v1beta1_CustomMetricCurrentStatus(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_CustomMetricCurrentStatusList_To_v1beta1_CustomMetricCurrentStatusList(in *extensions.CustomMetricCurrentStatusList, out *CustomMetricCurrentStatusList, s conversion.Scope) error {
+ return autoConvert_extensions_CustomMetricCurrentStatusList_To_v1beta1_CustomMetricCurrentStatusList(in, out, s)
+}
+
+func autoConvert_v1beta1_CustomMetricTarget_To_extensions_CustomMetricTarget(in *CustomMetricTarget, out *extensions.CustomMetricTarget, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.TargetValue, &out.TargetValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_CustomMetricTarget_To_extensions_CustomMetricTarget(in *CustomMetricTarget, out *extensions.CustomMetricTarget, s conversion.Scope) error {
+ return autoConvert_v1beta1_CustomMetricTarget_To_extensions_CustomMetricTarget(in, out, s)
+}
+
+func autoConvert_extensions_CustomMetricTarget_To_v1beta1_CustomMetricTarget(in *extensions.CustomMetricTarget, out *CustomMetricTarget, s conversion.Scope) error {
+ out.Name = in.Name
+ if err := api.Convert_resource_Quantity_To_resource_Quantity(&in.TargetValue, &out.TargetValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_CustomMetricTarget_To_v1beta1_CustomMetricTarget(in *extensions.CustomMetricTarget, out *CustomMetricTarget, s conversion.Scope) error {
+ return autoConvert_extensions_CustomMetricTarget_To_v1beta1_CustomMetricTarget(in, out, s)
+}
+
+func autoConvert_v1beta1_CustomMetricTargetList_To_extensions_CustomMetricTargetList(in *CustomMetricTargetList, out *extensions.CustomMetricTargetList, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.CustomMetricTarget, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_CustomMetricTarget_To_extensions_CustomMetricTarget(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_CustomMetricTargetList_To_extensions_CustomMetricTargetList(in *CustomMetricTargetList, out *extensions.CustomMetricTargetList, s conversion.Scope) error {
+ return autoConvert_v1beta1_CustomMetricTargetList_To_extensions_CustomMetricTargetList(in, out, s)
+}
+
+func autoConvert_extensions_CustomMetricTargetList_To_v1beta1_CustomMetricTargetList(in *extensions.CustomMetricTargetList, out *CustomMetricTargetList, s conversion.Scope) error {
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]CustomMetricTarget, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_CustomMetricTarget_To_v1beta1_CustomMetricTarget(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_CustomMetricTargetList_To_v1beta1_CustomMetricTargetList(in *extensions.CustomMetricTargetList, out *CustomMetricTargetList, s conversion.Scope) error {
+ return autoConvert_extensions_CustomMetricTargetList_To_v1beta1_CustomMetricTargetList(in, out, s)
+}
+
+func autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet(in *DaemonSet, out *extensions.DaemonSet, s conversion.Scope) error {
+ SetDefaults_DaemonSet(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_DaemonSet_To_extensions_DaemonSet(in *DaemonSet, out *extensions.DaemonSet, s conversion.Scope) error {
+ return autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet(in, out, s)
+}
+
+func autoConvert_extensions_DaemonSet_To_v1beta1_DaemonSet(in *extensions.DaemonSet, out *DaemonSet, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_DaemonSet_To_v1beta1_DaemonSet(in *extensions.DaemonSet, out *DaemonSet, s conversion.Scope) error {
+ return autoConvert_extensions_DaemonSet_To_v1beta1_DaemonSet(in, out, s)
+}
+
+func autoConvert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in *DaemonSetList, out *extensions.DaemonSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.DaemonSet, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_DaemonSet_To_extensions_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in *DaemonSetList, out *extensions.DaemonSetList, s conversion.Scope) error {
+ return autoConvert_v1beta1_DaemonSetList_To_extensions_DaemonSetList(in, out, s)
+}
+
+func autoConvert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in *extensions.DaemonSetList, out *DaemonSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]DaemonSet, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_DaemonSet_To_v1beta1_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in *extensions.DaemonSetList, out *DaemonSetList, s conversion.Scope) error {
+ return autoConvert_extensions_DaemonSetList_To_v1beta1_DaemonSetList(in, out, s)
+}
+
+func autoConvert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in *DaemonSetSpec, out *extensions.DaemonSetSpec, s conversion.Scope) error {
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.Convert_v1_PodTemplateSpec_To_api_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in *DaemonSetSpec, out *extensions.DaemonSetSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_DaemonSetSpec_To_extensions_DaemonSetSpec(in, out, s)
+}
+
+func autoConvert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *extensions.DaemonSetSpec, out *DaemonSetSpec, s conversion.Scope) error {
+ if in.Selector != nil {
+ in, out := &in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.Convert_api_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *extensions.DaemonSetSpec, out *DaemonSetSpec, s conversion.Scope) error {
+ return autoConvert_extensions_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in *DaemonSetStatus, out *extensions.DaemonSetStatus, s conversion.Scope) error {
+ out.CurrentNumberScheduled = in.CurrentNumberScheduled
+ out.NumberMisscheduled = in.NumberMisscheduled
+ out.DesiredNumberScheduled = in.DesiredNumberScheduled
+ return nil
+}
+
+func Convert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in *DaemonSetStatus, out *extensions.DaemonSetStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_DaemonSetStatus_To_extensions_DaemonSetStatus(in, out, s)
+}
+
+func autoConvert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *extensions.DaemonSetStatus, out *DaemonSetStatus, s conversion.Scope) error {
+ out.CurrentNumberScheduled = in.CurrentNumberScheduled
+ out.NumberMisscheduled = in.NumberMisscheduled
+ out.DesiredNumberScheduled = in.DesiredNumberScheduled
+ return nil
+}
+
+func Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *extensions.DaemonSetStatus, out *DaemonSetStatus, s conversion.Scope) error {
+ return autoConvert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_Deployment_To_extensions_Deployment(in *Deployment, out *extensions.Deployment, s conversion.Scope) error {
+ SetDefaults_Deployment(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_DeploymentSpec_To_extensions_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_Deployment_To_extensions_Deployment(in *Deployment, out *extensions.Deployment, s conversion.Scope) error {
+ return autoConvert_v1beta1_Deployment_To_extensions_Deployment(in, out, s)
+}
+
+func autoConvert_extensions_Deployment_To_v1beta1_Deployment(in *extensions.Deployment, out *Deployment, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_DeploymentSpec_To_v1beta1_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_Deployment_To_v1beta1_Deployment(in *extensions.Deployment, out *Deployment, s conversion.Scope) error {
+ return autoConvert_extensions_Deployment_To_v1beta1_Deployment(in, out, s)
+}
+
+func autoConvert_v1beta1_DeploymentList_To_extensions_DeploymentList(in *DeploymentList, out *extensions.DeploymentList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.Deployment, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_Deployment_To_extensions_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_DeploymentList_To_extensions_DeploymentList(in *DeploymentList, out *extensions.DeploymentList, s conversion.Scope) error {
+ return autoConvert_v1beta1_DeploymentList_To_extensions_DeploymentList(in, out, s)
+}
+
+func autoConvert_extensions_DeploymentList_To_v1beta1_DeploymentList(in *extensions.DeploymentList, out *DeploymentList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Deployment, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_Deployment_To_v1beta1_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_DeploymentList_To_v1beta1_DeploymentList(in *extensions.DeploymentList, out *DeploymentList, s conversion.Scope) error {
+ return autoConvert_extensions_DeploymentList_To_v1beta1_DeploymentList(in, out, s)
+}
+
+func autoConvert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in *DeploymentRollback, out *extensions.DeploymentRollback, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Name = in.Name
+ out.UpdatedAnnotations = in.UpdatedAnnotations
+ if err := Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in *DeploymentRollback, out *extensions.DeploymentRollback, s conversion.Scope) error {
+ return autoConvert_v1beta1_DeploymentRollback_To_extensions_DeploymentRollback(in, out, s)
+}
+
+func autoConvert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in *extensions.DeploymentRollback, out *DeploymentRollback, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ out.Name = in.Name
+ out.UpdatedAnnotations = in.UpdatedAnnotations
+ if err := Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in *extensions.DeploymentRollback, out *DeploymentRollback, s conversion.Scope) error {
+ return autoConvert_extensions_DeploymentRollback_To_v1beta1_DeploymentRollback(in, out, s)
+}
+
+func autoConvert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in *DeploymentStatus, out *extensions.DeploymentStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = in.Replicas
+ out.UpdatedReplicas = in.UpdatedReplicas
+ out.AvailableReplicas = in.AvailableReplicas
+ out.UnavailableReplicas = in.UnavailableReplicas
+ return nil
+}
+
+func Convert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in *DeploymentStatus, out *extensions.DeploymentStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_DeploymentStatus_To_extensions_DeploymentStatus(in, out, s)
+}
+
+func autoConvert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in *extensions.DeploymentStatus, out *DeploymentStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = in.Replicas
+ out.UpdatedReplicas = in.UpdatedReplicas
+ out.AvailableReplicas = in.AvailableReplicas
+ out.UnavailableReplicas = in.UnavailableReplicas
+ return nil
+}
+
+func Convert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in *extensions.DeploymentStatus, out *DeploymentStatus, s conversion.Scope) error {
+ return autoConvert_extensions_DeploymentStatus_To_v1beta1_DeploymentStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_DeploymentStrategy_To_extensions_DeploymentStrategy(in *DeploymentStrategy, out *extensions.DeploymentStrategy, s conversion.Scope) error {
+ out.Type = extensions.DeploymentStrategyType(in.Type)
+ if in.RollingUpdate != nil {
+ in, out := &in.RollingUpdate, &out.RollingUpdate
+ *out = new(extensions.RollingUpdateDeployment)
+ if err := Convert_v1beta1_RollingUpdateDeployment_To_extensions_RollingUpdateDeployment(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RollingUpdate = nil
+ }
+ return nil
+}
+
+func autoConvert_extensions_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *extensions.DeploymentStrategy, out *DeploymentStrategy, s conversion.Scope) error {
+ out.Type = DeploymentStrategyType(in.Type)
+ if in.RollingUpdate != nil {
+ in, out := &in.RollingUpdate, &out.RollingUpdate
+ *out = new(RollingUpdateDeployment)
+ if err := Convert_extensions_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.RollingUpdate = nil
+ }
+ return nil
+}
+
+func autoConvert_v1beta1_FSGroupStrategyOptions_To_extensions_FSGroupStrategyOptions(in *FSGroupStrategyOptions, out *extensions.FSGroupStrategyOptions, s conversion.Scope) error {
+ out.Rule = extensions.FSGroupStrategyType(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]extensions.IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_IDRange_To_extensions_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_FSGroupStrategyOptions_To_extensions_FSGroupStrategyOptions(in *FSGroupStrategyOptions, out *extensions.FSGroupStrategyOptions, s conversion.Scope) error {
+ return autoConvert_v1beta1_FSGroupStrategyOptions_To_extensions_FSGroupStrategyOptions(in, out, s)
+}
+
+func autoConvert_extensions_FSGroupStrategyOptions_To_v1beta1_FSGroupStrategyOptions(in *extensions.FSGroupStrategyOptions, out *FSGroupStrategyOptions, s conversion.Scope) error {
+ out.Rule = FSGroupStrategyType(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_IDRange_To_v1beta1_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_extensions_FSGroupStrategyOptions_To_v1beta1_FSGroupStrategyOptions(in *extensions.FSGroupStrategyOptions, out *FSGroupStrategyOptions, s conversion.Scope) error {
+ return autoConvert_extensions_FSGroupStrategyOptions_To_v1beta1_FSGroupStrategyOptions(in, out, s)
+}
+
+func autoConvert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in *HTTPIngressPath, out *extensions.HTTPIngressPath, s conversion.Scope) error {
+ out.Path = in.Path
+ if err := Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in *HTTPIngressPath, out *extensions.HTTPIngressPath, s conversion.Scope) error {
+ return autoConvert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(in, out, s)
+}
+
+func autoConvert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *extensions.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error {
+ out.Path = in.Path
+ if err := Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *extensions.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error {
+ return autoConvert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in, out, s)
+}
+
+func autoConvert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *extensions.HTTPIngressRuleValue, s conversion.Scope) error {
+ if in.Paths != nil {
+ in, out := &in.Paths, &out.Paths
+ *out = make([]extensions.HTTPIngressPath, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_HTTPIngressPath_To_extensions_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Paths = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *extensions.HTTPIngressRuleValue, s conversion.Scope) error {
+ return autoConvert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(in, out, s)
+}
+
+func autoConvert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *extensions.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error {
+ if in.Paths != nil {
+ in, out := &in.Paths, &out.Paths
+ *out = make([]HTTPIngressPath, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_HTTPIngressPath_To_v1beta1_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Paths = nil
+ }
+ return nil
+}
+
+func Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *extensions.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error {
+ return autoConvert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in, out, s)
+}
+
+func autoConvert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
+ SetDefaults_HorizontalPodAutoscaler(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
+ return autoConvert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1beta1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(in, out, s)
+}
+
+func autoConvert_v1beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
+ return autoConvert_v1beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]HorizontalPodAutoscaler, len(*in))
+ for i := range *in {
+ if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v1beta1_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1beta1_HorizontalPodAutoscalerList(in, out, s)
+}
+
+func autoConvert_v1beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.LastScaleTime = in.LastScaleTime
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ out.CurrentCPUUtilizationPercentage = in.CurrentCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_v1beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in, out, s)
+}
+
+func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.LastScaleTime = in.LastScaleTime
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ out.CurrentCPUUtilizationPercentage = in.CurrentCPUUtilizationPercentage
+ return nil
+}
+
+func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, s conversion.Scope) error {
+ return autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v1beta1_HorizontalPodAutoscalerStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_HostPortRange_To_extensions_HostPortRange(in *HostPortRange, out *extensions.HostPortRange, s conversion.Scope) error {
+ out.Min = int(in.Min)
+ out.Max = int(in.Max)
+ return nil
+}
+
+func Convert_v1beta1_HostPortRange_To_extensions_HostPortRange(in *HostPortRange, out *extensions.HostPortRange, s conversion.Scope) error {
+ return autoConvert_v1beta1_HostPortRange_To_extensions_HostPortRange(in, out, s)
+}
+
+func autoConvert_extensions_HostPortRange_To_v1beta1_HostPortRange(in *extensions.HostPortRange, out *HostPortRange, s conversion.Scope) error {
+ out.Min = int32(in.Min)
+ out.Max = int32(in.Max)
+ return nil
+}
+
+func Convert_extensions_HostPortRange_To_v1beta1_HostPortRange(in *extensions.HostPortRange, out *HostPortRange, s conversion.Scope) error {
+ return autoConvert_extensions_HostPortRange_To_v1beta1_HostPortRange(in, out, s)
+}
+
+func autoConvert_v1beta1_IDRange_To_extensions_IDRange(in *IDRange, out *extensions.IDRange, s conversion.Scope) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func Convert_v1beta1_IDRange_To_extensions_IDRange(in *IDRange, out *extensions.IDRange, s conversion.Scope) error {
+ return autoConvert_v1beta1_IDRange_To_extensions_IDRange(in, out, s)
+}
+
+func autoConvert_extensions_IDRange_To_v1beta1_IDRange(in *extensions.IDRange, out *IDRange, s conversion.Scope) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func Convert_extensions_IDRange_To_v1beta1_IDRange(in *extensions.IDRange, out *IDRange, s conversion.Scope) error {
+ return autoConvert_extensions_IDRange_To_v1beta1_IDRange(in, out, s)
+}
+
+func autoConvert_v1beta1_Ingress_To_extensions_Ingress(in *Ingress, out *extensions.Ingress, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_IngressSpec_To_extensions_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_IngressStatus_To_extensions_IngressStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_Ingress_To_extensions_Ingress(in *Ingress, out *extensions.Ingress, s conversion.Scope) error {
+ return autoConvert_v1beta1_Ingress_To_extensions_Ingress(in, out, s)
+}
+
+func autoConvert_extensions_Ingress_To_v1beta1_Ingress(in *extensions.Ingress, out *Ingress, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_IngressSpec_To_v1beta1_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_IngressStatus_To_v1beta1_IngressStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_Ingress_To_v1beta1_Ingress(in *extensions.Ingress, out *Ingress, s conversion.Scope) error {
+ return autoConvert_extensions_Ingress_To_v1beta1_Ingress(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressBackend_To_extensions_IngressBackend(in *IngressBackend, out *extensions.IngressBackend, s conversion.Scope) error {
+ out.ServiceName = in.ServiceName
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.ServicePort, &out.ServicePort, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(in *IngressBackend, out *extensions.IngressBackend, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressBackend_To_extensions_IngressBackend(in, out, s)
+}
+
+func autoConvert_extensions_IngressBackend_To_v1beta1_IngressBackend(in *extensions.IngressBackend, out *IngressBackend, s conversion.Scope) error {
+ out.ServiceName = in.ServiceName
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.ServicePort, &out.ServicePort, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(in *extensions.IngressBackend, out *IngressBackend, s conversion.Scope) error {
+ return autoConvert_extensions_IngressBackend_To_v1beta1_IngressBackend(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressList_To_extensions_IngressList(in *IngressList, out *extensions.IngressList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.Ingress, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_Ingress_To_extensions_Ingress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressList_To_extensions_IngressList(in *IngressList, out *extensions.IngressList, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressList_To_extensions_IngressList(in, out, s)
+}
+
+func autoConvert_extensions_IngressList_To_v1beta1_IngressList(in *extensions.IngressList, out *IngressList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Ingress, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_Ingress_To_v1beta1_Ingress(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_IngressList_To_v1beta1_IngressList(in *extensions.IngressList, out *IngressList, s conversion.Scope) error {
+ return autoConvert_extensions_IngressList_To_v1beta1_IngressList(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressRule_To_extensions_IngressRule(in *IngressRule, out *extensions.IngressRule, s conversion.Scope) error {
+ out.Host = in.Host
+ if err := Convert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressRule_To_extensions_IngressRule(in *IngressRule, out *extensions.IngressRule, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressRule_To_extensions_IngressRule(in, out, s)
+}
+
+func autoConvert_extensions_IngressRule_To_v1beta1_IngressRule(in *extensions.IngressRule, out *IngressRule, s conversion.Scope) error {
+ out.Host = in.Host
+ if err := Convert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_IngressRule_To_v1beta1_IngressRule(in *extensions.IngressRule, out *IngressRule, s conversion.Scope) error {
+ return autoConvert_extensions_IngressRule_To_v1beta1_IngressRule(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in *IngressRuleValue, out *extensions.IngressRuleValue, s conversion.Scope) error {
+ if in.HTTP != nil {
+ in, out := &in.HTTP, &out.HTTP
+ *out = new(extensions.HTTPIngressRuleValue)
+ if err := Convert_v1beta1_HTTPIngressRuleValue_To_extensions_HTTPIngressRuleValue(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.HTTP = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in *IngressRuleValue, out *extensions.IngressRuleValue, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressRuleValue_To_extensions_IngressRuleValue(in, out, s)
+}
+
+func autoConvert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in *extensions.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error {
+ if in.HTTP != nil {
+ in, out := &in.HTTP, &out.HTTP
+ *out = new(HTTPIngressRuleValue)
+ if err := Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.HTTP = nil
+ }
+ return nil
+}
+
+func Convert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in *extensions.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error {
+ return autoConvert_extensions_IngressRuleValue_To_v1beta1_IngressRuleValue(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressSpec_To_extensions_IngressSpec(in *IngressSpec, out *extensions.IngressSpec, s conversion.Scope) error {
+ if in.Backend != nil {
+ in, out := &in.Backend, &out.Backend
+ *out = new(extensions.IngressBackend)
+ if err := Convert_v1beta1_IngressBackend_To_extensions_IngressBackend(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Backend = nil
+ }
+ if in.TLS != nil {
+ in, out := &in.TLS, &out.TLS
+ *out = make([]extensions.IngressTLS, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_IngressTLS_To_extensions_IngressTLS(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.TLS = nil
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]extensions.IngressRule, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_IngressRule_To_extensions_IngressRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressSpec_To_extensions_IngressSpec(in *IngressSpec, out *extensions.IngressSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressSpec_To_extensions_IngressSpec(in, out, s)
+}
+
+func autoConvert_extensions_IngressSpec_To_v1beta1_IngressSpec(in *extensions.IngressSpec, out *IngressSpec, s conversion.Scope) error {
+ if in.Backend != nil {
+ in, out := &in.Backend, &out.Backend
+ *out = new(IngressBackend)
+ if err := Convert_extensions_IngressBackend_To_v1beta1_IngressBackend(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.Backend = nil
+ }
+ if in.TLS != nil {
+ in, out := &in.TLS, &out.TLS
+ *out = make([]IngressTLS, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_IngressTLS_To_v1beta1_IngressTLS(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.TLS = nil
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]IngressRule, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_IngressRule_To_v1beta1_IngressRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_extensions_IngressSpec_To_v1beta1_IngressSpec(in *extensions.IngressSpec, out *IngressSpec, s conversion.Scope) error {
+ return autoConvert_extensions_IngressSpec_To_v1beta1_IngressSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressStatus_To_extensions_IngressStatus(in *IngressStatus, out *extensions.IngressStatus, s conversion.Scope) error {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.LoadBalancer, &out.LoadBalancer, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_IngressStatus_To_extensions_IngressStatus(in *IngressStatus, out *extensions.IngressStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressStatus_To_extensions_IngressStatus(in, out, s)
+}
+
+func autoConvert_extensions_IngressStatus_To_v1beta1_IngressStatus(in *extensions.IngressStatus, out *IngressStatus, s conversion.Scope) error {
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.LoadBalancer, &out.LoadBalancer, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_IngressStatus_To_v1beta1_IngressStatus(in *extensions.IngressStatus, out *IngressStatus, s conversion.Scope) error {
+ return autoConvert_extensions_IngressStatus_To_v1beta1_IngressStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_IngressTLS_To_extensions_IngressTLS(in *IngressTLS, out *extensions.IngressTLS, s conversion.Scope) error {
+ out.Hosts = in.Hosts
+ out.SecretName = in.SecretName
+ return nil
+}
+
+func Convert_v1beta1_IngressTLS_To_extensions_IngressTLS(in *IngressTLS, out *extensions.IngressTLS, s conversion.Scope) error {
+ return autoConvert_v1beta1_IngressTLS_To_extensions_IngressTLS(in, out, s)
+}
+
+func autoConvert_extensions_IngressTLS_To_v1beta1_IngressTLS(in *extensions.IngressTLS, out *IngressTLS, s conversion.Scope) error {
+ out.Hosts = in.Hosts
+ out.SecretName = in.SecretName
+ return nil
+}
+
+func Convert_extensions_IngressTLS_To_v1beta1_IngressTLS(in *extensions.IngressTLS, out *IngressTLS, s conversion.Scope) error {
+ return autoConvert_extensions_IngressTLS_To_v1beta1_IngressTLS(in, out, s)
+}
+
+func autoConvert_v1beta1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ SetDefaults_Job(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
+ return autoConvert_v1beta1_Job_To_batch_Job(in, out, s)
+}
+
+func autoConvert_batch_Job_To_v1beta1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobSpec_To_v1beta1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_batch_JobStatus_To_v1beta1_JobStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_batch_Job_To_v1beta1_Job(in *batch.Job, out *Job, s conversion.Scope) error {
+ return autoConvert_batch_Job_To_v1beta1_Job(in, out, s)
+}
+
+func autoConvert_v1beta1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ out.Type = batch.JobConditionType(in.Type)
+ out.Status = api.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_v1beta1_JobCondition_To_batch_JobCondition(in *JobCondition, out *batch.JobCondition, s conversion.Scope) error {
+ return autoConvert_v1beta1_JobCondition_To_batch_JobCondition(in, out, s)
+}
+
+func autoConvert_batch_JobCondition_To_v1beta1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ out.Type = JobConditionType(in.Type)
+ out.Status = v1.ConditionStatus(in.Status)
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastProbeTime, &out.LastProbeTime, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_Time_To_unversioned_Time(&in.LastTransitionTime, &out.LastTransitionTime, s); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func Convert_batch_JobCondition_To_v1beta1_JobCondition(in *batch.JobCondition, out *JobCondition, s conversion.Scope) error {
+ return autoConvert_batch_JobCondition_To_v1beta1_JobCondition(in, out, s)
+}
+
+func autoConvert_v1beta1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]batch.Job, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_JobList_To_batch_JobList(in *JobList, out *batch.JobList, s conversion.Scope) error {
+ return autoConvert_v1beta1_JobList_To_batch_JobList(in, out, s)
+}
+
+func autoConvert_batch_JobList_To_v1beta1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Job, len(*in))
+ for i := range *in {
+ if err := Convert_batch_Job_To_v1beta1_Job(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_batch_JobList_To_v1beta1_JobList(in *batch.JobList, out *JobList, s conversion.Scope) error {
+ return autoConvert_batch_JobList_To_v1beta1_JobList(in, out, s)
+}
+
+func autoConvert_v1beta1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]batch.JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_JobCondition_To_batch_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_v1beta1_JobStatus_To_batch_JobStatus(in *JobStatus, out *batch.JobStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_JobStatus_To_batch_JobStatus(in, out, s)
+}
+
+func autoConvert_batch_JobStatus_To_v1beta1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ if in.Conditions != nil {
+ in, out := &in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(*in))
+ for i := range *in {
+ if err := Convert_batch_JobCondition_To_v1beta1_JobCondition(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ out.StartTime = in.StartTime
+ out.CompletionTime = in.CompletionTime
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func Convert_batch_JobStatus_To_v1beta1_JobStatus(in *batch.JobStatus, out *JobStatus, s conversion.Scope) error {
+ return autoConvert_batch_JobStatus_To_v1beta1_JobStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]unversioned.LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in *LabelSelector, out *unversioned.LabelSelector, s conversion.Scope) error {
+ return autoConvert_v1beta1_LabelSelector_To_unversioned_LabelSelector(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ out.MatchLabels = in.MatchLabels
+ if in.MatchExpressions != nil {
+ in, out := &in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(*in))
+ for i := range *in {
+ if err := Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in *unversioned.LabelSelector, out *LabelSelector, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelector_To_v1beta1_LabelSelector(in, out, s)
+}
+
+func autoConvert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = unversioned.LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in *LabelSelectorRequirement, out *unversioned.LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_v1beta1_LabelSelectorRequirement_To_unversioned_LabelSelectorRequirement(in, out, s)
+}
+
+func autoConvert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ out.Key = in.Key
+ out.Operator = LabelSelectorOperator(in.Operator)
+ out.Values = in.Values
+ return nil
+}
+
+func Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in *unversioned.LabelSelectorRequirement, out *LabelSelectorRequirement, s conversion.Scope) error {
+ return autoConvert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequirement(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy(in *NetworkPolicy, out *extensions.NetworkPolicy, s conversion.Scope) error {
+ SetDefaults_NetworkPolicy(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_NetworkPolicySpec_To_extensions_NetworkPolicySpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy(in *NetworkPolicy, out *extensions.NetworkPolicy, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicy_To_v1beta1_NetworkPolicy(in *extensions.NetworkPolicy, out *NetworkPolicy, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_NetworkPolicy_To_v1beta1_NetworkPolicy(in *extensions.NetworkPolicy, out *NetworkPolicy, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicy_To_v1beta1_NetworkPolicy(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicyIngressRule_To_extensions_NetworkPolicyIngressRule(in *NetworkPolicyIngressRule, out *extensions.NetworkPolicyIngressRule, s conversion.Scope) error {
+ if in.Ports != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]extensions.NetworkPolicyPort, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_NetworkPolicyPort_To_extensions_NetworkPolicyPort(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.From != nil {
+ in, out := &in.From, &out.From
+ *out = make([]extensions.NetworkPolicyPeer, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_NetworkPolicyPeer_To_extensions_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.From = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicyIngressRule_To_extensions_NetworkPolicyIngressRule(in *NetworkPolicyIngressRule, out *extensions.NetworkPolicyIngressRule, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicyIngressRule_To_extensions_NetworkPolicyIngressRule(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in *extensions.NetworkPolicyIngressRule, out *NetworkPolicyIngressRule, s conversion.Scope) error {
+ if in.Ports != nil {
+ in, out := &in.Ports, &out.Ports
+ *out = make([]NetworkPolicyPort, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.From != nil {
+ in, out := &in.From, &out.From
+ *out = make([]NetworkPolicyPeer, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.From = nil
+ }
+ return nil
+}
+
+func Convert_extensions_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in *extensions.NetworkPolicyIngressRule, out *NetworkPolicyIngressRule, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicyList_To_extensions_NetworkPolicyList(in *NetworkPolicyList, out *extensions.NetworkPolicyList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.NetworkPolicy, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicyList_To_extensions_NetworkPolicyList(in *NetworkPolicyList, out *extensions.NetworkPolicyList, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicyList_To_extensions_NetworkPolicyList(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in *extensions.NetworkPolicyList, out *NetworkPolicyList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]NetworkPolicy, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_NetworkPolicy_To_v1beta1_NetworkPolicy(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in *extensions.NetworkPolicyList, out *NetworkPolicyList, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicyPeer_To_extensions_NetworkPolicyPeer(in *NetworkPolicyPeer, out *extensions.NetworkPolicyPeer, s conversion.Scope) error {
+ if in.PodSelector != nil {
+ in, out := &in.PodSelector, &out.PodSelector
+ *out = new(unversioned.LabelSelector)
+ if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodSelector = nil
+ }
+ if in.NamespaceSelector != nil {
+ in, out := &in.NamespaceSelector, &out.NamespaceSelector
+ *out = new(unversioned.LabelSelector)
+ if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NamespaceSelector = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicyPeer_To_extensions_NetworkPolicyPeer(in *NetworkPolicyPeer, out *extensions.NetworkPolicyPeer, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicyPeer_To_extensions_NetworkPolicyPeer(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in *extensions.NetworkPolicyPeer, out *NetworkPolicyPeer, s conversion.Scope) error {
+ if in.PodSelector != nil {
+ in, out := &in.PodSelector, &out.PodSelector
+ *out = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.PodSelector = nil
+ }
+ if in.NamespaceSelector != nil {
+ in, out := &in.NamespaceSelector, &out.NamespaceSelector
+ *out = new(LabelSelector)
+ if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(*in, *out, s); err != nil {
+ return err
+ }
+ } else {
+ out.NamespaceSelector = nil
+ }
+ return nil
+}
+
+func Convert_extensions_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in *extensions.NetworkPolicyPeer, out *NetworkPolicyPeer, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicyPort_To_extensions_NetworkPolicyPort(in *NetworkPolicyPort, out *extensions.NetworkPolicyPort, s conversion.Scope) error {
+ if in.Protocol != nil {
+ in, out := &in.Protocol, &out.Protocol
+ *out = new(api.Protocol)
+ **out = api.Protocol(**in)
+ } else {
+ out.Protocol = nil
+ }
+ out.Port = in.Port
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicyPort_To_extensions_NetworkPolicyPort(in *NetworkPolicyPort, out *extensions.NetworkPolicyPort, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicyPort_To_extensions_NetworkPolicyPort(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in *extensions.NetworkPolicyPort, out *NetworkPolicyPort, s conversion.Scope) error {
+ if in.Protocol != nil {
+ in, out := &in.Protocol, &out.Protocol
+ *out = new(v1.Protocol)
+ **out = v1.Protocol(**in)
+ } else {
+ out.Protocol = nil
+ }
+ out.Port = in.Port
+ return nil
+}
+
+func Convert_extensions_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in *extensions.NetworkPolicyPort, out *NetworkPolicyPort, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in, out, s)
+}
+
+func autoConvert_v1beta1_NetworkPolicySpec_To_extensions_NetworkPolicySpec(in *NetworkPolicySpec, out *extensions.NetworkPolicySpec, s conversion.Scope) error {
+ if err := Convert_v1beta1_LabelSelector_To_unversioned_LabelSelector(&in.PodSelector, &out.PodSelector, s); err != nil {
+ return err
+ }
+ if in.Ingress != nil {
+ in, out := &in.Ingress, &out.Ingress
+ *out = make([]extensions.NetworkPolicyIngressRule, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_NetworkPolicyIngressRule_To_extensions_NetworkPolicyIngressRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_NetworkPolicySpec_To_extensions_NetworkPolicySpec(in *NetworkPolicySpec, out *extensions.NetworkPolicySpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_NetworkPolicySpec_To_extensions_NetworkPolicySpec(in, out, s)
+}
+
+func autoConvert_extensions_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in *extensions.NetworkPolicySpec, out *NetworkPolicySpec, s conversion.Scope) error {
+ if err := Convert_unversioned_LabelSelector_To_v1beta1_LabelSelector(&in.PodSelector, &out.PodSelector, s); err != nil {
+ return err
+ }
+ if in.Ingress != nil {
+ in, out := &in.Ingress, &out.Ingress
+ *out = make([]NetworkPolicyIngressRule, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
+ }
+ return nil
+}
+
+func Convert_extensions_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in *extensions.NetworkPolicySpec, out *NetworkPolicySpec, s conversion.Scope) error {
+ return autoConvert_extensions_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in, out, s)
+}
+
+func autoConvert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in *PodSecurityPolicy, out *extensions.PodSecurityPolicy, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in *PodSecurityPolicy, out *extensions.PodSecurityPolicy, s conversion.Scope) error {
+ return autoConvert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(in, out, s)
+}
+
+func autoConvert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in *extensions.PodSecurityPolicy, out *PodSecurityPolicy, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in *extensions.PodSecurityPolicy, out *PodSecurityPolicy, s conversion.Scope) error {
+ return autoConvert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(in, out, s)
+}
+
+func autoConvert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in *PodSecurityPolicyList, out *extensions.PodSecurityPolicyList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.PodSecurityPolicy, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_PodSecurityPolicy_To_extensions_PodSecurityPolicy(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in *PodSecurityPolicyList, out *extensions.PodSecurityPolicyList, s conversion.Scope) error {
+ return autoConvert_v1beta1_PodSecurityPolicyList_To_extensions_PodSecurityPolicyList(in, out, s)
+}
+
+func autoConvert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in *extensions.PodSecurityPolicyList, out *PodSecurityPolicyList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PodSecurityPolicy, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_PodSecurityPolicy_To_v1beta1_PodSecurityPolicy(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in *extensions.PodSecurityPolicyList, out *PodSecurityPolicyList, s conversion.Scope) error {
+ return autoConvert_extensions_PodSecurityPolicyList_To_v1beta1_PodSecurityPolicyList(in, out, s)
+}
+
+func autoConvert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in *PodSecurityPolicySpec, out *extensions.PodSecurityPolicySpec, s conversion.Scope) error {
+ out.Privileged = in.Privileged
+ if in.DefaultAddCapabilities != nil {
+ in, out := &in.DefaultAddCapabilities, &out.DefaultAddCapabilities
+ *out = make([]api.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = api.Capability((*in)[i])
+ }
+ } else {
+ out.DefaultAddCapabilities = nil
+ }
+ if in.RequiredDropCapabilities != nil {
+ in, out := &in.RequiredDropCapabilities, &out.RequiredDropCapabilities
+ *out = make([]api.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = api.Capability((*in)[i])
+ }
+ } else {
+ out.RequiredDropCapabilities = nil
+ }
+ if in.AllowedCapabilities != nil {
+ in, out := &in.AllowedCapabilities, &out.AllowedCapabilities
+ *out = make([]api.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = api.Capability((*in)[i])
+ }
+ } else {
+ out.AllowedCapabilities = nil
+ }
+ if in.Volumes != nil {
+ in, out := &in.Volumes, &out.Volumes
+ *out = make([]extensions.FSType, len(*in))
+ for i := range *in {
+ (*out)[i] = extensions.FSType((*in)[i])
+ }
+ } else {
+ out.Volumes = nil
+ }
+ out.HostNetwork = in.HostNetwork
+ if in.HostPorts != nil {
+ in, out := &in.HostPorts, &out.HostPorts
+ *out = make([]extensions.HostPortRange, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_HostPortRange_To_extensions_HostPortRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HostPorts = nil
+ }
+ out.HostPID = in.HostPID
+ out.HostIPC = in.HostIPC
+ if err := Convert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(&in.SELinux, &out.SELinux, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(&in.RunAsUser, &out.RunAsUser, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_SupplementalGroupsStrategyOptions_To_extensions_SupplementalGroupsStrategyOptions(&in.SupplementalGroups, &out.SupplementalGroups, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_FSGroupStrategyOptions_To_extensions_FSGroupStrategyOptions(&in.FSGroup, &out.FSGroup, s); err != nil {
+ return err
+ }
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
+ return nil
+}
+
+func Convert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in *PodSecurityPolicySpec, out *extensions.PodSecurityPolicySpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_PodSecurityPolicySpec_To_extensions_PodSecurityPolicySpec(in, out, s)
+}
+
+func autoConvert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in *extensions.PodSecurityPolicySpec, out *PodSecurityPolicySpec, s conversion.Scope) error {
+ out.Privileged = in.Privileged
+ if in.DefaultAddCapabilities != nil {
+ in, out := &in.DefaultAddCapabilities, &out.DefaultAddCapabilities
+ *out = make([]v1.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = v1.Capability((*in)[i])
+ }
+ } else {
+ out.DefaultAddCapabilities = nil
+ }
+ if in.RequiredDropCapabilities != nil {
+ in, out := &in.RequiredDropCapabilities, &out.RequiredDropCapabilities
+ *out = make([]v1.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = v1.Capability((*in)[i])
+ }
+ } else {
+ out.RequiredDropCapabilities = nil
+ }
+ if in.AllowedCapabilities != nil {
+ in, out := &in.AllowedCapabilities, &out.AllowedCapabilities
+ *out = make([]v1.Capability, len(*in))
+ for i := range *in {
+ (*out)[i] = v1.Capability((*in)[i])
+ }
+ } else {
+ out.AllowedCapabilities = nil
+ }
+ if in.Volumes != nil {
+ in, out := &in.Volumes, &out.Volumes
+ *out = make([]FSType, len(*in))
+ for i := range *in {
+ (*out)[i] = FSType((*in)[i])
+ }
+ } else {
+ out.Volumes = nil
+ }
+ out.HostNetwork = in.HostNetwork
+ if in.HostPorts != nil {
+ in, out := &in.HostPorts, &out.HostPorts
+ *out = make([]HostPortRange, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_HostPortRange_To_v1beta1_HostPortRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HostPorts = nil
+ }
+ out.HostPID = in.HostPID
+ out.HostIPC = in.HostIPC
+ if err := Convert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(&in.SELinux, &out.SELinux, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(&in.RunAsUser, &out.RunAsUser, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_SupplementalGroupsStrategyOptions_To_v1beta1_SupplementalGroupsStrategyOptions(&in.SupplementalGroups, &out.SupplementalGroups, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_FSGroupStrategyOptions_To_v1beta1_FSGroupStrategyOptions(&in.FSGroup, &out.FSGroup, s); err != nil {
+ return err
+ }
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
+ return nil
+}
+
+func Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in *extensions.PodSecurityPolicySpec, out *PodSecurityPolicySpec, s conversion.Scope) error {
+ return autoConvert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(in, out, s)
+}
+
+func autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in *ReplicaSet, out *extensions.ReplicaSet, s conversion.Scope) error {
+ SetDefaults_ReplicaSet(in)
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ReplicaSetSpec_To_extensions_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in *ReplicaSet, out *extensions.ReplicaSet, s conversion.Scope) error {
+ return autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in, out, s)
+}
+
+func autoConvert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in *extensions.ReplicaSet, out *ReplicaSet, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in *extensions.ReplicaSet, out *ReplicaSet, s conversion.Scope) error {
+ return autoConvert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(in, out, s)
+}
+
+func autoConvert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in *ReplicaSetList, out *extensions.ReplicaSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.ReplicaSet, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in *ReplicaSetList, out *extensions.ReplicaSetList, s conversion.Scope) error {
+ return autoConvert_v1beta1_ReplicaSetList_To_extensions_ReplicaSetList(in, out, s)
+}
+
+func autoConvert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in *extensions.ReplicaSetList, out *ReplicaSetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ReplicaSet, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in *extensions.ReplicaSetList, out *ReplicaSetList, s conversion.Scope) error {
+ return autoConvert_extensions_ReplicaSetList_To_v1beta1_ReplicaSetList(in, out, s)
+}
+
+func autoConvert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in *ReplicaSetStatus, out *extensions.ReplicaSetStatus, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func Convert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in *ReplicaSetStatus, out *extensions.ReplicaSetStatus, s conversion.Scope) error {
+ return autoConvert_v1beta1_ReplicaSetStatus_To_extensions_ReplicaSetStatus(in, out, s)
+}
+
+func autoConvert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *extensions.ReplicaSetStatus, out *ReplicaSetStatus, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func Convert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *extensions.ReplicaSetStatus, out *ReplicaSetStatus, s conversion.Scope) error {
+ return autoConvert_extensions_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in, out, s)
+}
+
+func autoConvert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in *ReplicationControllerDummy, out *extensions.ReplicationControllerDummy, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in *ReplicationControllerDummy, out *extensions.ReplicationControllerDummy, s conversion.Scope) error {
+ return autoConvert_v1beta1_ReplicationControllerDummy_To_extensions_ReplicationControllerDummy(in, out, s)
+}
+
+func autoConvert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in *extensions.ReplicationControllerDummy, out *ReplicationControllerDummy, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in *extensions.ReplicationControllerDummy, out *ReplicationControllerDummy, s conversion.Scope) error {
+ return autoConvert_extensions_ReplicationControllerDummy_To_v1beta1_ReplicationControllerDummy(in, out, s)
+}
+
+func autoConvert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in *RollbackConfig, out *extensions.RollbackConfig, s conversion.Scope) error {
+ out.Revision = in.Revision
+ return nil
+}
+
+func Convert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in *RollbackConfig, out *extensions.RollbackConfig, s conversion.Scope) error {
+ return autoConvert_v1beta1_RollbackConfig_To_extensions_RollbackConfig(in, out, s)
+}
+
+func autoConvert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in *extensions.RollbackConfig, out *RollbackConfig, s conversion.Scope) error {
+ out.Revision = in.Revision
+ return nil
+}
+
+func Convert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in *extensions.RollbackConfig, out *RollbackConfig, s conversion.Scope) error {
+ return autoConvert_extensions_RollbackConfig_To_v1beta1_RollbackConfig(in, out, s)
+}
+
+func autoConvert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in *RunAsUserStrategyOptions, out *extensions.RunAsUserStrategyOptions, s conversion.Scope) error {
+ out.Rule = extensions.RunAsUserStrategy(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]extensions.IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_IDRange_To_extensions_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in *RunAsUserStrategyOptions, out *extensions.RunAsUserStrategyOptions, s conversion.Scope) error {
+ return autoConvert_v1beta1_RunAsUserStrategyOptions_To_extensions_RunAsUserStrategyOptions(in, out, s)
+}
+
+func autoConvert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in *extensions.RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, s conversion.Scope) error {
+ out.Rule = RunAsUserStrategy(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_IDRange_To_v1beta1_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in *extensions.RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, s conversion.Scope) error {
+ return autoConvert_extensions_RunAsUserStrategyOptions_To_v1beta1_RunAsUserStrategyOptions(in, out, s)
+}
+
+func autoConvert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in *SELinuxStrategyOptions, out *extensions.SELinuxStrategyOptions, s conversion.Scope) error {
+ out.Rule = extensions.SELinuxStrategy(in.Rule)
+ if in.SELinuxOptions != nil {
+ in, out := &in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(api.SELinuxOptions)
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in *SELinuxStrategyOptions, out *extensions.SELinuxStrategyOptions, s conversion.Scope) error {
+ return autoConvert_v1beta1_SELinuxStrategyOptions_To_extensions_SELinuxStrategyOptions(in, out, s)
+}
+
+func autoConvert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in *extensions.SELinuxStrategyOptions, out *SELinuxStrategyOptions, s conversion.Scope) error {
+ out.Rule = SELinuxStrategy(in.Rule)
+ if in.SELinuxOptions != nil {
+ in, out := &in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(v1.SELinuxOptions)
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(*in, *out, 0); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ return nil
+}
+
+func Convert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in *extensions.SELinuxStrategyOptions, out *SELinuxStrategyOptions, s conversion.Scope) error {
+ return autoConvert_extensions_SELinuxStrategyOptions_To_v1beta1_SELinuxStrategyOptions(in, out, s)
+}
+
+func autoConvert_v1beta1_Scale_To_extensions_Scale(in *Scale, out *extensions.Scale, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1beta1_ScaleStatus_To_extensions_ScaleStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_Scale_To_extensions_Scale(in *Scale, out *extensions.Scale, s conversion.Scope) error {
+ return autoConvert_v1beta1_Scale_To_extensions_Scale(in, out, s)
+}
+
+func autoConvert_extensions_Scale_To_v1beta1_Scale(in *extensions.Scale, out *Scale, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_extensions_ScaleStatus_To_v1beta1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_Scale_To_v1beta1_Scale(in *extensions.Scale, out *Scale, s conversion.Scope) error {
+ return autoConvert_extensions_Scale_To_v1beta1_Scale(in, out, s)
+}
+
+func autoConvert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in *ScaleSpec, out *extensions.ScaleSpec, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func Convert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in *ScaleSpec, out *extensions.ScaleSpec, s conversion.Scope) error {
+ return autoConvert_v1beta1_ScaleSpec_To_extensions_ScaleSpec(in, out, s)
+}
+
+func autoConvert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in *extensions.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func Convert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in *extensions.ScaleSpec, out *ScaleSpec, s conversion.Scope) error {
+ return autoConvert_extensions_ScaleSpec_To_v1beta1_ScaleSpec(in, out, s)
+}
+
+func autoConvert_v1beta1_SupplementalGroupsStrategyOptions_To_extensions_SupplementalGroupsStrategyOptions(in *SupplementalGroupsStrategyOptions, out *extensions.SupplementalGroupsStrategyOptions, s conversion.Scope) error {
+ out.Rule = extensions.SupplementalGroupsStrategyType(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]extensions.IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_IDRange_To_extensions_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_SupplementalGroupsStrategyOptions_To_extensions_SupplementalGroupsStrategyOptions(in *SupplementalGroupsStrategyOptions, out *extensions.SupplementalGroupsStrategyOptions, s conversion.Scope) error {
+ return autoConvert_v1beta1_SupplementalGroupsStrategyOptions_To_extensions_SupplementalGroupsStrategyOptions(in, out, s)
+}
+
+func autoConvert_extensions_SupplementalGroupsStrategyOptions_To_v1beta1_SupplementalGroupsStrategyOptions(in *extensions.SupplementalGroupsStrategyOptions, out *SupplementalGroupsStrategyOptions, s conversion.Scope) error {
+ out.Rule = SupplementalGroupsStrategyType(in.Rule)
+ if in.Ranges != nil {
+ in, out := &in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_IDRange_To_v1beta1_IDRange(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func Convert_extensions_SupplementalGroupsStrategyOptions_To_v1beta1_SupplementalGroupsStrategyOptions(in *extensions.SupplementalGroupsStrategyOptions, out *SupplementalGroupsStrategyOptions, s conversion.Scope) error {
+ return autoConvert_extensions_SupplementalGroupsStrategyOptions_To_v1beta1_SupplementalGroupsStrategyOptions(in, out, s)
+}
+
+func autoConvert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in *ThirdPartyResource, out *extensions.ThirdPartyResource, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ out.Description = in.Description
+ if in.Versions != nil {
+ in, out := &in.Versions, &out.Versions
+ *out = make([]extensions.APIVersion, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_APIVersion_To_extensions_APIVersion(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Versions = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in *ThirdPartyResource, out *extensions.ThirdPartyResource, s conversion.Scope) error {
+ return autoConvert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(in, out, s)
+}
+
+func autoConvert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in *extensions.ThirdPartyResource, out *ThirdPartyResource, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ out.Description = in.Description
+ if in.Versions != nil {
+ in, out := &in.Versions, &out.Versions
+ *out = make([]APIVersion, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_APIVersion_To_v1beta1_APIVersion(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Versions = nil
+ }
+ return nil
+}
+
+func Convert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in *extensions.ThirdPartyResource, out *ThirdPartyResource, s conversion.Scope) error {
+ return autoConvert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(in, out, s)
+}
+
+func autoConvert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in *ThirdPartyResourceData, out *extensions.ThirdPartyResourceData, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := conversion.Convert_Slice_byte_To_Slice_byte(&in.Data, &out.Data, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in *ThirdPartyResourceData, out *extensions.ThirdPartyResourceData, s conversion.Scope) error {
+ return autoConvert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(in, out, s)
+}
+
+func autoConvert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in *extensions.ThirdPartyResourceData, out *ThirdPartyResourceData, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := conversion.Convert_Slice_byte_To_Slice_byte(&in.Data, &out.Data, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in *extensions.ThirdPartyResourceData, out *ThirdPartyResourceData, s conversion.Scope) error {
+ return autoConvert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(in, out, s)
+}
+
+func autoConvert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in *ThirdPartyResourceDataList, out *extensions.ThirdPartyResourceDataList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.ThirdPartyResourceData, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_ThirdPartyResourceData_To_extensions_ThirdPartyResourceData(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in *ThirdPartyResourceDataList, out *extensions.ThirdPartyResourceDataList, s conversion.Scope) error {
+ return autoConvert_v1beta1_ThirdPartyResourceDataList_To_extensions_ThirdPartyResourceDataList(in, out, s)
+}
+
+func autoConvert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in *extensions.ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ThirdPartyResourceData, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_ThirdPartyResourceData_To_v1beta1_ThirdPartyResourceData(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in *extensions.ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, s conversion.Scope) error {
+ return autoConvert_extensions_ThirdPartyResourceDataList_To_v1beta1_ThirdPartyResourceDataList(in, out, s)
+}
+
+func autoConvert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in *ThirdPartyResourceList, out *extensions.ThirdPartyResourceList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]extensions.ThirdPartyResource, len(*in))
+ for i := range *in {
+ if err := Convert_v1beta1_ThirdPartyResource_To_extensions_ThirdPartyResource(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in *ThirdPartyResourceList, out *extensions.ThirdPartyResourceList, s conversion.Scope) error {
+ return autoConvert_v1beta1_ThirdPartyResourceList_To_extensions_ThirdPartyResourceList(in, out, s)
+}
+
+func autoConvert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in *extensions.ThirdPartyResourceList, out *ThirdPartyResourceList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ThirdPartyResource, len(*in))
+ for i := range *in {
+ if err := Convert_extensions_ThirdPartyResource_To_v1beta1_ThirdPartyResource(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in *extensions.ThirdPartyResourceList, out *ThirdPartyResourceList, s conversion.Scope) error {
+ return autoConvert_extensions_ThirdPartyResourceList_To_v1beta1_ThirdPartyResourceList(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..32debd197f0a6c2fa5fbb35be988d019eff7a4c4
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/deep_copy_generated.go
@@ -0,0 +1,1297 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1beta1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ resource "k8s.io/kubernetes/pkg/api/resource"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ intstr "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1beta1_APIVersion,
+ DeepCopy_v1beta1_CPUTargetUtilization,
+ DeepCopy_v1beta1_CustomMetricCurrentStatus,
+ DeepCopy_v1beta1_CustomMetricCurrentStatusList,
+ DeepCopy_v1beta1_CustomMetricTarget,
+ DeepCopy_v1beta1_CustomMetricTargetList,
+ DeepCopy_v1beta1_DaemonSet,
+ DeepCopy_v1beta1_DaemonSetList,
+ DeepCopy_v1beta1_DaemonSetSpec,
+ DeepCopy_v1beta1_DaemonSetStatus,
+ DeepCopy_v1beta1_Deployment,
+ DeepCopy_v1beta1_DeploymentList,
+ DeepCopy_v1beta1_DeploymentRollback,
+ DeepCopy_v1beta1_DeploymentSpec,
+ DeepCopy_v1beta1_DeploymentStatus,
+ DeepCopy_v1beta1_DeploymentStrategy,
+ DeepCopy_v1beta1_ExportOptions,
+ DeepCopy_v1beta1_FSGroupStrategyOptions,
+ DeepCopy_v1beta1_HTTPIngressPath,
+ DeepCopy_v1beta1_HTTPIngressRuleValue,
+ DeepCopy_v1beta1_HorizontalPodAutoscaler,
+ DeepCopy_v1beta1_HorizontalPodAutoscalerList,
+ DeepCopy_v1beta1_HorizontalPodAutoscalerSpec,
+ DeepCopy_v1beta1_HorizontalPodAutoscalerStatus,
+ DeepCopy_v1beta1_HostPortRange,
+ DeepCopy_v1beta1_IDRange,
+ DeepCopy_v1beta1_Ingress,
+ DeepCopy_v1beta1_IngressBackend,
+ DeepCopy_v1beta1_IngressList,
+ DeepCopy_v1beta1_IngressRule,
+ DeepCopy_v1beta1_IngressRuleValue,
+ DeepCopy_v1beta1_IngressSpec,
+ DeepCopy_v1beta1_IngressStatus,
+ DeepCopy_v1beta1_IngressTLS,
+ DeepCopy_v1beta1_Job,
+ DeepCopy_v1beta1_JobCondition,
+ DeepCopy_v1beta1_JobList,
+ DeepCopy_v1beta1_JobSpec,
+ DeepCopy_v1beta1_JobStatus,
+ DeepCopy_v1beta1_LabelSelector,
+ DeepCopy_v1beta1_LabelSelectorRequirement,
+ DeepCopy_v1beta1_ListOptions,
+ DeepCopy_v1beta1_NetworkPolicy,
+ DeepCopy_v1beta1_NetworkPolicyIngressRule,
+ DeepCopy_v1beta1_NetworkPolicyList,
+ DeepCopy_v1beta1_NetworkPolicyPeer,
+ DeepCopy_v1beta1_NetworkPolicyPort,
+ DeepCopy_v1beta1_NetworkPolicySpec,
+ DeepCopy_v1beta1_PodSecurityPolicy,
+ DeepCopy_v1beta1_PodSecurityPolicyList,
+ DeepCopy_v1beta1_PodSecurityPolicySpec,
+ DeepCopy_v1beta1_ReplicaSet,
+ DeepCopy_v1beta1_ReplicaSetList,
+ DeepCopy_v1beta1_ReplicaSetSpec,
+ DeepCopy_v1beta1_ReplicaSetStatus,
+ DeepCopy_v1beta1_ReplicationControllerDummy,
+ DeepCopy_v1beta1_RollbackConfig,
+ DeepCopy_v1beta1_RollingUpdateDeployment,
+ DeepCopy_v1beta1_RunAsUserStrategyOptions,
+ DeepCopy_v1beta1_SELinuxStrategyOptions,
+ DeepCopy_v1beta1_Scale,
+ DeepCopy_v1beta1_ScaleSpec,
+ DeepCopy_v1beta1_ScaleStatus,
+ DeepCopy_v1beta1_SubresourceReference,
+ DeepCopy_v1beta1_SupplementalGroupsStrategyOptions,
+ DeepCopy_v1beta1_ThirdPartyResource,
+ DeepCopy_v1beta1_ThirdPartyResourceData,
+ DeepCopy_v1beta1_ThirdPartyResourceDataList,
+ DeepCopy_v1beta1_ThirdPartyResourceList,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1beta1_APIVersion(in APIVersion, out *APIVersion, c *conversion.Cloner) error {
+ out.Name = in.Name
+ return nil
+}
+
+func DeepCopy_v1beta1_CPUTargetUtilization(in CPUTargetUtilization, out *CPUTargetUtilization, c *conversion.Cloner) error {
+ out.TargetPercentage = in.TargetPercentage
+ return nil
+}
+
+func DeepCopy_v1beta1_CustomMetricCurrentStatus(in CustomMetricCurrentStatus, out *CustomMetricCurrentStatus, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := resource.DeepCopy_resource_Quantity(in.CurrentValue, &out.CurrentValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_CustomMetricCurrentStatusList(in CustomMetricCurrentStatusList, out *CustomMetricCurrentStatusList, c *conversion.Cloner) error {
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]CustomMetricCurrentStatus, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_CustomMetricCurrentStatus(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_CustomMetricTarget(in CustomMetricTarget, out *CustomMetricTarget, c *conversion.Cloner) error {
+ out.Name = in.Name
+ if err := resource.DeepCopy_resource_Quantity(in.TargetValue, &out.TargetValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_CustomMetricTargetList(in CustomMetricTargetList, out *CustomMetricTargetList, c *conversion.Cloner) error {
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]CustomMetricTarget, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_CustomMetricTarget(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DaemonSet(in DaemonSet, out *DaemonSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_DaemonSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_DaemonSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DaemonSetList(in DaemonSetList, out *DaemonSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]DaemonSet, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_DaemonSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DaemonSetSpec(in DaemonSetSpec, out *DaemonSetSpec, c *conversion.Cloner) error {
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DaemonSetStatus(in DaemonSetStatus, out *DaemonSetStatus, c *conversion.Cloner) error {
+ out.CurrentNumberScheduled = in.CurrentNumberScheduled
+ out.NumberMisscheduled = in.NumberMisscheduled
+ out.DesiredNumberScheduled = in.DesiredNumberScheduled
+ return nil
+}
+
+func DeepCopy_v1beta1_Deployment(in Deployment, out *Deployment, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_DeploymentSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_DeploymentStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DeploymentList(in DeploymentList, out *DeploymentList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Deployment, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_Deployment(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DeploymentRollback(in DeploymentRollback, out *DeploymentRollback, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Name = in.Name
+ if in.UpdatedAnnotations != nil {
+ in, out := in.UpdatedAnnotations, &out.UpdatedAnnotations
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.UpdatedAnnotations = nil
+ }
+ if err := DeepCopy_v1beta1_RollbackConfig(in.RollbackTo, &out.RollbackTo, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DeploymentSpec(in DeploymentSpec, out *DeploymentSpec, c *conversion.Cloner) error {
+ if in.Replicas != nil {
+ in, out := in.Replicas, &out.Replicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Replicas = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_DeploymentStrategy(in.Strategy, &out.Strategy, c); err != nil {
+ return err
+ }
+ out.MinReadySeconds = in.MinReadySeconds
+ if in.RevisionHistoryLimit != nil {
+ in, out := in.RevisionHistoryLimit, &out.RevisionHistoryLimit
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.RevisionHistoryLimit = nil
+ }
+ out.Paused = in.Paused
+ if in.RollbackTo != nil {
+ in, out := in.RollbackTo, &out.RollbackTo
+ *out = new(RollbackConfig)
+ if err := DeepCopy_v1beta1_RollbackConfig(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RollbackTo = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_DeploymentStatus(in DeploymentStatus, out *DeploymentStatus, c *conversion.Cloner) error {
+ out.ObservedGeneration = in.ObservedGeneration
+ out.Replicas = in.Replicas
+ out.UpdatedReplicas = in.UpdatedReplicas
+ out.AvailableReplicas = in.AvailableReplicas
+ out.UnavailableReplicas = in.UnavailableReplicas
+ return nil
+}
+
+func DeepCopy_v1beta1_DeploymentStrategy(in DeploymentStrategy, out *DeploymentStrategy, c *conversion.Cloner) error {
+ out.Type = in.Type
+ if in.RollingUpdate != nil {
+ in, out := in.RollingUpdate, &out.RollingUpdate
+ *out = new(RollingUpdateDeployment)
+ if err := DeepCopy_v1beta1_RollingUpdateDeployment(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.RollingUpdate = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ExportOptions(in ExportOptions, out *ExportOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.Export = in.Export
+ out.Exact = in.Exact
+ return nil
+}
+
+func DeepCopy_v1beta1_FSGroupStrategyOptions(in FSGroupStrategyOptions, out *FSGroupStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HTTPIngressPath(in HTTPIngressPath, out *HTTPIngressPath, c *conversion.Cloner) error {
+ out.Path = in.Path
+ if err := DeepCopy_v1beta1_IngressBackend(in.Backend, &out.Backend, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HTTPIngressRuleValue(in HTTPIngressRuleValue, out *HTTPIngressRuleValue, c *conversion.Cloner) error {
+ if in.Paths != nil {
+ in, out := in.Paths, &out.Paths
+ *out = make([]HTTPIngressPath, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_HTTPIngressPath(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Paths = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_HorizontalPodAutoscalerSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_HorizontalPodAutoscalerStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HorizontalPodAutoscalerList(in HorizontalPodAutoscalerList, out *HorizontalPodAutoscalerList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]HorizontalPodAutoscaler, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_HorizontalPodAutoscaler(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HorizontalPodAutoscalerSpec(in HorizontalPodAutoscalerSpec, out *HorizontalPodAutoscalerSpec, c *conversion.Cloner) error {
+ if err := DeepCopy_v1beta1_SubresourceReference(in.ScaleRef, &out.ScaleRef, c); err != nil {
+ return err
+ }
+ if in.MinReplicas != nil {
+ in, out := in.MinReplicas, &out.MinReplicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.MinReplicas = nil
+ }
+ out.MaxReplicas = in.MaxReplicas
+ if in.CPUUtilization != nil {
+ in, out := in.CPUUtilization, &out.CPUUtilization
+ *out = new(CPUTargetUtilization)
+ if err := DeepCopy_v1beta1_CPUTargetUtilization(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CPUUtilization = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HorizontalPodAutoscalerStatus(in HorizontalPodAutoscalerStatus, out *HorizontalPodAutoscalerStatus, c *conversion.Cloner) error {
+ if in.ObservedGeneration != nil {
+ in, out := in.ObservedGeneration, &out.ObservedGeneration
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ObservedGeneration = nil
+ }
+ if in.LastScaleTime != nil {
+ in, out := in.LastScaleTime, &out.LastScaleTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.LastScaleTime = nil
+ }
+ out.CurrentReplicas = in.CurrentReplicas
+ out.DesiredReplicas = in.DesiredReplicas
+ if in.CurrentCPUUtilizationPercentage != nil {
+ in, out := in.CurrentCPUUtilizationPercentage, &out.CurrentCPUUtilizationPercentage
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.CurrentCPUUtilizationPercentage = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_HostPortRange(in HostPortRange, out *HostPortRange, c *conversion.Cloner) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func DeepCopy_v1beta1_IDRange(in IDRange, out *IDRange, c *conversion.Cloner) error {
+ out.Min = in.Min
+ out.Max = in.Max
+ return nil
+}
+
+func DeepCopy_v1beta1_Ingress(in Ingress, out *Ingress, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_IngressSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_IngressStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressBackend(in IngressBackend, out *IngressBackend, c *conversion.Cloner) error {
+ out.ServiceName = in.ServiceName
+ if err := intstr.DeepCopy_intstr_IntOrString(in.ServicePort, &out.ServicePort, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressList(in IngressList, out *IngressList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Ingress, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_Ingress(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error {
+ out.Host = in.Host
+ if err := DeepCopy_v1beta1_IngressRuleValue(in.IngressRuleValue, &out.IngressRuleValue, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressRuleValue(in IngressRuleValue, out *IngressRuleValue, c *conversion.Cloner) error {
+ if in.HTTP != nil {
+ in, out := in.HTTP, &out.HTTP
+ *out = new(HTTPIngressRuleValue)
+ if err := DeepCopy_v1beta1_HTTPIngressRuleValue(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.HTTP = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressSpec(in IngressSpec, out *IngressSpec, c *conversion.Cloner) error {
+ if in.Backend != nil {
+ in, out := in.Backend, &out.Backend
+ *out = new(IngressBackend)
+ if err := DeepCopy_v1beta1_IngressBackend(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Backend = nil
+ }
+ if in.TLS != nil {
+ in, out := in.TLS, &out.TLS
+ *out = make([]IngressTLS, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_IngressTLS(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.TLS = nil
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]IngressRule, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_IngressRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressStatus(in IngressStatus, out *IngressStatus, c *conversion.Cloner) error {
+ if err := v1.DeepCopy_v1_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_IngressTLS(in IngressTLS, out *IngressTLS, c *conversion.Cloner) error {
+ if in.Hosts != nil {
+ in, out := in.Hosts, &out.Hosts
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Hosts = nil
+ }
+ out.SecretName = in.SecretName
+ return nil
+}
+
+func DeepCopy_v1beta1_Job(in Job, out *Job, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_JobSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_JobStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_JobCondition(in JobCondition, out *JobCondition, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.Status = in.Status
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastProbeTime, &out.LastProbeTime, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil {
+ return err
+ }
+ out.Reason = in.Reason
+ out.Message = in.Message
+ return nil
+}
+
+func DeepCopy_v1beta1_JobList(in JobList, out *JobList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Job, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_Job(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_JobSpec(in JobSpec, out *JobSpec, c *conversion.Cloner) error {
+ if in.Parallelism != nil {
+ in, out := in.Parallelism, &out.Parallelism
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Parallelism = nil
+ }
+ if in.Completions != nil {
+ in, out := in.Completions, &out.Completions
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Completions = nil
+ }
+ if in.ActiveDeadlineSeconds != nil {
+ in, out := in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.ActiveDeadlineSeconds = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if in.AutoSelector != nil {
+ in, out := in.AutoSelector, &out.AutoSelector
+ *out = new(bool)
+ **out = *in
+ } else {
+ out.AutoSelector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_JobStatus(in JobStatus, out *JobStatus, c *conversion.Cloner) error {
+ if in.Conditions != nil {
+ in, out := in.Conditions, &out.Conditions
+ *out = make([]JobCondition, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_JobCondition(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Conditions = nil
+ }
+ if in.StartTime != nil {
+ in, out := in.StartTime, &out.StartTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.StartTime = nil
+ }
+ if in.CompletionTime != nil {
+ in, out := in.CompletionTime, &out.CompletionTime
+ *out = new(unversioned.Time)
+ if err := unversioned.DeepCopy_unversioned_Time(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.CompletionTime = nil
+ }
+ out.Active = in.Active
+ out.Succeeded = in.Succeeded
+ out.Failed = in.Failed
+ return nil
+}
+
+func DeepCopy_v1beta1_LabelSelector(in LabelSelector, out *LabelSelector, c *conversion.Cloner) error {
+ if in.MatchLabels != nil {
+ in, out := in.MatchLabels, &out.MatchLabels
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.MatchLabels = nil
+ }
+ if in.MatchExpressions != nil {
+ in, out := in.MatchExpressions, &out.MatchExpressions
+ *out = make([]LabelSelectorRequirement, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_LabelSelectorRequirement(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.MatchExpressions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_LabelSelectorRequirement(in LabelSelectorRequirement, out *LabelSelectorRequirement, c *conversion.Cloner) error {
+ out.Key = in.Key
+ out.Operator = in.Operator
+ if in.Values != nil {
+ in, out := in.Values, &out.Values
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Values = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ out.LabelSelector = in.LabelSelector
+ out.FieldSelector = in.FieldSelector
+ out.Watch = in.Watch
+ out.ResourceVersion = in.ResourceVersion
+ if in.TimeoutSeconds != nil {
+ in, out := in.TimeoutSeconds, &out.TimeoutSeconds
+ *out = new(int64)
+ **out = *in
+ } else {
+ out.TimeoutSeconds = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicy(in NetworkPolicy, out *NetworkPolicy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_NetworkPolicySpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicyIngressRule(in NetworkPolicyIngressRule, out *NetworkPolicyIngressRule, c *conversion.Cloner) error {
+ if in.Ports != nil {
+ in, out := in.Ports, &out.Ports
+ *out = make([]NetworkPolicyPort, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_NetworkPolicyPort(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ports = nil
+ }
+ if in.From != nil {
+ in, out := in.From, &out.From
+ *out = make([]NetworkPolicyPeer, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_NetworkPolicyPeer(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.From = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicyList(in NetworkPolicyList, out *NetworkPolicyList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]NetworkPolicy, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_NetworkPolicy(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicyPeer(in NetworkPolicyPeer, out *NetworkPolicyPeer, c *conversion.Cloner) error {
+ if in.PodSelector != nil {
+ in, out := in.PodSelector, &out.PodSelector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.PodSelector = nil
+ }
+ if in.NamespaceSelector != nil {
+ in, out := in.NamespaceSelector, &out.NamespaceSelector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.NamespaceSelector = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicyPort(in NetworkPolicyPort, out *NetworkPolicyPort, c *conversion.Cloner) error {
+ if in.Protocol != nil {
+ in, out := in.Protocol, &out.Protocol
+ *out = new(v1.Protocol)
+ **out = *in
+ } else {
+ out.Protocol = nil
+ }
+ if in.Port != nil {
+ in, out := in.Port, &out.Port
+ *out = new(intstr.IntOrString)
+ if err := intstr.DeepCopy_intstr_IntOrString(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Port = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_NetworkPolicySpec(in NetworkPolicySpec, out *NetworkPolicySpec, c *conversion.Cloner) error {
+ if err := DeepCopy_v1beta1_LabelSelector(in.PodSelector, &out.PodSelector, c); err != nil {
+ return err
+ }
+ if in.Ingress != nil {
+ in, out := in.Ingress, &out.Ingress
+ *out = make([]NetworkPolicyIngressRule, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_NetworkPolicyIngressRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ingress = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_PodSecurityPolicy(in PodSecurityPolicy, out *PodSecurityPolicy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_PodSecurityPolicySpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_PodSecurityPolicyList(in PodSecurityPolicyList, out *PodSecurityPolicyList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PodSecurityPolicy, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_PodSecurityPolicy(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_PodSecurityPolicySpec(in PodSecurityPolicySpec, out *PodSecurityPolicySpec, c *conversion.Cloner) error {
+ out.Privileged = in.Privileged
+ if in.DefaultAddCapabilities != nil {
+ in, out := in.DefaultAddCapabilities, &out.DefaultAddCapabilities
+ *out = make([]v1.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.DefaultAddCapabilities = nil
+ }
+ if in.RequiredDropCapabilities != nil {
+ in, out := in.RequiredDropCapabilities, &out.RequiredDropCapabilities
+ *out = make([]v1.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.RequiredDropCapabilities = nil
+ }
+ if in.AllowedCapabilities != nil {
+ in, out := in.AllowedCapabilities, &out.AllowedCapabilities
+ *out = make([]v1.Capability, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.AllowedCapabilities = nil
+ }
+ if in.Volumes != nil {
+ in, out := in.Volumes, &out.Volumes
+ *out = make([]FSType, len(in))
+ for i := range in {
+ (*out)[i] = in[i]
+ }
+ } else {
+ out.Volumes = nil
+ }
+ out.HostNetwork = in.HostNetwork
+ if in.HostPorts != nil {
+ in, out := in.HostPorts, &out.HostPorts
+ *out = make([]HostPortRange, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_HostPortRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.HostPorts = nil
+ }
+ out.HostPID = in.HostPID
+ out.HostIPC = in.HostIPC
+ if err := DeepCopy_v1beta1_SELinuxStrategyOptions(in.SELinux, &out.SELinux, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_RunAsUserStrategyOptions(in.RunAsUser, &out.RunAsUser, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_SupplementalGroupsStrategyOptions(in.SupplementalGroups, &out.SupplementalGroups, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_FSGroupStrategyOptions(in.FSGroup, &out.FSGroup, c); err != nil {
+ return err
+ }
+ out.ReadOnlyRootFilesystem = in.ReadOnlyRootFilesystem
+ return nil
+}
+
+func DeepCopy_v1beta1_ReplicaSet(in ReplicaSet, out *ReplicaSet, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ReplicaSetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ReplicaSetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ReplicaSetList(in ReplicaSetList, out *ReplicaSetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ReplicaSet, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_ReplicaSet(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ReplicaSetSpec(in ReplicaSetSpec, out *ReplicaSetSpec, c *conversion.Cloner) error {
+ if in.Replicas != nil {
+ in, out := in.Replicas, &out.Replicas
+ *out = new(int32)
+ **out = *in
+ } else {
+ out.Replicas = nil
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(LabelSelector)
+ if err := DeepCopy_v1beta1_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ if err := v1.DeepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ReplicaSetStatus(in ReplicaSetStatus, out *ReplicaSetStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ out.FullyLabeledReplicas = in.FullyLabeledReplicas
+ out.ObservedGeneration = in.ObservedGeneration
+ return nil
+}
+
+func DeepCopy_v1beta1_ReplicationControllerDummy(in ReplicationControllerDummy, out *ReplicationControllerDummy, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_RollbackConfig(in RollbackConfig, out *RollbackConfig, c *conversion.Cloner) error {
+ out.Revision = in.Revision
+ return nil
+}
+
+func DeepCopy_v1beta1_RollingUpdateDeployment(in RollingUpdateDeployment, out *RollingUpdateDeployment, c *conversion.Cloner) error {
+ if in.MaxUnavailable != nil {
+ in, out := in.MaxUnavailable, &out.MaxUnavailable
+ *out = new(intstr.IntOrString)
+ if err := intstr.DeepCopy_intstr_IntOrString(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.MaxUnavailable = nil
+ }
+ if in.MaxSurge != nil {
+ in, out := in.MaxSurge, &out.MaxSurge
+ *out = new(intstr.IntOrString)
+ if err := intstr.DeepCopy_intstr_IntOrString(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.MaxSurge = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_RunAsUserStrategyOptions(in RunAsUserStrategyOptions, out *RunAsUserStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_SELinuxStrategyOptions(in SELinuxStrategyOptions, out *SELinuxStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.SELinuxOptions != nil {
+ in, out := in.SELinuxOptions, &out.SELinuxOptions
+ *out = new(v1.SELinuxOptions)
+ if err := v1.DeepCopy_v1_SELinuxOptions(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.SELinuxOptions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_Scale(in Scale, out *Scale, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ScaleSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1beta1_ScaleStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ScaleSpec(in ScaleSpec, out *ScaleSpec, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ return nil
+}
+
+func DeepCopy_v1beta1_ScaleStatus(in ScaleStatus, out *ScaleStatus, c *conversion.Cloner) error {
+ out.Replicas = in.Replicas
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = make(map[string]string)
+ for key, val := range in {
+ (*out)[key] = val
+ }
+ } else {
+ out.Selector = nil
+ }
+ out.TargetSelector = in.TargetSelector
+ return nil
+}
+
+func DeepCopy_v1beta1_SubresourceReference(in SubresourceReference, out *SubresourceReference, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.Name = in.Name
+ out.APIVersion = in.APIVersion
+ out.Subresource = in.Subresource
+ return nil
+}
+
+func DeepCopy_v1beta1_SupplementalGroupsStrategyOptions(in SupplementalGroupsStrategyOptions, out *SupplementalGroupsStrategyOptions, c *conversion.Cloner) error {
+ out.Rule = in.Rule
+ if in.Ranges != nil {
+ in, out := in.Ranges, &out.Ranges
+ *out = make([]IDRange, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_IDRange(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Ranges = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ThirdPartyResource(in ThirdPartyResource, out *ThirdPartyResource, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ out.Description = in.Description
+ if in.Versions != nil {
+ in, out := in.Versions, &out.Versions
+ *out = make([]APIVersion, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_APIVersion(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Versions = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ThirdPartyResourceData(in ThirdPartyResourceData, out *ThirdPartyResourceData, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Data != nil {
+ in, out := in.Data, &out.Data
+ *out = make([]byte, len(in))
+ copy(*out, in)
+ } else {
+ out.Data = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ThirdPartyResourceDataList(in ThirdPartyResourceDataList, out *ThirdPartyResourceDataList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ThirdPartyResourceData, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_ThirdPartyResourceData(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1beta1_ThirdPartyResourceList(in ThirdPartyResourceList, out *ThirdPartyResourceList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ThirdPartyResource, len(in))
+ for i := range in {
+ if err := DeepCopy_v1beta1_ThirdPartyResource(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..71e55a467a96c7f09b5db483abda4743dee4a55e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/defaults.go
@@ -0,0 +1,167 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) {
+ scheme.AddDefaultingFuncs(
+ SetDefaults_DaemonSet,
+ SetDefaults_Deployment,
+ SetDefaults_Job,
+ SetDefaults_HorizontalPodAutoscaler,
+ SetDefaults_ReplicaSet,
+ SetDefaults_NetworkPolicy,
+ )
+}
+
+func SetDefaults_DaemonSet(obj *DaemonSet) {
+ labels := obj.Spec.Template.Labels
+
+ // TODO: support templates defined elsewhere when we support them in the API
+ if labels != nil {
+ if obj.Spec.Selector == nil {
+ obj.Spec.Selector = &LabelSelector{
+ MatchLabels: labels,
+ }
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+}
+
+func SetDefaults_Deployment(obj *Deployment) {
+ // Default labels and selector to labels from pod template spec.
+ labels := obj.Spec.Template.Labels
+
+ if labels != nil {
+ if obj.Spec.Selector == nil {
+ obj.Spec.Selector = &LabelSelector{MatchLabels: labels}
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+ // Set DeploymentSpec.Replicas to 1 if it is not set.
+ if obj.Spec.Replicas == nil {
+ obj.Spec.Replicas = new(int32)
+ *obj.Spec.Replicas = 1
+ }
+ strategy := &obj.Spec.Strategy
+ // Set default DeploymentStrategyType as RollingUpdate.
+ if strategy.Type == "" {
+ strategy.Type = RollingUpdateDeploymentStrategyType
+ }
+ if strategy.Type == RollingUpdateDeploymentStrategyType {
+ if strategy.RollingUpdate == nil {
+ rollingUpdate := RollingUpdateDeployment{}
+ strategy.RollingUpdate = &rollingUpdate
+ }
+ if strategy.RollingUpdate.MaxUnavailable == nil {
+ // Set default MaxUnavailable as 1 by default.
+ maxUnavailable := intstr.FromInt(1)
+ strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
+ }
+ if strategy.RollingUpdate.MaxSurge == nil {
+ // Set default MaxSurge as 1 by default.
+ maxSurge := intstr.FromInt(1)
+ strategy.RollingUpdate.MaxSurge = &maxSurge
+ }
+ }
+}
+
+func SetDefaults_Job(obj *Job) {
+ labels := obj.Spec.Template.Labels
+ // TODO: support templates defined elsewhere when we support them in the API
+ if labels != nil {
+ // if an autoselector is requested, we'll build the selector later with controller-uid and job-name
+ autoSelector := bool(obj.Spec.AutoSelector != nil && *obj.Spec.AutoSelector)
+
+ // otherwise, we are using a manual selector
+ manualSelector := !autoSelector
+
+ // and default behavior for an unspecified manual selector is to use the pod template labels
+ if manualSelector && obj.Spec.Selector == nil {
+ obj.Spec.Selector = &LabelSelector{
+ MatchLabels: labels,
+ }
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+ // For a non-parallel job, you can leave both `.spec.completions` and
+ // `.spec.parallelism` unset. When both are unset, both are defaulted to 1.
+ if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
+ obj.Spec.Completions = new(int32)
+ *obj.Spec.Completions = 1
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+ if obj.Spec.Parallelism == nil {
+ obj.Spec.Parallelism = new(int32)
+ *obj.Spec.Parallelism = 1
+ }
+}
+
+func SetDefaults_HorizontalPodAutoscaler(obj *HorizontalPodAutoscaler) {
+ if obj.Spec.MinReplicas == nil {
+ minReplicas := int32(1)
+ obj.Spec.MinReplicas = &minReplicas
+ }
+ if obj.Spec.CPUUtilization == nil {
+ obj.Spec.CPUUtilization = &CPUTargetUtilization{TargetPercentage: 80}
+ }
+}
+
+func SetDefaults_ReplicaSet(obj *ReplicaSet) {
+ labels := obj.Spec.Template.Labels
+
+ // TODO: support templates defined elsewhere when we support them in the API
+ if labels != nil {
+ if obj.Spec.Selector == nil {
+ obj.Spec.Selector = &LabelSelector{
+ MatchLabels: labels,
+ }
+ }
+ if len(obj.Labels) == 0 {
+ obj.Labels = labels
+ }
+ }
+ if obj.Spec.Replicas == nil {
+ obj.Spec.Replicas = new(int32)
+ *obj.Spec.Replicas = 1
+ }
+}
+
+func SetDefaults_NetworkPolicy(obj *NetworkPolicy) {
+ // Default any undefined Protocol fields to TCP.
+ for _, i := range obj.Spec.Ingress {
+ // TODO: Update Ports to be a pointer to slice as soon as auto-generation supports it.
+ for _, p := range i.Ports {
+ if p.Protocol == nil {
+ proto := v1.ProtocolTCP
+ p.Protocol = &proto
+ }
+ }
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfdb87c53d848bec83a37e7fca7492be7790d03e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +genconversion=true
+package v1beta1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..3120ce17ff312c11679f342c481f359418bd76cb
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.pb.go
@@ -0,0 +1,13005 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1beta1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.proto
+
+ It has these top-level messages:
+ APIVersion
+ CPUTargetUtilization
+ CustomMetricCurrentStatus
+ CustomMetricCurrentStatusList
+ CustomMetricTarget
+ CustomMetricTargetList
+ DaemonSet
+ DaemonSetList
+ DaemonSetSpec
+ DaemonSetStatus
+ Deployment
+ DeploymentList
+ DeploymentRollback
+ DeploymentSpec
+ DeploymentStatus
+ DeploymentStrategy
+ ExportOptions
+ FSGroupStrategyOptions
+ HTTPIngressPath
+ HTTPIngressRuleValue
+ HorizontalPodAutoscaler
+ HorizontalPodAutoscalerList
+ HorizontalPodAutoscalerSpec
+ HorizontalPodAutoscalerStatus
+ HostPortRange
+ IDRange
+ Ingress
+ IngressBackend
+ IngressList
+ IngressRule
+ IngressRuleValue
+ IngressSpec
+ IngressStatus
+ IngressTLS
+ Job
+ JobCondition
+ JobList
+ JobSpec
+ JobStatus
+ LabelSelector
+ LabelSelectorRequirement
+ ListOptions
+ NetworkPolicy
+ NetworkPolicyIngressRule
+ NetworkPolicyList
+ NetworkPolicyPeer
+ NetworkPolicyPort
+ NetworkPolicySpec
+ PodSecurityPolicy
+ PodSecurityPolicyList
+ PodSecurityPolicySpec
+ ReplicaSet
+ ReplicaSetList
+ ReplicaSetSpec
+ ReplicaSetStatus
+ ReplicationControllerDummy
+ RollbackConfig
+ RollingUpdateDeployment
+ RunAsUserStrategyOptions
+ SELinuxStrategyOptions
+ Scale
+ ScaleSpec
+ ScaleStatus
+ SubresourceReference
+ SupplementalGroupsStrategyOptions
+ ThirdPartyResource
+ ThirdPartyResourceData
+ ThirdPartyResourceDataList
+ ThirdPartyResourceList
+*/
+package v1beta1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
+
+import k8s_io_kubernetes_pkg_util_intstr "k8s.io/kubernetes/pkg/util/intstr"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *APIVersion) Reset() { *m = APIVersion{} }
+func (m *APIVersion) String() string { return proto.CompactTextString(m) }
+func (*APIVersion) ProtoMessage() {}
+
+func (m *CPUTargetUtilization) Reset() { *m = CPUTargetUtilization{} }
+func (m *CPUTargetUtilization) String() string { return proto.CompactTextString(m) }
+func (*CPUTargetUtilization) ProtoMessage() {}
+
+func (m *CustomMetricCurrentStatus) Reset() { *m = CustomMetricCurrentStatus{} }
+func (m *CustomMetricCurrentStatus) String() string { return proto.CompactTextString(m) }
+func (*CustomMetricCurrentStatus) ProtoMessage() {}
+
+func (m *CustomMetricCurrentStatusList) Reset() { *m = CustomMetricCurrentStatusList{} }
+func (m *CustomMetricCurrentStatusList) String() string { return proto.CompactTextString(m) }
+func (*CustomMetricCurrentStatusList) ProtoMessage() {}
+
+func (m *CustomMetricTarget) Reset() { *m = CustomMetricTarget{} }
+func (m *CustomMetricTarget) String() string { return proto.CompactTextString(m) }
+func (*CustomMetricTarget) ProtoMessage() {}
+
+func (m *CustomMetricTargetList) Reset() { *m = CustomMetricTargetList{} }
+func (m *CustomMetricTargetList) String() string { return proto.CompactTextString(m) }
+func (*CustomMetricTargetList) ProtoMessage() {}
+
+func (m *DaemonSet) Reset() { *m = DaemonSet{} }
+func (m *DaemonSet) String() string { return proto.CompactTextString(m) }
+func (*DaemonSet) ProtoMessage() {}
+
+func (m *DaemonSetList) Reset() { *m = DaemonSetList{} }
+func (m *DaemonSetList) String() string { return proto.CompactTextString(m) }
+func (*DaemonSetList) ProtoMessage() {}
+
+func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} }
+func (m *DaemonSetSpec) String() string { return proto.CompactTextString(m) }
+func (*DaemonSetSpec) ProtoMessage() {}
+
+func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} }
+func (m *DaemonSetStatus) String() string { return proto.CompactTextString(m) }
+func (*DaemonSetStatus) ProtoMessage() {}
+
+func (m *Deployment) Reset() { *m = Deployment{} }
+func (m *Deployment) String() string { return proto.CompactTextString(m) }
+func (*Deployment) ProtoMessage() {}
+
+func (m *DeploymentList) Reset() { *m = DeploymentList{} }
+func (m *DeploymentList) String() string { return proto.CompactTextString(m) }
+func (*DeploymentList) ProtoMessage() {}
+
+func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} }
+func (m *DeploymentRollback) String() string { return proto.CompactTextString(m) }
+func (*DeploymentRollback) ProtoMessage() {}
+
+func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} }
+func (m *DeploymentSpec) String() string { return proto.CompactTextString(m) }
+func (*DeploymentSpec) ProtoMessage() {}
+
+func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} }
+func (m *DeploymentStatus) String() string { return proto.CompactTextString(m) }
+func (*DeploymentStatus) ProtoMessage() {}
+
+func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} }
+func (m *DeploymentStrategy) String() string { return proto.CompactTextString(m) }
+func (*DeploymentStrategy) ProtoMessage() {}
+
+func (m *ExportOptions) Reset() { *m = ExportOptions{} }
+func (m *ExportOptions) String() string { return proto.CompactTextString(m) }
+func (*ExportOptions) ProtoMessage() {}
+
+func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} }
+func (m *FSGroupStrategyOptions) String() string { return proto.CompactTextString(m) }
+func (*FSGroupStrategyOptions) ProtoMessage() {}
+
+func (m *HTTPIngressPath) Reset() { *m = HTTPIngressPath{} }
+func (m *HTTPIngressPath) String() string { return proto.CompactTextString(m) }
+func (*HTTPIngressPath) ProtoMessage() {}
+
+func (m *HTTPIngressRuleValue) Reset() { *m = HTTPIngressRuleValue{} }
+func (m *HTTPIngressRuleValue) String() string { return proto.CompactTextString(m) }
+func (*HTTPIngressRuleValue) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscaler) Reset() { *m = HorizontalPodAutoscaler{} }
+func (m *HorizontalPodAutoscaler) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscaler) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerList) Reset() { *m = HorizontalPodAutoscalerList{} }
+func (m *HorizontalPodAutoscalerList) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerList) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerSpec) Reset() { *m = HorizontalPodAutoscalerSpec{} }
+func (m *HorizontalPodAutoscalerSpec) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerSpec) ProtoMessage() {}
+
+func (m *HorizontalPodAutoscalerStatus) Reset() { *m = HorizontalPodAutoscalerStatus{} }
+func (m *HorizontalPodAutoscalerStatus) String() string { return proto.CompactTextString(m) }
+func (*HorizontalPodAutoscalerStatus) ProtoMessage() {}
+
+func (m *HostPortRange) Reset() { *m = HostPortRange{} }
+func (m *HostPortRange) String() string { return proto.CompactTextString(m) }
+func (*HostPortRange) ProtoMessage() {}
+
+func (m *IDRange) Reset() { *m = IDRange{} }
+func (m *IDRange) String() string { return proto.CompactTextString(m) }
+func (*IDRange) ProtoMessage() {}
+
+func (m *Ingress) Reset() { *m = Ingress{} }
+func (m *Ingress) String() string { return proto.CompactTextString(m) }
+func (*Ingress) ProtoMessage() {}
+
+func (m *IngressBackend) Reset() { *m = IngressBackend{} }
+func (m *IngressBackend) String() string { return proto.CompactTextString(m) }
+func (*IngressBackend) ProtoMessage() {}
+
+func (m *IngressList) Reset() { *m = IngressList{} }
+func (m *IngressList) String() string { return proto.CompactTextString(m) }
+func (*IngressList) ProtoMessage() {}
+
+func (m *IngressRule) Reset() { *m = IngressRule{} }
+func (m *IngressRule) String() string { return proto.CompactTextString(m) }
+func (*IngressRule) ProtoMessage() {}
+
+func (m *IngressRuleValue) Reset() { *m = IngressRuleValue{} }
+func (m *IngressRuleValue) String() string { return proto.CompactTextString(m) }
+func (*IngressRuleValue) ProtoMessage() {}
+
+func (m *IngressSpec) Reset() { *m = IngressSpec{} }
+func (m *IngressSpec) String() string { return proto.CompactTextString(m) }
+func (*IngressSpec) ProtoMessage() {}
+
+func (m *IngressStatus) Reset() { *m = IngressStatus{} }
+func (m *IngressStatus) String() string { return proto.CompactTextString(m) }
+func (*IngressStatus) ProtoMessage() {}
+
+func (m *IngressTLS) Reset() { *m = IngressTLS{} }
+func (m *IngressTLS) String() string { return proto.CompactTextString(m) }
+func (*IngressTLS) ProtoMessage() {}
+
+func (m *Job) Reset() { *m = Job{} }
+func (m *Job) String() string { return proto.CompactTextString(m) }
+func (*Job) ProtoMessage() {}
+
+func (m *JobCondition) Reset() { *m = JobCondition{} }
+func (m *JobCondition) String() string { return proto.CompactTextString(m) }
+func (*JobCondition) ProtoMessage() {}
+
+func (m *JobList) Reset() { *m = JobList{} }
+func (m *JobList) String() string { return proto.CompactTextString(m) }
+func (*JobList) ProtoMessage() {}
+
+func (m *JobSpec) Reset() { *m = JobSpec{} }
+func (m *JobSpec) String() string { return proto.CompactTextString(m) }
+func (*JobSpec) ProtoMessage() {}
+
+func (m *JobStatus) Reset() { *m = JobStatus{} }
+func (m *JobStatus) String() string { return proto.CompactTextString(m) }
+func (*JobStatus) ProtoMessage() {}
+
+func (m *LabelSelector) Reset() { *m = LabelSelector{} }
+func (m *LabelSelector) String() string { return proto.CompactTextString(m) }
+func (*LabelSelector) ProtoMessage() {}
+
+func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} }
+func (m *LabelSelectorRequirement) String() string { return proto.CompactTextString(m) }
+func (*LabelSelectorRequirement) ProtoMessage() {}
+
+func (m *ListOptions) Reset() { *m = ListOptions{} }
+func (m *ListOptions) String() string { return proto.CompactTextString(m) }
+func (*ListOptions) ProtoMessage() {}
+
+func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} }
+func (m *NetworkPolicy) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicy) ProtoMessage() {}
+
+func (m *NetworkPolicyIngressRule) Reset() { *m = NetworkPolicyIngressRule{} }
+func (m *NetworkPolicyIngressRule) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicyIngressRule) ProtoMessage() {}
+
+func (m *NetworkPolicyList) Reset() { *m = NetworkPolicyList{} }
+func (m *NetworkPolicyList) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicyList) ProtoMessage() {}
+
+func (m *NetworkPolicyPeer) Reset() { *m = NetworkPolicyPeer{} }
+func (m *NetworkPolicyPeer) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicyPeer) ProtoMessage() {}
+
+func (m *NetworkPolicyPort) Reset() { *m = NetworkPolicyPort{} }
+func (m *NetworkPolicyPort) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicyPort) ProtoMessage() {}
+
+func (m *NetworkPolicySpec) Reset() { *m = NetworkPolicySpec{} }
+func (m *NetworkPolicySpec) String() string { return proto.CompactTextString(m) }
+func (*NetworkPolicySpec) ProtoMessage() {}
+
+func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} }
+func (m *PodSecurityPolicy) String() string { return proto.CompactTextString(m) }
+func (*PodSecurityPolicy) ProtoMessage() {}
+
+func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} }
+func (m *PodSecurityPolicyList) String() string { return proto.CompactTextString(m) }
+func (*PodSecurityPolicyList) ProtoMessage() {}
+
+func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} }
+func (m *PodSecurityPolicySpec) String() string { return proto.CompactTextString(m) }
+func (*PodSecurityPolicySpec) ProtoMessage() {}
+
+func (m *ReplicaSet) Reset() { *m = ReplicaSet{} }
+func (m *ReplicaSet) String() string { return proto.CompactTextString(m) }
+func (*ReplicaSet) ProtoMessage() {}
+
+func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} }
+func (m *ReplicaSetList) String() string { return proto.CompactTextString(m) }
+func (*ReplicaSetList) ProtoMessage() {}
+
+func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} }
+func (m *ReplicaSetSpec) String() string { return proto.CompactTextString(m) }
+func (*ReplicaSetSpec) ProtoMessage() {}
+
+func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} }
+func (m *ReplicaSetStatus) String() string { return proto.CompactTextString(m) }
+func (*ReplicaSetStatus) ProtoMessage() {}
+
+func (m *ReplicationControllerDummy) Reset() { *m = ReplicationControllerDummy{} }
+func (m *ReplicationControllerDummy) String() string { return proto.CompactTextString(m) }
+func (*ReplicationControllerDummy) ProtoMessage() {}
+
+func (m *RollbackConfig) Reset() { *m = RollbackConfig{} }
+func (m *RollbackConfig) String() string { return proto.CompactTextString(m) }
+func (*RollbackConfig) ProtoMessage() {}
+
+func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
+func (m *RollingUpdateDeployment) String() string { return proto.CompactTextString(m) }
+func (*RollingUpdateDeployment) ProtoMessage() {}
+
+func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} }
+func (m *RunAsUserStrategyOptions) String() string { return proto.CompactTextString(m) }
+func (*RunAsUserStrategyOptions) ProtoMessage() {}
+
+func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} }
+func (m *SELinuxStrategyOptions) String() string { return proto.CompactTextString(m) }
+func (*SELinuxStrategyOptions) ProtoMessage() {}
+
+func (m *Scale) Reset() { *m = Scale{} }
+func (m *Scale) String() string { return proto.CompactTextString(m) }
+func (*Scale) ProtoMessage() {}
+
+func (m *ScaleSpec) Reset() { *m = ScaleSpec{} }
+func (m *ScaleSpec) String() string { return proto.CompactTextString(m) }
+func (*ScaleSpec) ProtoMessage() {}
+
+func (m *ScaleStatus) Reset() { *m = ScaleStatus{} }
+func (m *ScaleStatus) String() string { return proto.CompactTextString(m) }
+func (*ScaleStatus) ProtoMessage() {}
+
+func (m *SubresourceReference) Reset() { *m = SubresourceReference{} }
+func (m *SubresourceReference) String() string { return proto.CompactTextString(m) }
+func (*SubresourceReference) ProtoMessage() {}
+
+func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} }
+func (m *SupplementalGroupsStrategyOptions) String() string { return proto.CompactTextString(m) }
+func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
+
+func (m *ThirdPartyResource) Reset() { *m = ThirdPartyResource{} }
+func (m *ThirdPartyResource) String() string { return proto.CompactTextString(m) }
+func (*ThirdPartyResource) ProtoMessage() {}
+
+func (m *ThirdPartyResourceData) Reset() { *m = ThirdPartyResourceData{} }
+func (m *ThirdPartyResourceData) String() string { return proto.CompactTextString(m) }
+func (*ThirdPartyResourceData) ProtoMessage() {}
+
+func (m *ThirdPartyResourceDataList) Reset() { *m = ThirdPartyResourceDataList{} }
+func (m *ThirdPartyResourceDataList) String() string { return proto.CompactTextString(m) }
+func (*ThirdPartyResourceDataList) ProtoMessage() {}
+
+func (m *ThirdPartyResourceList) Reset() { *m = ThirdPartyResourceList{} }
+func (m *ThirdPartyResourceList) String() string { return proto.CompactTextString(m) }
+func (*ThirdPartyResourceList) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*APIVersion)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.APIVersion")
+ proto.RegisterType((*CPUTargetUtilization)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.CPUTargetUtilization")
+ proto.RegisterType((*CustomMetricCurrentStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.CustomMetricCurrentStatus")
+ proto.RegisterType((*CustomMetricCurrentStatusList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.CustomMetricCurrentStatusList")
+ proto.RegisterType((*CustomMetricTarget)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.CustomMetricTarget")
+ proto.RegisterType((*CustomMetricTargetList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.CustomMetricTargetList")
+ proto.RegisterType((*DaemonSet)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DaemonSet")
+ proto.RegisterType((*DaemonSetList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DaemonSetList")
+ proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DaemonSetSpec")
+ proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DaemonSetStatus")
+ proto.RegisterType((*Deployment)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.Deployment")
+ proto.RegisterType((*DeploymentList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DeploymentList")
+ proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DeploymentRollback")
+ proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DeploymentSpec")
+ proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DeploymentStatus")
+ proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.DeploymentStrategy")
+ proto.RegisterType((*ExportOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ExportOptions")
+ proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.FSGroupStrategyOptions")
+ proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HTTPIngressPath")
+ proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HTTPIngressRuleValue")
+ proto.RegisterType((*HorizontalPodAutoscaler)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HorizontalPodAutoscaler")
+ proto.RegisterType((*HorizontalPodAutoscalerList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HorizontalPodAutoscalerList")
+ proto.RegisterType((*HorizontalPodAutoscalerSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HorizontalPodAutoscalerSpec")
+ proto.RegisterType((*HorizontalPodAutoscalerStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HorizontalPodAutoscalerStatus")
+ proto.RegisterType((*HostPortRange)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.HostPortRange")
+ proto.RegisterType((*IDRange)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IDRange")
+ proto.RegisterType((*Ingress)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.Ingress")
+ proto.RegisterType((*IngressBackend)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressBackend")
+ proto.RegisterType((*IngressList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressList")
+ proto.RegisterType((*IngressRule)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressRule")
+ proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressRuleValue")
+ proto.RegisterType((*IngressSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressSpec")
+ proto.RegisterType((*IngressStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressStatus")
+ proto.RegisterType((*IngressTLS)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.IngressTLS")
+ proto.RegisterType((*Job)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.Job")
+ proto.RegisterType((*JobCondition)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.JobCondition")
+ proto.RegisterType((*JobList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.JobList")
+ proto.RegisterType((*JobSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.JobSpec")
+ proto.RegisterType((*JobStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.JobStatus")
+ proto.RegisterType((*LabelSelector)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.LabelSelector")
+ proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.LabelSelectorRequirement")
+ proto.RegisterType((*ListOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ListOptions")
+ proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicy")
+ proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicyIngressRule")
+ proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicyList")
+ proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicyPeer")
+ proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicyPort")
+ proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.NetworkPolicySpec")
+ proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.PodSecurityPolicy")
+ proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.PodSecurityPolicyList")
+ proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.PodSecurityPolicySpec")
+ proto.RegisterType((*ReplicaSet)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ReplicaSet")
+ proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ReplicaSetList")
+ proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ReplicaSetSpec")
+ proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ReplicaSetStatus")
+ proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ReplicationControllerDummy")
+ proto.RegisterType((*RollbackConfig)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.RollbackConfig")
+ proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.RollingUpdateDeployment")
+ proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.RunAsUserStrategyOptions")
+ proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.SELinuxStrategyOptions")
+ proto.RegisterType((*Scale)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.Scale")
+ proto.RegisterType((*ScaleSpec)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ScaleSpec")
+ proto.RegisterType((*ScaleStatus)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ScaleStatus")
+ proto.RegisterType((*SubresourceReference)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.SubresourceReference")
+ proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.SupplementalGroupsStrategyOptions")
+ proto.RegisterType((*ThirdPartyResource)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ThirdPartyResource")
+ proto.RegisterType((*ThirdPartyResourceData)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ThirdPartyResourceData")
+ proto.RegisterType((*ThirdPartyResourceDataList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ThirdPartyResourceDataList")
+ proto.RegisterType((*ThirdPartyResourceList)(nil), "k8s.io.kubernetes.pkg.apis.extensions.v1beta1.ThirdPartyResourceList")
+}
+func (m *APIVersion) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *APIVersion) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ return i, nil
+}
+
+func (m *CPUTargetUtilization) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CPUTargetUtilization) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TargetPercentage))
+ return i, nil
+}
+
+func (m *CustomMetricCurrentStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CustomMetricCurrentStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CurrentValue.Size()))
+ n1, err := m.CurrentValue.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ return i, nil
+}
+
+func (m *CustomMetricCurrentStatusList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CustomMetricCurrentStatusList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *CustomMetricTarget) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CustomMetricTarget) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TargetValue.Size()))
+ n2, err := m.TargetValue.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ return i, nil
+}
+
+func (m *CustomMetricTargetList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *CustomMetricTargetList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *DaemonSet) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DaemonSet) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n3, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n4, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n5, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ return i, nil
+}
+
+func (m *DaemonSetList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DaemonSetList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n6, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *DaemonSetSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DaemonSetSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Selector != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n7, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n8, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ return i, nil
+}
+
+func (m *DaemonSetStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DaemonSetStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CurrentNumberScheduled))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NumberMisscheduled))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DesiredNumberScheduled))
+ return i, nil
+}
+
+func (m *Deployment) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Deployment) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n9, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n10, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n10
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n11, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n11
+ return i, nil
+}
+
+func (m *DeploymentList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeploymentList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n12, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n12
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *DeploymentRollback) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeploymentRollback) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ if len(m.UpdatedAnnotations) > 0 {
+ for k := range m.UpdatedAnnotations {
+ data[i] = 0x12
+ i++
+ v := m.UpdatedAnnotations[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RollbackTo.Size()))
+ n13, err := m.RollbackTo.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n13
+ return i, nil
+}
+
+func (m *DeploymentSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeploymentSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n14, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n14
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n15, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n15
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Strategy.Size()))
+ n16, err := m.Strategy.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n16
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MinReadySeconds))
+ if m.RevisionHistoryLimit != nil {
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.RevisionHistoryLimit))
+ }
+ data[i] = 0x38
+ i++
+ if m.Paused {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if m.RollbackTo != nil {
+ data[i] = 0x42
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RollbackTo.Size()))
+ n17, err := m.RollbackTo.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n17
+ }
+ return i, nil
+}
+
+func (m *DeploymentStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeploymentStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObservedGeneration))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.UpdatedReplicas))
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AvailableReplicas))
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.UnavailableReplicas))
+ return i, nil
+}
+
+func (m *DeploymentStrategy) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *DeploymentStrategy) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ if m.RollingUpdate != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RollingUpdate.Size()))
+ n18, err := m.RollingUpdate.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n18
+ }
+ return i, nil
+}
+
+func (m *ExportOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ExportOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Export {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ if m.Exact {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *FSGroupStrategyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *FSGroupStrategyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Rule)))
+ i += copy(data[i:], m.Rule)
+ if len(m.Ranges) > 0 {
+ for _, msg := range m.Ranges {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *HTTPIngressPath) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HTTPIngressPath) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Path)))
+ i += copy(data[i:], m.Path)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Backend.Size()))
+ n19, err := m.Backend.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n19
+ return i, nil
+}
+
+func (m *HTTPIngressRuleValue) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HTTPIngressRuleValue) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Paths) > 0 {
+ for _, msg := range m.Paths {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscaler) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscaler) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n20, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n20
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n21, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n21
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n22, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n22
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n23, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n23
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ScaleRef.Size()))
+ n24, err := m.ScaleRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n24
+ if m.MinReplicas != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.MinReplicas))
+ }
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MaxReplicas))
+ if m.CPUUtilization != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CPUUtilization.Size()))
+ n25, err := m.CPUUtilization.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n25
+ }
+ return i, nil
+}
+
+func (m *HorizontalPodAutoscalerStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HorizontalPodAutoscalerStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ObservedGeneration))
+ }
+ if m.LastScaleTime != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastScaleTime.Size()))
+ n26, err := m.LastScaleTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n26
+ }
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CurrentReplicas))
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DesiredReplicas))
+ if m.CurrentCPUUtilizationPercentage != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.CurrentCPUUtilizationPercentage))
+ }
+ return i, nil
+}
+
+func (m *HostPortRange) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *HostPortRange) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Min))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Max))
+ return i, nil
+}
+
+func (m *IDRange) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IDRange) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Min))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Max))
+ return i, nil
+}
+
+func (m *Ingress) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Ingress) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n27, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n27
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n28, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n28
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n29, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n29
+ return i, nil
+}
+
+func (m *IngressBackend) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressBackend) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ServiceName)))
+ i += copy(data[i:], m.ServiceName)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ServicePort.Size()))
+ n30, err := m.ServicePort.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n30
+ return i, nil
+}
+
+func (m *IngressList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n31, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n31
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *IngressRule) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressRule) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Host)))
+ i += copy(data[i:], m.Host)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.IngressRuleValue.Size()))
+ n32, err := m.IngressRuleValue.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n32
+ return i, nil
+}
+
+func (m *IngressRuleValue) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressRuleValue) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.HTTP != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.HTTP.Size()))
+ n33, err := m.HTTP.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n33
+ }
+ return i, nil
+}
+
+func (m *IngressSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Backend != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Backend.Size()))
+ n34, err := m.Backend.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n34
+ }
+ if len(m.TLS) > 0 {
+ for _, msg := range m.TLS {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.Rules) > 0 {
+ for _, msg := range m.Rules {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *IngressStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LoadBalancer.Size()))
+ n35, err := m.LoadBalancer.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n35
+ return i, nil
+}
+
+func (m *IngressTLS) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IngressTLS) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Hosts) > 0 {
+ for _, s := range m.Hosts {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.SecretName)))
+ i += copy(data[i:], m.SecretName)
+ return i, nil
+}
+
+func (m *Job) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Job) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n36, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n36
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n37, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n37
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n38, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n38
+ return i, nil
+}
+
+func (m *JobCondition) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobCondition) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
+ i += copy(data[i:], m.Status)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
+ n39, err := m.LastProbeTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n39
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
+ n40, err := m.LastTransitionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n40
+ data[i] = 0x2a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
+ i += copy(data[i:], m.Reason)
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
+ i += copy(data[i:], m.Message)
+ return i, nil
+}
+
+func (m *JobList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n41, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n41
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *JobSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n42, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n42
+ }
+ if m.AutoSelector != nil {
+ data[i] = 0x28
+ i++
+ if *m.AutoSelector {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ }
+ data[i] = 0x32
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n43, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n43
+ return i, nil
+}
+
+func (m *JobStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *JobStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, msg := range m.Conditions {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if m.StartTime != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.StartTime.Size()))
+ n44, err := m.StartTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n44
+ }
+ if m.CompletionTime != nil {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CompletionTime.Size()))
+ n45, err := m.CompletionTime.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n45
+ }
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Active))
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Succeeded))
+ data[i] = 0x30
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Failed))
+ return i, nil
+}
+
+func (m *LabelSelector) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelector) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k := range m.MatchLabels {
+ data[i] = 0xa
+ i++
+ v := m.MatchLabels[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, msg := range m.MatchExpressions {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *LabelSelectorRequirement) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *LabelSelectorRequirement) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Key)))
+ i += copy(data[i:], m.Key)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Operator)))
+ i += copy(data[i:], m.Operator)
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *ListOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ListOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.LabelSelector)))
+ i += copy(data[i:], m.LabelSelector)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.FieldSelector)))
+ i += copy(data[i:], m.FieldSelector)
+ data[i] = 0x18
+ i++
+ if m.Watch {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ResourceVersion)))
+ i += copy(data[i:], m.ResourceVersion)
+ if m.TimeoutSeconds != nil {
+ data[i] = 0x28
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.TimeoutSeconds))
+ }
+ return i, nil
+}
+
+func (m *NetworkPolicy) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicy) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n46, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n46
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n47, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n47
+ return i, nil
+}
+
+func (m *NetworkPolicyIngressRule) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicyIngressRule) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Ports) > 0 {
+ for _, msg := range m.Ports {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ if len(m.From) > 0 {
+ for _, msg := range m.From {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NetworkPolicyList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicyList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n48, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n48
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *NetworkPolicyPeer) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicyPeer) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.PodSelector != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PodSelector.Size()))
+ n49, err := m.PodSelector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n49
+ }
+ if m.NamespaceSelector != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.NamespaceSelector.Size()))
+ n50, err := m.NamespaceSelector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n50
+ }
+ return i, nil
+}
+
+func (m *NetworkPolicyPort) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicyPort) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Protocol != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(*m.Protocol)))
+ i += copy(data[i:], *m.Protocol)
+ }
+ if m.Port != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Port.Size()))
+ n51, err := m.Port.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n51
+ }
+ return i, nil
+}
+
+func (m *NetworkPolicySpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *NetworkPolicySpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.PodSelector.Size()))
+ n52, err := m.PodSelector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n52
+ if len(m.Ingress) > 0 {
+ for _, msg := range m.Ingress {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodSecurityPolicy) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodSecurityPolicy) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n53, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n53
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n54, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n54
+ return i, nil
+}
+
+func (m *PodSecurityPolicyList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodSecurityPolicyList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n55, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n55
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodSecurityPolicySpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodSecurityPolicySpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.Privileged {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if len(m.DefaultAddCapabilities) > 0 {
+ for _, s := range m.DefaultAddCapabilities {
+ data[i] = 0x12
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.RequiredDropCapabilities) > 0 {
+ for _, s := range m.RequiredDropCapabilities {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.AllowedCapabilities) > 0 {
+ for _, s := range m.AllowedCapabilities {
+ data[i] = 0x22
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.Volumes) > 0 {
+ for _, s := range m.Volumes {
+ data[i] = 0x2a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x30
+ i++
+ if m.HostNetwork {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ if len(m.HostPorts) > 0 {
+ for _, msg := range m.HostPorts {
+ data[i] = 0x3a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x40
+ i++
+ if m.HostPID {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x48
+ i++
+ if m.HostIPC {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x52
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SELinux.Size()))
+ n56, err := m.SELinux.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n56
+ data[i] = 0x5a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RunAsUser.Size()))
+ n57, err := m.RunAsUser.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n57
+ data[i] = 0x62
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SupplementalGroups.Size()))
+ n58, err := m.SupplementalGroups.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n58
+ data[i] = 0x6a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FSGroup.Size()))
+ n59, err := m.FSGroup.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n59
+ data[i] = 0x70
+ i++
+ if m.ReadOnlyRootFilesystem {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ return i, nil
+}
+
+func (m *ReplicaSet) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicaSet) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n60, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n60
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n61, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n61
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n62, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n62
+ return i, nil
+}
+
+func (m *ReplicaSetList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicaSetList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n63, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n63
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ReplicaSetSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicaSetSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n64, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n64
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
+ n65, err := m.Template.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n65
+ return i, nil
+}
+
+func (m *ReplicaSetStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicaSetStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.FullyLabeledReplicas))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObservedGeneration))
+ return i, nil
+}
+
+func (m *ReplicationControllerDummy) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ReplicationControllerDummy) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ return i, nil
+}
+
+func (m *RollbackConfig) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RollbackConfig) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Revision))
+ return i, nil
+}
+
+func (m *RollingUpdateDeployment) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RollingUpdateDeployment) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.MaxUnavailable != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MaxUnavailable.Size()))
+ n66, err := m.MaxUnavailable.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n66
+ }
+ if m.MaxSurge != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MaxSurge.Size()))
+ n67, err := m.MaxSurge.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n67
+ }
+ return i, nil
+}
+
+func (m *RunAsUserStrategyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RunAsUserStrategyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Rule)))
+ i += copy(data[i:], m.Rule)
+ if len(m.Ranges) > 0 {
+ for _, msg := range m.Ranges {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *SELinuxStrategyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SELinuxStrategyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Rule)))
+ i += copy(data[i:], m.Rule)
+ if m.SELinuxOptions != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.SELinuxOptions.Size()))
+ n68, err := m.SELinuxOptions.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n68
+ }
+ return i, nil
+}
+
+func (m *Scale) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Scale) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n69, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n69
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n70, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n70
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n71, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n71
+ return i, nil
+}
+
+func (m *ScaleSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScaleSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ return i, nil
+}
+
+func (m *ScaleStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ScaleStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Replicas))
+ if len(m.Selector) > 0 {
+ for k := range m.Selector {
+ data[i] = 0x12
+ i++
+ v := m.Selector[k]
+ mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ i = encodeVarintGenerated(data, i, uint64(mapSize))
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(k)))
+ i += copy(data[i:], k)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(v)))
+ i += copy(data[i:], v)
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.TargetSelector)))
+ i += copy(data[i:], m.TargetSelector)
+ return i, nil
+}
+
+func (m *SubresourceReference) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SubresourceReference) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Subresource)))
+ i += copy(data[i:], m.Subresource)
+ return i, nil
+}
+
+func (m *SupplementalGroupsStrategyOptions) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *SupplementalGroupsStrategyOptions) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Rule)))
+ i += copy(data[i:], m.Rule)
+ if len(m.Ranges) > 0 {
+ for _, msg := range m.Ranges {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ThirdPartyResource) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ThirdPartyResource) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n72, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n72
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Description)))
+ i += copy(data[i:], m.Description)
+ if len(m.Versions) > 0 {
+ for _, msg := range m.Versions {
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ThirdPartyResourceData) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ThirdPartyResourceData) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n73, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n73
+ if m.Data != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Data)))
+ i += copy(data[i:], m.Data)
+ }
+ return i, nil
+}
+
+func (m *ThirdPartyResourceDataList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ThirdPartyResourceDataList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n74, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n74
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ThirdPartyResourceList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ThirdPartyResourceList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n75, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n75
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *APIVersion) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *CPUTargetUtilization) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.TargetPercentage))
+ return n
+}
+
+func (m *CustomMetricCurrentStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.CurrentValue.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *CustomMetricCurrentStatusList) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *CustomMetricTarget) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.TargetValue.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *CustomMetricTargetList) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *DaemonSet) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *DaemonSetList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *DaemonSetSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *DaemonSetStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
+ n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
+ n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
+ return n
+}
+
+func (m *Deployment) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *DeploymentList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *DeploymentRollback) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.UpdatedAnnotations) > 0 {
+ for k, v := range m.UpdatedAnnotations {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = m.RollbackTo.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *DeploymentSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ n += 1 + sovGenerated(uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Strategy.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 1 + sovGenerated(uint64(m.MinReadySeconds))
+ if m.RevisionHistoryLimit != nil {
+ n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
+ }
+ n += 2
+ if m.RollbackTo != nil {
+ l = m.RollbackTo.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *DeploymentStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.ObservedGeneration))
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
+ n += 1 + sovGenerated(uint64(m.AvailableReplicas))
+ n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
+ return n
+}
+
+func (m *DeploymentStrategy) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.RollingUpdate != nil {
+ l = m.RollingUpdate.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ExportOptions) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 2
+ return n
+}
+
+func (m *FSGroupStrategyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Rule)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Ranges) > 0 {
+ for _, e := range m.Ranges {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *HTTPIngressPath) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Path)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Backend.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *HTTPIngressRuleValue) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Paths) > 0 {
+ for _, e := range m.Paths {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *HorizontalPodAutoscaler) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *HorizontalPodAutoscalerList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *HorizontalPodAutoscalerSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ScaleRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.MinReplicas != nil {
+ n += 1 + sovGenerated(uint64(*m.MinReplicas))
+ }
+ n += 1 + sovGenerated(uint64(m.MaxReplicas))
+ if m.CPUUtilization != nil {
+ l = m.CPUUtilization.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *HorizontalPodAutoscalerStatus) Size() (n int) {
+ var l int
+ _ = l
+ if m.ObservedGeneration != nil {
+ n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
+ }
+ if m.LastScaleTime != nil {
+ l = m.LastScaleTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.CurrentReplicas))
+ n += 1 + sovGenerated(uint64(m.DesiredReplicas))
+ if m.CurrentCPUUtilizationPercentage != nil {
+ n += 1 + sovGenerated(uint64(*m.CurrentCPUUtilizationPercentage))
+ }
+ return n
+}
+
+func (m *HostPortRange) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Min))
+ n += 1 + sovGenerated(uint64(m.Max))
+ return n
+}
+
+func (m *IDRange) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Min))
+ n += 1 + sovGenerated(uint64(m.Max))
+ return n
+}
+
+func (m *Ingress) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *IngressBackend) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.ServiceName)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.ServicePort.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *IngressList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *IngressRule) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Host)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.IngressRuleValue.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *IngressRuleValue) Size() (n int) {
+ var l int
+ _ = l
+ if m.HTTP != nil {
+ l = m.HTTP.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *IngressSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Backend != nil {
+ l = m.Backend.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if len(m.TLS) > 0 {
+ for _, e := range m.TLS {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Rules) > 0 {
+ for _, e := range m.Rules {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *IngressStatus) Size() (n int) {
+ var l int
+ _ = l
+ l = m.LoadBalancer.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *IngressTLS) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Hosts) > 0 {
+ for _, s := range m.Hosts {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = len(m.SecretName)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Job) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobCondition) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Status)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastProbeTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.LastTransitionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Reason)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Message)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *JobSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Parallelism != nil {
+ n += 1 + sovGenerated(uint64(*m.Parallelism))
+ }
+ if m.Completions != nil {
+ n += 1 + sovGenerated(uint64(*m.Completions))
+ }
+ if m.ActiveDeadlineSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.AutoSelector != nil {
+ n += 2
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *JobStatus) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Conditions) > 0 {
+ for _, e := range m.Conditions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if m.StartTime != nil {
+ l = m.StartTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.CompletionTime != nil {
+ l = m.CompletionTime.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ n += 1 + sovGenerated(uint64(m.Active))
+ n += 1 + sovGenerated(uint64(m.Succeeded))
+ n += 1 + sovGenerated(uint64(m.Failed))
+ return n
+}
+
+func (m *LabelSelector) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.MatchLabels) > 0 {
+ for k, v := range m.MatchLabels {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ if len(m.MatchExpressions) > 0 {
+ for _, e := range m.MatchExpressions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *LabelSelectorRequirement) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Key)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Operator)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Values) > 0 {
+ for _, s := range m.Values {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ListOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.LabelSelector)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.FieldSelector)
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ l = len(m.ResourceVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.TimeoutSeconds != nil {
+ n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
+ }
+ return n
+}
+
+func (m *NetworkPolicy) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *NetworkPolicyIngressRule) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Ports) > 0 {
+ for _, e := range m.Ports {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.From) > 0 {
+ for _, e := range m.From {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NetworkPolicyList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *NetworkPolicyPeer) Size() (n int) {
+ var l int
+ _ = l
+ if m.PodSelector != nil {
+ l = m.PodSelector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.NamespaceSelector != nil {
+ l = m.NamespaceSelector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *NetworkPolicyPort) Size() (n int) {
+ var l int
+ _ = l
+ if m.Protocol != nil {
+ l = len(*m.Protocol)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.Port != nil {
+ l = m.Port.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *NetworkPolicySpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.PodSelector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Ingress) > 0 {
+ for _, e := range m.Ingress {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodSecurityPolicy) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodSecurityPolicyList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodSecurityPolicySpec) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ if len(m.DefaultAddCapabilities) > 0 {
+ for _, s := range m.DefaultAddCapabilities {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.RequiredDropCapabilities) > 0 {
+ for _, s := range m.RequiredDropCapabilities {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.AllowedCapabilities) > 0 {
+ for _, s := range m.AllowedCapabilities {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Volumes) > 0 {
+ for _, s := range m.Volumes {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ n += 2
+ if len(m.HostPorts) > 0 {
+ for _, e := range m.HostPorts {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ n += 2
+ n += 2
+ l = m.SELinux.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.RunAsUser.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.SupplementalGroups.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.FSGroup.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ n += 2
+ return n
+}
+
+func (m *ReplicaSet) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ReplicaSetList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ReplicaSetSpec) Size() (n int) {
+ var l int
+ _ = l
+ if m.Replicas != nil {
+ n += 1 + sovGenerated(uint64(*m.Replicas))
+ }
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = m.Template.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ReplicaSetStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
+ n += 1 + sovGenerated(uint64(m.ObservedGeneration))
+ return n
+}
+
+func (m *ReplicationControllerDummy) Size() (n int) {
+ var l int
+ _ = l
+ return n
+}
+
+func (m *RollbackConfig) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Revision))
+ return n
+}
+
+func (m *RollingUpdateDeployment) Size() (n int) {
+ var l int
+ _ = l
+ if m.MaxUnavailable != nil {
+ l = m.MaxUnavailable.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ if m.MaxSurge != nil {
+ l = m.MaxSurge.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *RunAsUserStrategyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Rule)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Ranges) > 0 {
+ for _, e := range m.Ranges {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *SELinuxStrategyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Rule)
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.SELinuxOptions != nil {
+ l = m.SELinuxOptions.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *Scale) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ScaleSpec) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ return n
+}
+
+func (m *ScaleStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Replicas))
+ if len(m.Selector) > 0 {
+ for k, v := range m.Selector {
+ _ = k
+ _ = v
+ mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+ n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+ }
+ }
+ l = len(m.TargetSelector)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *SubresourceReference) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Subresource)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Rule)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Ranges) > 0 {
+ for _, e := range m.Ranges {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ThirdPartyResource) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Description)
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Versions) > 0 {
+ for _, e := range m.Versions {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ThirdPartyResourceData) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Data != nil {
+ l = len(m.Data)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *ThirdPartyResourceDataList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ThirdPartyResourceList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *APIVersion) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: APIVersion: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: APIVersion: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CPUTargetUtilization) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CPUTargetUtilization: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CPUTargetUtilization: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetPercentage", wireType)
+ }
+ m.TargetPercentage = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.TargetPercentage |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CustomMetricCurrentStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CustomMetricCurrentStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CustomMetricCurrentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentValue", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.CurrentValue.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CustomMetricCurrentStatusList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CustomMetricCurrentStatusList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CustomMetricCurrentStatusList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, CustomMetricCurrentStatus{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CustomMetricTarget) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CustomMetricTarget: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CustomMetricTarget: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetValue", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.TargetValue.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *CustomMetricTargetList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: CustomMetricTargetList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CustomMetricTargetList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, CustomMetricTarget{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DaemonSet) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DaemonSetList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, DaemonSet{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DaemonSetSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DaemonSetStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
+ }
+ m.CurrentNumberScheduled = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
+ }
+ m.NumberMisscheduled = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.NumberMisscheduled |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
+ }
+ m.DesiredNumberScheduled = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Deployment) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeploymentList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Deployment{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeploymentRollback) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.UpdatedAnnotations == nil {
+ m.UpdatedAnnotations = make(map[string]string)
+ }
+ m.UpdatedAnnotations[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.RollbackTo.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeploymentSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Replicas = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Strategy.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
+ }
+ m.MinReadySeconds = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.MinReadySeconds |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.RevisionHistoryLimit = &v
+ case 7:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Paused = bool(v != 0)
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.RollbackTo == nil {
+ m.RollbackTo = &RollbackConfig{}
+ }
+ if err := m.RollbackTo.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeploymentStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ m.ObservedGeneration = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ObservedGeneration |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
+ }
+ m.UpdatedReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
+ }
+ m.AvailableReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.AvailableReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
+ }
+ m.UnavailableReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DeploymentStrategy) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = DeploymentStrategyType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.RollingUpdate == nil {
+ m.RollingUpdate = &RollingUpdateDeployment{}
+ }
+ if err := m.RollingUpdate.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ExportOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Export = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Exact = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *FSGroupStrategyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rule = FSGroupStrategyType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ranges = append(m.Ranges, IDRange{})
+ if err := m.Ranges[len(m.Ranges)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HTTPIngressPath) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Path = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Backend.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HTTPIngressRuleValue) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Paths = append(m.Paths, HTTPIngressPath{})
+ if err := m.Paths[len(m.Paths)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscaler) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscaler: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, HorizontalPodAutoscaler{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ScaleRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ScaleRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MinReplicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.MinReplicas = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxReplicas", wireType)
+ }
+ m.MaxReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.MaxReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CPUUtilization", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CPUUtilization == nil {
+ m.CPUUtilization = &CPUTargetUtilization{}
+ }
+ if err := m.CPUUtilization.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HorizontalPodAutoscalerStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ObservedGeneration = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastScaleTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.LastScaleTime == nil {
+ m.LastScaleTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.LastScaleTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
+ }
+ m.CurrentReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.CurrentReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DesiredReplicas", wireType)
+ }
+ m.DesiredReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.DesiredReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentCPUUtilizationPercentage", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CurrentCPUUtilizationPercentage = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *HostPortRange) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
+ }
+ m.Min = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Min |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
+ }
+ m.Max = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Max |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IDRange) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
+ }
+ m.Min = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Min |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
+ }
+ m.Max = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Max |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Ingress) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressBackend) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ServiceName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ServicePort.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Ingress{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressRule) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Host = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.IngressRuleValue.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressRuleValue) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.HTTP == nil {
+ m.HTTP = &HTTPIngressRuleValue{}
+ }
+ if err := m.HTTP.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Backend == nil {
+ m.Backend = &IngressBackend{}
+ }
+ if err := m.Backend.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TLS = append(m.TLS, IngressTLS{})
+ if err := m.TLS[len(m.TLS)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rules = append(m.Rules, IngressRule{})
+ if err := m.Rules[len(m.Rules)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LoadBalancer.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *IngressTLS) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Hosts = append(m.Hosts, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.SecretName = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Job) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Job: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobCondition) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobCondition: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobCondition: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = JobConditionType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Status = k8s_io_kubernetes_pkg_api_v1.ConditionStatus(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Reason = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Message = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Job{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Parallelism", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Parallelism = &v
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Completions", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Completions = &v
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ActiveDeadlineSeconds = &v
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AutoSelector", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ b := bool(v != 0)
+ m.AutoSelector = &b
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *JobStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: JobStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Conditions = append(m.Conditions, JobCondition{})
+ if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.StartTime == nil {
+ m.StartTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.StartTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.CompletionTime == nil {
+ m.CompletionTime = &k8s_io_kubernetes_pkg_api_unversioned.Time{}
+ }
+ if err := m.CompletionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
+ }
+ m.Active = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Active |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
+ }
+ m.Succeeded = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Succeeded |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
+ }
+ m.Failed = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Failed |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelector) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.MatchLabels == nil {
+ m.MatchLabels = make(map[string]string)
+ }
+ m.MatchLabels[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
+ if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *LabelSelectorRequirement) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Key = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Operator = LabelSelectorOperator(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Values = append(m.Values, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ListOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ListOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.LabelSelector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FieldSelector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Watch = bool(v != 0)
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
+ }
+ var v int64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.TimeoutSeconds = &v
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicy) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicyIngressRule) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ports = append(m.Ports, NetworkPolicyPort{})
+ if err := m.Ports[len(m.Ports)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.From = append(m.From, NetworkPolicyPeer{})
+ if err := m.From[len(m.From)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicyList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, NetworkPolicy{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicyPeer) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.PodSelector == nil {
+ m.PodSelector = &LabelSelector{}
+ }
+ if err := m.PodSelector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.NamespaceSelector == nil {
+ m.NamespaceSelector = &LabelSelector{}
+ }
+ if err := m.NamespaceSelector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicyPort) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ s := k8s_io_kubernetes_pkg_api_v1.Protocol(data[iNdEx:postIndex])
+ m.Protocol = &s
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Port == nil {
+ m.Port = &k8s_io_kubernetes_pkg_util_intstr.IntOrString{}
+ }
+ if err := m.Port.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NetworkPolicySpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.PodSelector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{})
+ if err := m.Ingress[len(m.Ingress)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodSecurityPolicy) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodSecurityPolicyList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PodSecurityPolicy{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodSecurityPolicySpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Privileged = bool(v != 0)
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_kubernetes_pkg_api_v1.Capability(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_kubernetes_pkg_api_v1.Capability(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_kubernetes_pkg_api_v1.Capability(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Volumes = append(m.Volumes, FSType(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostNetwork = bool(v != 0)
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.HostPorts = append(m.HostPorts, HostPortRange{})
+ if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostPID = bool(v != 0)
+ case 9:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.HostIPC = bool(v != 0)
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.SELinux.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.RunAsUser.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.SupplementalGroups.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.FSGroup.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 14:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.ReadOnlyRootFilesystem = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicaSet) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicaSetList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ReplicaSet{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicaSetSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ var v int32
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Replicas = &v
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicaSetStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
+ }
+ m.FullyLabeledReplicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
+ }
+ m.ObservedGeneration = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ObservedGeneration |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ReplicationControllerDummy) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RollbackConfig) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+ }
+ m.Revision = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Revision |= (int64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RollingUpdateDeployment) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.MaxUnavailable == nil {
+ m.MaxUnavailable = &k8s_io_kubernetes_pkg_util_intstr.IntOrString{}
+ }
+ if err := m.MaxUnavailable.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.MaxSurge == nil {
+ m.MaxSurge = &k8s_io_kubernetes_pkg_util_intstr.IntOrString{}
+ }
+ if err := m.MaxSurge.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RunAsUserStrategyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rule = RunAsUserStrategy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ranges = append(m.Ranges, IDRange{})
+ if err := m.Ranges[len(m.Ranges)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SELinuxStrategyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rule = SELinuxStrategy(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.SELinuxOptions == nil {
+ m.SELinuxOptions = &k8s_io_kubernetes_pkg_api_v1.SELinuxOptions{}
+ }
+ if err := m.SELinuxOptions.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Scale) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Scale: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScaleSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ScaleStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
+ }
+ m.Replicas = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Replicas |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var keykey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ keykey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapkey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapkey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapkey := int(stringLenmapkey)
+ if intStringLenmapkey < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapkey := iNdEx + intStringLenmapkey
+ if postStringIndexmapkey > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapkey := string(data[iNdEx:postStringIndexmapkey])
+ iNdEx = postStringIndexmapkey
+ var valuekey uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ valuekey |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ var stringLenmapvalue uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLenmapvalue := int(stringLenmapvalue)
+ if intStringLenmapvalue < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+ if postStringIndexmapvalue > l {
+ return io.ErrUnexpectedEOF
+ }
+ mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+ iNdEx = postStringIndexmapvalue
+ if m.Selector == nil {
+ m.Selector = make(map[string]string)
+ }
+ m.Selector[mapkey] = mapvalue
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.TargetSelector = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SubresourceReference) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SubresourceReference: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SubresourceReference: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subresource", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subresource = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *SupplementalGroupsStrategyOptions) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rule = SupplementalGroupsStrategyType(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Ranges = append(m.Ranges, IDRange{})
+ if err := m.Ranges[len(m.Ranges)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ThirdPartyResource) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ThirdPartyResource: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ThirdPartyResource: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Versions = append(m.Versions, APIVersion{})
+ if err := m.Versions[len(m.Versions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ThirdPartyResourceData) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ThirdPartyResourceData: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ThirdPartyResourceData: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ byteLen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Data = append(m.Data[:0], data[iNdEx:postIndex]...)
+ if m.Data == nil {
+ m.Data = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ThirdPartyResourceDataList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ThirdPartyResourceDataList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ThirdPartyResourceDataList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ThirdPartyResourceData{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ThirdPartyResourceList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ThirdPartyResourceList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ThirdPartyResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ThirdPartyResource{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..bd4da6974f244c28023bb9595519b8318e3c05c4
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/generated.proto
@@ -0,0 +1,1010 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.extensions.v1beta1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1beta1";
+
+// An APIVersion represents a single concrete version of an object model.
+message APIVersion {
+ // Name of this version (e.g. 'v1').
+ optional string name = 1;
+}
+
+message CPUTargetUtilization {
+ // fraction of the requested CPU that should be utilized/used,
+ // e.g. 70 means that 70% of the requested CPU should be in use.
+ optional int32 targetPercentage = 1;
+}
+
+message CustomMetricCurrentStatus {
+ // Custom Metric name.
+ optional string name = 1;
+
+ // Custom Metric value (average).
+ optional k8s.io.kubernetes.pkg.api.resource.Quantity value = 2;
+}
+
+message CustomMetricCurrentStatusList {
+ repeated CustomMetricCurrentStatus items = 1;
+}
+
+// Alpha-level support for Custom Metrics in HPA (as annotations).
+message CustomMetricTarget {
+ // Custom Metric name.
+ optional string name = 1;
+
+ // Custom Metric value (average).
+ optional k8s.io.kubernetes.pkg.api.resource.Quantity value = 2;
+}
+
+message CustomMetricTargetList {
+ repeated CustomMetricTarget items = 1;
+}
+
+// DaemonSet represents the configuration of a daemon set.
+message DaemonSet {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec defines the desired behavior of this daemon set.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional DaemonSetSpec spec = 2;
+
+ // Status is 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional DaemonSetStatus status = 3;
+}
+
+// DaemonSetList is a collection of daemon sets.
+message DaemonSetList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of daemon sets.
+ repeated DaemonSet items = 2;
+}
+
+// DaemonSetSpec is the specification of a daemon set.
+message DaemonSetSpec {
+ // Selector is a label query over pods that are managed by the daemon set.
+ // Must match in order to be controlled.
+ // If empty, defaulted to labels on Pod template.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional LabelSelector selector = 1;
+
+ // Template is the 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: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 2;
+}
+
+// DaemonSetStatus represents the current status of a daemon set.
+message DaemonSetStatus {
+ // CurrentNumberScheduled is the number of nodes that are running at least 1
+ // daemon pod and are supposed to run the daemon pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ optional int32 currentNumberScheduled = 1;
+
+ // NumberMisscheduled is the number of nodes that are running the daemon pod, but are
+ // not supposed to run the daemon pod.
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ optional int32 numberMisscheduled = 2;
+
+ // DesiredNumberScheduled is the total number of nodes that should be running the daemon
+ // pod (including nodes correctly running the daemon pod).
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ optional int32 desiredNumberScheduled = 3;
+}
+
+// Deployment enables declarative updates for Pods and ReplicaSets.
+message Deployment {
+ // Standard object metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior of the Deployment.
+ optional DeploymentSpec spec = 2;
+
+ // Most recently observed status of the Deployment.
+ optional DeploymentStatus status = 3;
+}
+
+// DeploymentList is a list of Deployments.
+message DeploymentList {
+ // Standard list metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Deployments.
+ repeated Deployment items = 2;
+}
+
+// DeploymentRollback stores the information required to rollback a deployment.
+message DeploymentRollback {
+ // Required: This must match the Name of a deployment.
+ optional string name = 1;
+
+ // The annotations to be updated to a deployment
+ map<string, string> updatedAnnotations = 2;
+
+ // The config of this deployment rollback.
+ optional RollbackConfig rollbackTo = 3;
+}
+
+// DeploymentSpec is the specification of the desired behavior of the Deployment.
+message DeploymentSpec {
+ // Number of desired pods. This is a pointer to distinguish between explicit
+ // zero and not specified. Defaults to 1.
+ optional int32 replicas = 1;
+
+ // Label selector for pods. Existing ReplicaSets whose pods are
+ // selected by this will be the ones affected by this deployment.
+ optional LabelSelector selector = 2;
+
+ // Template describes the pods that will be created.
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 3;
+
+ // The deployment strategy to use to replace existing pods with new ones.
+ optional DeploymentStrategy strategy = 4;
+
+ // 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)
+ optional int32 minReadySeconds = 5;
+
+ // The number of old ReplicaSets to retain to allow rollback.
+ // This is a pointer to distinguish between explicit zero and not specified.
+ optional int32 revisionHistoryLimit = 6;
+
+ // Indicates that the deployment is paused and will not be processed by the
+ // deployment controller.
+ optional bool paused = 7;
+
+ // The config this deployment is rolling back to. Will be cleared after rollback is done.
+ optional RollbackConfig rollbackTo = 8;
+}
+
+// DeploymentStatus is the most recently observed status of the Deployment.
+message DeploymentStatus {
+ // The generation observed by the deployment controller.
+ optional int64 observedGeneration = 1;
+
+ // Total number of non-terminated pods targeted by this deployment (their labels match the selector).
+ optional int32 replicas = 2;
+
+ // Total number of non-terminated pods targeted by this deployment that have the desired template spec.
+ optional int32 updatedReplicas = 3;
+
+ // Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.
+ optional int32 availableReplicas = 4;
+
+ // Total number of unavailable pods targeted by this deployment.
+ optional int32 unavailableReplicas = 5;
+}
+
+// DeploymentStrategy describes how to replace existing pods with new ones.
+message DeploymentStrategy {
+ // Type of deployment. Can be "Recreate" or "RollingUpdate". Default is RollingUpdate.
+ optional string type = 1;
+
+ // Rolling update config params. Present only if DeploymentStrategyType =
+ // RollingUpdate.
+ // ---
+ // TODO: Update this to follow our convention for oneOf, whatever we decide it
+ // to be.
+ optional RollingUpdateDeployment rollingUpdate = 2;
+}
+
+// ExportOptions is the query options to the standard REST get call.
+message ExportOptions {
+ // Should this value be exported. Export strips fields that a user can not specify.
+ optional bool export = 1;
+
+ // Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
+ optional bool exact = 2;
+}
+
+// FSGroupStrategyOptions defines the strategy type and options used to create the strategy.
+message FSGroupStrategyOptions {
+ // Rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
+ optional string rule = 1;
+
+ // 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.
+ repeated IDRange ranges = 2;
+}
+
+// HTTPIngressPath associates a path regex with a backend. Incoming urls matching
+// the path are forwarded to the backend.
+message HTTPIngressPath {
+ // Path is a extended POSIX regex as defined by IEEE Std 1003.1,
+ // (i.e this follows the egrep/unix syntax, not the perl syntax)
+ // 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 '/'. If unspecified, the path defaults to a catch all sending
+ // traffic to the backend.
+ optional string path = 1;
+
+ // Backend defines the referenced service endpoint to which the traffic
+ // will be forwarded to.
+ optional IngressBackend backend = 2;
+}
+
+// HTTPIngressRuleValue is a list of http selectors pointing to backends.
+// In the example: http://<host>/<path>?<searchpart> -> 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 '#'.
+message HTTPIngressRuleValue {
+ // A collection of paths that map requests to backends.
+ repeated HTTPIngressPath paths = 1;
+}
+
+// configuration of a horizontal pod autoscaler.
+message HorizontalPodAutoscaler {
+ // Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ optional HorizontalPodAutoscalerSpec spec = 2;
+
+ // current information about the autoscaler.
+ optional HorizontalPodAutoscalerStatus status = 3;
+}
+
+// list of horizontal pod autoscaler objects.
+message HorizontalPodAutoscalerList {
+ // Standard list metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // list of horizontal pod autoscaler objects.
+ repeated HorizontalPodAutoscaler items = 2;
+}
+
+// specification of a horizontal pod autoscaler.
+message HorizontalPodAutoscalerSpec {
+ // reference to Scale subresource; horizontal pod autoscaler will learn the current resource consumption from its status,
+ // and will set the desired number of pods by modifying its spec.
+ optional SubresourceReference scaleRef = 1;
+
+ // lower limit for the number of pods that can be set by the autoscaler, default 1.
+ optional int32 minReplicas = 2;
+
+ // upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
+ optional int32 maxReplicas = 3;
+
+ // target average CPU utilization (represented as a percentage of requested CPU) over all the pods;
+ // if not specified it defaults to the target CPU utilization at 80% of the requested resources.
+ optional CPUTargetUtilization cpuUtilization = 4;
+}
+
+// current status of a horizontal pod autoscaler
+message HorizontalPodAutoscalerStatus {
+ // most recent generation observed by this autoscaler.
+ optional int64 observedGeneration = 1;
+
+ // last time the HorizontalPodAutoscaler scaled the number of pods;
+ // used by the autoscaler to control how often the number of pods is changed.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastScaleTime = 2;
+
+ // current number of replicas of pods managed by this autoscaler.
+ optional int32 currentReplicas = 3;
+
+ // desired number of replicas of pods managed by this autoscaler.
+ optional int32 desiredReplicas = 4;
+
+ // 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.
+ optional int32 currentCPUUtilizationPercentage = 5;
+}
+
+// Host Port Range 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.
+message HostPortRange {
+ // min is the start of the range, inclusive.
+ optional int32 min = 1;
+
+ // max is the end of the range, inclusive.
+ optional int32 max = 2;
+}
+
+// ID Range provides a min/max of an allowed range of IDs.
+message IDRange {
+ // Min is the start of the range, inclusive.
+ optional int64 min = 1;
+
+ // Max is the end of the range, inclusive.
+ optional int64 max = 2;
+}
+
+// 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.
+message Ingress {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec is the desired state of the Ingress.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional IngressSpec spec = 2;
+
+ // Status is the current state of the Ingress.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional IngressStatus status = 3;
+}
+
+// IngressBackend describes all endpoints for a given service and port.
+message IngressBackend {
+ // Specifies the name of the referenced service.
+ optional string serviceName = 1;
+
+ // Specifies the port of the referenced service.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString servicePort = 2;
+}
+
+// IngressList is a collection of Ingress.
+message IngressList {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Ingress.
+ repeated Ingress items = 2;
+}
+
+// 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.
+message IngressRule {
+ // 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 the RFC:
+ // 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.
+ optional string host = 1;
+
+ // IngressRuleValue represents a rule to route requests for this IngressRule.
+ // If unspecified, the rule defaults to a http catch-all. Whether that sends
+ // just traffic matching the host to the default backend or all traffic to the
+ // default backend, is left to the controller fulfilling the Ingress. Http is
+ // currently the only supported IngressRuleValue.
+ optional IngressRuleValue ingressRuleValue = 2;
+}
+
+// IngressRuleValue represents a rule to apply against incoming requests. If the
+// rule is satisfied, the request is routed to the specified backend. Currently
+// mixing different types of rules in a single Ingress is disallowed, so exactly
+// one of the following must be set.
+message IngressRuleValue {
+ optional HTTPIngressRuleValue http = 1;
+}
+
+// IngressSpec describes the Ingress the user wishes to exist.
+message IngressSpec {
+ // A default backend capable of servicing requests that don't match any
+ // rule. At least one of 'backend' or 'rules' must be specified. This field
+ // is optional to allow the loadbalancer controller or defaulting logic to
+ // specify a global default.
+ optional IngressBackend backend = 1;
+
+ // 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.
+ repeated IngressTLS tls = 2;
+
+ // A list of host rules used to configure the Ingress. If unspecified, or
+ // no rule matches, all traffic is sent to the default backend.
+ repeated IngressRule rules = 3;
+}
+
+// IngressStatus describe the current state of the Ingress.
+message IngressStatus {
+ // LoadBalancer contains the current status of the load-balancer.
+ optional k8s.io.kubernetes.pkg.api.v1.LoadBalancerStatus loadBalancer = 1;
+}
+
+// IngressTLS describes the transport layer security associated with an Ingress.
+message IngressTLS {
+ // 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.
+ repeated string hosts = 1;
+
+ // SecretName is the name of the secret used to terminate SSL traffic on 443.
+ // Field is left optional to allow SSL 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.
+ optional string secretName = 2;
+}
+
+// Job represents the configuration of a single job.
+message Job {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec is a structure defining the expected behavior of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobSpec spec = 2;
+
+ // Status is a structure describing current status of a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional JobStatus status = 3;
+}
+
+// JobCondition describes current state of a job.
+message JobCondition {
+ // Type of job condition, Complete or Failed.
+ optional string type = 1;
+
+ // Status of the condition, one of True, False, Unknown.
+ optional string status = 2;
+
+ // Last time the condition was checked.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastProbeTime = 3;
+
+ // Last time the condition transit from one status to another.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time lastTransitionTime = 4;
+
+ // (brief) reason for the condition's last transition.
+ optional string reason = 5;
+
+ // Human readable message indicating details about last transition.
+ optional string message = 6;
+}
+
+// JobList is a collection of jobs.
+message JobList {
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of Job.
+ repeated Job items = 2;
+}
+
+// JobSpec describes how the job execution will look like.
+message JobSpec {
+ // Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 parallelism = 1;
+
+ // Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional int32 completions = 2;
+
+ // Optional duration in seconds relative to the startTime that the job may be active
+ // before the system tries to terminate it; value must be positive integer
+ optional int64 activeDeadlineSeconds = 3;
+
+ // Selector is a label query over pods that should match the pod count.
+ // Normally, the system sets this field for you.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional LabelSelector selector = 4;
+
+ // AutoSelector controls generation of pod labels and pod selectors.
+ // It was not present in the original extensions/v1beta1 Job definition, but exists
+ // to allow conversion from batch/v1 Jobs, where it corresponds to, but has the opposite
+ // meaning as, ManualSelector.
+ // More info: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ optional bool autoSelector = 5;
+
+ // Template is the object that describes the pod that will be created when
+ // executing a job.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 6;
+}
+
+// JobStatus represents the current state of a Job.
+message JobStatus {
+ // Conditions represent the latest available observations of an object's current state.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ repeated JobCondition conditions = 1;
+
+ // StartTime represents time when the job was acknowledged by the Job Manager.
+ // It is not guaranteed to be set in happens-before order across separate operations.
+ // It is represented in RFC3339 form and is in UTC.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time startTime = 2;
+
+ // CompletionTime 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.
+ optional k8s.io.kubernetes.pkg.api.unversioned.Time completionTime = 3;
+
+ // Active is the number of actively running pods.
+ optional int32 active = 4;
+
+ // Succeeded is the number of pods which reached Phase Succeeded.
+ optional int32 succeeded = 5;
+
+ // Failed is the number of pods which reached Phase Failed.
+ optional int32 failed = 6;
+}
+
+// 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.
+message LabelSelector {
+ // 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.
+ map<string, string> matchLabels = 1;
+
+ // matchExpressions is a list of label selector requirements. The requirements are ANDed.
+ repeated LabelSelectorRequirement matchExpressions = 2;
+}
+
+// A label selector requirement is a selector that contains values, a key, and an operator that
+// relates the key and values.
+message LabelSelectorRequirement {
+ // key is the label key that the selector applies to.
+ optional string key = 1;
+
+ // operator represents a key's relationship to a set of values.
+ // Valid operators ard In, NotIn, Exists and DoesNotExist.
+ optional string operator = 2;
+
+ // 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.
+ repeated string values = 3;
+}
+
+// ListOptions is the query options to a standard REST list call.
+message ListOptions {
+ // A selector to restrict the list of returned objects by their labels.
+ // Defaults to everything.
+ optional string labelSelector = 1;
+
+ // A selector to restrict the list of returned objects by their fields.
+ // Defaults to everything.
+ optional string fieldSelector = 2;
+
+ // Watch for changes to the described resources and return them as a stream of
+ // add, update, and remove notifications. Specify resourceVersion.
+ optional bool watch = 3;
+
+ // When specified with a watch call, shows changes that occur after that particular version of a resource.
+ // Defaults to changes from the beginning of history.
+ optional string resourceVersion = 4;
+
+ // Timeout for the list/watch call.
+ optional int64 timeoutSeconds = 5;
+}
+
+message NetworkPolicy {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior for this NetworkPolicy.
+ optional NetworkPolicySpec spec = 2;
+}
+
+// This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from.
+message NetworkPolicyIngressRule {
+ // 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 not provided, this rule matches all ports (traffic not restricted by port).
+ // If this field is empty, this rule matches no ports (no traffic matches).
+ // 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.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ repeated NetworkPolicyPort ports = 1;
+
+ // 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 not provided, this rule matches all sources (traffic not restricted by source).
+ // If this field is empty, this rule matches no sources (no traffic matches).
+ // If this field is present and contains at least on item, this rule allows traffic only if the
+ // traffic matches at least one item in the from list.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ repeated NetworkPolicyPeer from = 2;
+}
+
+// Network Policy List is a list of NetworkPolicy objects.
+message NetworkPolicyList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of schema objects.
+ repeated NetworkPolicy items = 2;
+}
+
+message NetworkPolicyPeer {
+ // This is a label selector which selects Pods in this namespace.
+ // This field follows standard label selector semantics.
+ // If not provided, this selector selects no pods.
+ // If present but empty, this selector selects all pods in this namespace.
+ optional LabelSelector podSelector = 1;
+
+ // Selects Namespaces using cluster scoped-labels. This
+ // matches all pods in all namespaces selected by this label selector.
+ // This field follows standard label selector semantics.
+ // If omitted, this selector selects no namespaces.
+ // If present but empty, this selector selects all namespaces.
+ optional LabelSelector namespaceSelector = 2;
+}
+
+message NetworkPolicyPort {
+ // Optional. The protocol (TCP or UDP) which traffic must match.
+ // If not specified, this field defaults to TCP.
+ optional string protocol = 1;
+
+ // If specified, 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.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString port = 2;
+}
+
+message NetworkPolicySpec {
+ // 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.
+ optional LabelSelector podSelector = 1;
+
+ // List of ingress rules to be applied to the selected pods.
+ // Traffic is allowed to a pod if namespace.networkPolicy.ingress.isolation is undefined and cluster policy allows it,
+ // 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 affect ingress isolation.
+ // If this field is present and contains at least one rule, this policy allows any traffic
+ // which matches at least one of the ingress rules in this list.
+ repeated NetworkPolicyIngressRule ingress = 2;
+}
+
+// Pod Security Policy governs the ability to make requests that affect the Security Context
+// that will be applied to a pod and container.
+message PodSecurityPolicy {
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // spec defines the policy enforced.
+ optional PodSecurityPolicySpec spec = 2;
+}
+
+// Pod Security Policy List is a list of PodSecurityPolicy objects.
+message PodSecurityPolicyList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of schema objects.
+ repeated PodSecurityPolicy items = 2;
+}
+
+// Pod Security Policy Spec defines the policy enforced.
+message PodSecurityPolicySpec {
+ // privileged determines if a pod can request to be run as privileged.
+ optional bool privileged = 1;
+
+ // 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 capabiility in both
+ // DefaultAddCapabilities and RequiredDropCapabilities.
+ repeated string defaultAddCapabilities = 2;
+
+ // RequiredDropCapabilities are the capabilities that will be dropped from the container. These
+ // are required to be dropped and cannot be added.
+ repeated string requiredDropCapabilities = 3;
+
+ // 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.
+ repeated string allowedCapabilities = 4;
+
+ // volumes is a white list of allowed volume plugins. Empty indicates that all plugins
+ // may be used.
+ repeated string volumes = 5;
+
+ // hostNetwork determines if the policy allows the use of HostNetwork in the pod spec.
+ optional bool hostNetwork = 6;
+
+ // hostPorts determines which host port ranges are allowed to be exposed.
+ repeated HostPortRange hostPorts = 7;
+
+ // hostPID determines if the policy allows the use of HostPID in the pod spec.
+ optional bool hostPID = 8;
+
+ // hostIPC determines if the policy allows the use of HostIPC in the pod spec.
+ optional bool hostIPC = 9;
+
+ // seLinux is the strategy that will dictate the allowable labels that may be set.
+ optional SELinuxStrategyOptions seLinux = 10;
+
+ // runAsUser is the strategy that will dictate the allowable RunAsUser values that may be set.
+ optional RunAsUserStrategyOptions runAsUser = 11;
+
+ // SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext.
+ optional SupplementalGroupsStrategyOptions supplementalGroups = 12;
+
+ // FSGroup is the strategy that will dictate what fs group is used by the SecurityContext.
+ optional FSGroupStrategyOptions fsGroup = 13;
+
+ // 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.
+ optional bool readOnlyRootFilesystem = 14;
+}
+
+// ReplicaSet represents the configuration of a ReplicaSet.
+message ReplicaSet {
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Spec defines the specification of the desired behavior of the ReplicaSet.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ReplicaSetSpec spec = 2;
+
+ // 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ optional ReplicaSetStatus status = 3;
+}
+
+// ReplicaSetList is a collection of ReplicaSets.
+message ReplicaSetList {
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // List of ReplicaSets.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md
+ repeated ReplicaSet items = 2;
+}
+
+// ReplicaSetSpec is the specification of a ReplicaSet.
+message ReplicaSetSpec {
+ // Replicas is the number of desired replicas.
+ // This is a pointer to distinguish between explicit zero and unspecified.
+ // Defaults to 1.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ optional int32 replicas = 1;
+
+ // Selector is a label query over pods that should match the replica count.
+ // If the 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 replica set.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional LabelSelector selector = 2;
+
+ // Template is the object that describes the pod that will be created if
+ // insufficient replicas are detected.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ optional k8s.io.kubernetes.pkg.api.v1.PodTemplateSpec template = 3;
+}
+
+// ReplicaSetStatus represents the current status of a ReplicaSet.
+message ReplicaSetStatus {
+ // Replicas is the most recently oberved number of replicas.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ optional int32 replicas = 1;
+
+ // The number of pods that have labels matching the labels of the pod template of the replicaset.
+ optional int32 fullyLabeledReplicas = 2;
+
+ // ObservedGeneration reflects the generation of the most recently observed ReplicaSet.
+ optional int64 observedGeneration = 3;
+}
+
+// Dummy definition
+message ReplicationControllerDummy {
+}
+
+message RollbackConfig {
+ // The revision to rollback to. If set to 0, rollbck to the last revision.
+ optional int64 revision = 1;
+}
+
+// Spec to control the desired behavior of rolling update.
+message RollingUpdateDeployment {
+ // 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 if MaxSurge is 0.
+ // By default, a fixed value of 1 is used.
+ // Example: when this is set to 30%, the old RC can be scaled down to 70% of desired pods
+ // immediately when the rolling update starts. Once new pods are ready, old RC
+ // can be scaled down further, followed by scaling up the new RC, ensuring
+ // that the total number of pods available at all times during the update is at
+ // least 70% of desired pods.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString maxUnavailable = 1;
+
+ // 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.
+ // By default, a value of 1 is used.
+ // Example: when this is set to 30%, the new RC 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 RC can be scaled up further, ensuring that total number of pods running
+ // at any time during the update is atmost 130% of desired pods.
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString maxSurge = 2;
+}
+
+// Run A sUser Strategy Options defines the strategy type and any options used to create the strategy.
+message RunAsUserStrategyOptions {
+ // Rule is the strategy that will dictate the allowable RunAsUser values that may be set.
+ optional string rule = 1;
+
+ // Ranges are the allowed ranges of uids that may be used.
+ repeated IDRange ranges = 2;
+}
+
+// SELinux Strategy Options defines the strategy type and any options used to create the strategy.
+message SELinuxStrategyOptions {
+ // type is the strategy that will dictate the allowable labels that may be set.
+ optional string rule = 1;
+
+ // seLinuxOptions required to run as; required for MustRunAs
+ // More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md#security-context
+ optional k8s.io.kubernetes.pkg.api.v1.SELinuxOptions seLinuxOptions = 2;
+}
+
+// represents a scaling request for a resource.
+message Scale {
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ optional ScaleSpec spec = 2;
+
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ optional ScaleStatus status = 3;
+}
+
+// describes the attributes of a scale subresource
+message ScaleSpec {
+ // desired number of instances for the scaled object.
+ optional int32 replicas = 1;
+}
+
+// represents the current status of a scale subresource.
+message ScaleStatus {
+ // actual number of observed instances of the scaled object.
+ optional int32 replicas = 1;
+
+ // label query over pods that should match the replicas count. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ map<string, string> selector = 2;
+
+ // label selector for pods that should match the replicas count. This is a serializated
+ // version of both map-based and more expressive set-based selectors. This is done to
+ // avoid introspection in the clients. The string will be in the same format as the
+ // query-param syntax. If the target type only supports map-based selectors, both this
+ // field and map-based selector field are populated.
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ optional string targetSelector = 3;
+}
+
+// SubresourceReference contains enough information to let you inspect or modify the referred subresource.
+message SubresourceReference {
+ // Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ optional string kind = 1;
+
+ // Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ optional string name = 2;
+
+ // API version of the referent
+ optional string apiVersion = 3;
+
+ // Subresource name of the referent
+ optional string subresource = 4;
+}
+
+// SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy.
+message SupplementalGroupsStrategyOptions {
+ // Rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
+ optional string rule = 1;
+
+ // 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.
+ repeated IDRange ranges = 2;
+}
+
+// A ThirdPartyResource is a generic representation of a resource, it is used by add-ons and plugins to add new resource
+// types to the API. It consists of one or more Versions of the api.
+message ThirdPartyResource {
+ // Standard object metadata
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Description is the description of this object.
+ optional string description = 2;
+
+ // Versions are versions for this third party object
+ repeated APIVersion versions = 3;
+}
+
+// An internal object, used for versioned storage in etcd. Not exposed to the end user.
+message ThirdPartyResourceData {
+ // Standard object metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Data is the raw JSON data for this data.
+ optional bytes data = 2;
+}
+
+// ThirdPartyResrouceDataList is a list of ThirdPartyResourceData.
+message ThirdPartyResourceDataList {
+ // Standard list metadata
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of ThirdpartyResourceData.
+ repeated ThirdPartyResourceData items = 2;
+}
+
+// ThirdPartyResourceList is a list of ThirdPartyResources.
+message ThirdPartyResourceList {
+ // Standard list metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is the list of ThirdPartyResources.
+ repeated ThirdPartyResource items = 2;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..e8bbf28b100fd7da42022d2a26e4677662395b62
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/register.go
@@ -0,0 +1,69 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 v1beta1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "extensions"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1beta1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Deployment{},
+ &DeploymentList{},
+ &DeploymentRollback{},
+ &HorizontalPodAutoscaler{},
+ &HorizontalPodAutoscalerList{},
+ &Job{},
+ &JobList{},
+ &ReplicationControllerDummy{},
+ &Scale{},
+ &ThirdPartyResource{},
+ &ThirdPartyResourceList{},
+ &DaemonSetList{},
+ &DaemonSet{},
+ &ThirdPartyResourceData{},
+ &ThirdPartyResourceDataList{},
+ &Ingress{},
+ &IngressList{},
+ &ListOptions{},
+ &v1.DeleteOptions{},
+ &ReplicaSet{},
+ &ReplicaSetList{},
+ &PodSecurityPolicy{},
+ &PodSecurityPolicyList{},
+ &NetworkPolicy{},
+ &NetworkPolicyList{},
+ )
+ // Add the watch version that applies
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go
index ffdeebcf59d764041daeb7d516f7426c4306d244..cbe82eff31609a4c6e0aeb23e23c0e99ec0b4df2 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -29,10 +29,9 @@ import (
pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
pkg3_types "k8s.io/kubernetes/pkg/types"
- pkg6_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
"reflect"
"runtime"
- pkg5_inf "speter.net/go/exp/math/dec/inf"
time "time"
)
@@ -70,10 +69,9 @@ func init() {
var v1 pkg1_unversioned.TypeMeta
var v2 pkg2_v1.ObjectMeta
var v3 pkg3_types.UID
- var v4 pkg6_intstr.IntOrString
- var v5 pkg5_inf.Dec
- var v6 time.Time
- _, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6
+ var v4 pkg5_intstr.IntOrString
+ var v5 time.Time
+ _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
}
}
@@ -4587,14 +4585,13 @@ func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [2]bool
+ var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Name != ""
- yyq2[1] = x.APIGroup != ""
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(2)
+ r.EncodeArrayStart(1)
} else {
yynn2 = 0
for _, b := range yyq2 {
@@ -4630,31 +4627,6 @@ func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[1] {
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym8 := z.EncBinary()
- _ = yym8
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
- }
- }
- }
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
@@ -4722,12 +4694,6 @@ func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- case "apiGroup":
- if r.TryDecodeAsNil() {
- x.APIGroup = ""
- } else {
- x.APIGroup = string(r.DecodeString())
- }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -4739,16 +4705,16 @@ func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj6 int
- var yyb6 bool
- var yyhl6 bool = l >= 0
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ var yyj5 int
+ var yyb5 bool
+ var yyhl5 bool = l >= 0
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb6 {
+ if yyb5 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -4758,34 +4724,18 @@ func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
- } else {
- yyb6 = r.CheckBreak()
- }
- if yyb6 {
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
- return
- }
- z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- if r.TryDecodeAsNil() {
- x.APIGroup = ""
- } else {
- x.APIGroup = string(r.DecodeString())
- }
for {
- yyj6++
- if yyhl6 {
- yyb6 = yyj6 > l
+ yyj5++
+ if yyhl5 {
+ yyb5 = yyj5 > l
} else {
- yyb6 = r.CheckBreak()
+ yyb5 = r.CheckBreak()
}
- if yyb6 {
+ if yyb5 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj6-1, "")
+ z.DecStructFieldNotFound(yyj5-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -6971,7 +6921,7 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Dec
}
} else {
if x.MaxUnavailable == nil {
- x.MaxUnavailable = new(pkg6_intstr.IntOrString)
+ x.MaxUnavailable = new(pkg5_intstr.IntOrString)
}
yym5 := z.DecBinary()
_ = yym5
@@ -6990,7 +6940,7 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Dec
}
} else {
if x.MaxSurge == nil {
- x.MaxSurge = new(pkg6_intstr.IntOrString)
+ x.MaxSurge = new(pkg5_intstr.IntOrString)
}
yym7 := z.DecBinary()
_ = yym7
@@ -7033,7 +6983,7 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.D
}
} else {
if x.MaxUnavailable == nil {
- x.MaxUnavailable = new(pkg6_intstr.IntOrString)
+ x.MaxUnavailable = new(pkg5_intstr.IntOrString)
}
yym10 := z.DecBinary()
_ = yym10
@@ -7062,7 +7012,7 @@ func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.D
}
} else {
if x.MaxSurge == nil {
- x.MaxSurge = new(pkg6_intstr.IntOrString)
+ x.MaxSurge = new(pkg5_intstr.IntOrString)
}
yym12 := z.DecBinary()
_ = yym12
@@ -13842,7 +13792,7 @@ func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
case "servicePort":
if r.TryDecodeAsNil() {
- x.ServicePort = pkg6_intstr.IntOrString{}
+ x.ServicePort = pkg5_intstr.IntOrString{}
} else {
yyv5 := &x.ServicePort
yym6 := z.DecBinary()
@@ -13897,7 +13847,7 @@ func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ServicePort = pkg6_intstr.IntOrString{}
+ x.ServicePort = pkg5_intstr.IntOrString{}
} else {
yyv9 := &x.ServicePort
yym10 := z.DecBinary()
@@ -16813,23 +16763,24 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [9]bool
+ var yyq2 [14]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Privileged != false
- yyq2[1] = len(x.Capabilities) != 0
- yyq2[2] = len(x.Volumes) != 0
- yyq2[3] = x.HostNetwork != false
- yyq2[4] = len(x.HostPorts) != 0
- yyq2[5] = x.HostPID != false
- yyq2[6] = x.HostIPC != false
- yyq2[7] = true
- yyq2[8] = true
+ yyq2[1] = len(x.DefaultAddCapabilities) != 0
+ yyq2[2] = len(x.RequiredDropCapabilities) != 0
+ yyq2[3] = len(x.AllowedCapabilities) != 0
+ yyq2[4] = len(x.Volumes) != 0
+ yyq2[5] = x.HostNetwork != false
+ yyq2[6] = len(x.HostPorts) != 0
+ yyq2[7] = x.HostPID != false
+ yyq2[8] = x.HostIPC != false
+ yyq2[13] = x.ReadOnlyRootFilesystem != false
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(9)
+ r.EncodeArrayStart(14)
} else {
- yynn2 = 0
+ yynn2 = 4
for _, b := range yyq2 {
if b {
yynn2++
@@ -16866,14 +16817,14 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
- if x.Capabilities == nil {
+ if x.DefaultAddCapabilities == nil {
r.EncodeNil()
} else {
yym7 := z.EncBinary()
_ = yym7
if false {
} else {
- h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.Capabilities), e)
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
}
}
} else {
@@ -16882,16 +16833,16 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("capabilities"))
+ r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Capabilities == nil {
+ if x.DefaultAddCapabilities == nil {
r.EncodeNil()
} else {
yym8 := z.EncBinary()
_ = yym8
if false {
} else {
- h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.Capabilities), e)
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
}
}
}
@@ -16899,14 +16850,14 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[2] {
- if x.Volumes == nil {
+ if x.RequiredDropCapabilities == nil {
r.EncodeNil()
} else {
yym10 := z.EncBinary()
_ = yym10
if false {
} else {
- h.encSliceFSType(([]FSType)(x.Volumes), e)
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
}
}
} else {
@@ -16915,16 +16866,16 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("volumes"))
+ r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Volumes == nil {
+ if x.RequiredDropCapabilities == nil {
r.EncodeNil()
} else {
yym11 := z.EncBinary()
_ = yym11
if false {
} else {
- h.encSliceFSType(([]FSType)(x.Volumes), e)
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
}
}
}
@@ -16932,39 +16883,47 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[3] {
- yym13 := z.EncBinary()
- _ = yym13
- if false {
+ if x.AllowedCapabilities == nil {
+ r.EncodeNil()
} else {
- r.EncodeBool(bool(x.HostNetwork))
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
+ }
}
} else {
- r.EncodeBool(false)
+ r.EncodeNil()
}
} else {
if yyq2[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
+ r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym14 := z.EncBinary()
- _ = yym14
- if false {
+ if x.AllowedCapabilities == nil {
+ r.EncodeNil()
} else {
- r.EncodeBool(bool(x.HostNetwork))
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[4] {
- if x.HostPorts == nil {
+ if x.Volumes == nil {
r.EncodeNil()
} else {
yym16 := z.EncBinary()
_ = yym16
if false {
} else {
- h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
+ h.encSliceFSType(([]FSType)(x.Volumes), e)
}
}
} else {
@@ -16973,16 +16932,16 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
+ r.EncodeString(codecSelferC_UTF81234, string("volumes"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.HostPorts == nil {
+ if x.Volumes == nil {
r.EncodeNil()
} else {
yym17 := z.EncBinary()
_ = yym17
if false {
} else {
- h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
+ h.encSliceFSType(([]FSType)(x.Volumes), e)
}
}
}
@@ -16994,7 +16953,7 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
_ = yym19
if false {
} else {
- r.EncodeBool(bool(x.HostPID))
+ r.EncodeBool(bool(x.HostNetwork))
}
} else {
r.EncodeBool(false)
@@ -17002,73 +16961,166 @@ func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym20 := z.EncBinary()
_ = yym20
if false {
} else {
- r.EncodeBool(bool(x.HostPID))
+ r.EncodeBool(bool(x.HostNetwork))
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[6] {
- yym22 := z.EncBinary()
- _ = yym22
- if false {
+ if x.HostPorts == nil {
+ r.EncodeNil()
} else {
- r.EncodeBool(bool(x.HostIPC))
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
+ }
}
} else {
- r.EncodeBool(false)
+ r.EncodeNil()
}
} else {
if yyq2[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym23 := z.EncBinary()
- _ = yym23
- if false {
+ if x.HostPorts == nil {
+ r.EncodeNil()
} else {
- r.EncodeBool(bool(x.HostIPC))
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
+ }
}
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[7] {
- yy25 := &x.SELinux
- yy25.CodecEncodeSelf(e)
+ yym25 := z.EncBinary()
+ _ = yym25
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostPID))
+ }
} else {
- r.EncodeNil()
+ r.EncodeBool(false)
}
} else {
if yyq2[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy27 := &x.SELinux
- yy27.CodecEncodeSelf(e)
+ yym26 := z.EncBinary()
+ _ = yym26
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostPID))
+ }
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[8] {
- yy30 := &x.RunAsUser
- yy30.CodecEncodeSelf(e)
+ yym28 := z.EncBinary()
+ _ = yym28
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostIPC))
+ }
} else {
- r.EncodeNil()
+ r.EncodeBool(false)
}
} else {
if yyq2[8] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
+ r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym29 := z.EncBinary()
+ _ = yym29
+ if false {
+ } else {
+ r.EncodeBool(bool(x.HostIPC))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy31 := &x.SELinux
+ yy31.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy33 := &x.SELinux
+ yy33.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy36 := &x.RunAsUser
+ yy36.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy38 := &x.RunAsUser
+ yy38.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy41 := &x.SupplementalGroups
+ yy41.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy43 := &x.SupplementalGroups
+ yy43.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy46 := &x.FSGroup
+ yy46.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy48 := &x.FSGroup
+ yy48.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[13] {
+ yym51 := z.EncBinary()
+ _ = yym51
+ if false {
+ } else {
+ r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
+ } else {
+ if yyq2[13] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy32 := &x.RunAsUser
- yy32.CodecEncodeSelf(e)
+ yym52 := z.EncBinary()
+ _ = yym52
+ if false {
+ } else {
+ r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
+ }
}
}
if yyr2 || yy2arr2 {
@@ -17138,11 +17190,11 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decod
} else {
x.Privileged = bool(r.DecodeBool())
}
- case "capabilities":
+ case "defaultAddCapabilities":
if r.TryDecodeAsNil() {
- x.Capabilities = nil
+ x.DefaultAddCapabilities = nil
} else {
- yyv5 := &x.Capabilities
+ yyv5 := &x.DefaultAddCapabilities
yym6 := z.DecBinary()
_ = yym6
if false {
@@ -17150,16 +17202,40 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decod
h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv5), d)
}
}
- case "volumes":
+ case "requiredDropCapabilities":
if r.TryDecodeAsNil() {
- x.Volumes = nil
+ x.RequiredDropCapabilities = nil
} else {
- yyv7 := &x.Volumes
+ yyv7 := &x.RequiredDropCapabilities
yym8 := z.DecBinary()
_ = yym8
if false {
} else {
- h.decSliceFSType((*[]FSType)(yyv7), d)
+ h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv7), d)
+ }
+ }
+ case "allowedCapabilities":
+ if r.TryDecodeAsNil() {
+ x.AllowedCapabilities = nil
+ } else {
+ yyv9 := &x.AllowedCapabilities
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv9), d)
+ }
+ }
+ case "volumes":
+ if r.TryDecodeAsNil() {
+ x.Volumes = nil
+ } else {
+ yyv11 := &x.Volumes
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceFSType((*[]FSType)(yyv11), d)
}
}
case "hostNetwork":
@@ -17172,12 +17248,12 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.HostPorts = nil
} else {
- yyv10 := &x.HostPorts
- yym11 := z.DecBinary()
- _ = yym11
+ yyv14 := &x.HostPorts
+ yym15 := z.DecBinary()
+ _ = yym15
if false {
} else {
- h.decSliceHostPortRange((*[]HostPortRange)(yyv10), d)
+ h.decSliceHostPortRange((*[]HostPortRange)(yyv14), d)
}
}
case "hostPID":
@@ -17196,15 +17272,35 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.SELinux = SELinuxStrategyOptions{}
} else {
- yyv14 := &x.SELinux
- yyv14.CodecDecodeSelf(d)
+ yyv18 := &x.SELinux
+ yyv18.CodecDecodeSelf(d)
}
case "runAsUser":
if r.TryDecodeAsNil() {
x.RunAsUser = RunAsUserStrategyOptions{}
} else {
- yyv15 := &x.RunAsUser
- yyv15.CodecDecodeSelf(d)
+ yyv19 := &x.RunAsUser
+ yyv19.CodecDecodeSelf(d)
+ }
+ case "supplementalGroups":
+ if r.TryDecodeAsNil() {
+ x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
+ } else {
+ yyv20 := &x.SupplementalGroups
+ yyv20.CodecDecodeSelf(d)
+ }
+ case "fsGroup":
+ if r.TryDecodeAsNil() {
+ x.FSGroup = FSGroupStrategyOptions{}
+ } else {
+ yyv21 := &x.FSGroup
+ yyv21.CodecDecodeSelf(d)
+ }
+ case "readOnlyRootFilesystem":
+ if r.TryDecodeAsNil() {
+ x.ReadOnlyRootFilesystem = false
+ } else {
+ x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
}
default:
z.DecStructFieldNotFound(-1, yys3)
@@ -17217,16 +17313,16 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj16 int
- var yyb16 bool
- var yyhl16 bool = l >= 0
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ var yyj23 int
+ var yyb23 bool
+ var yyhl23 bool = l >= 0
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -17236,144 +17332,188 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.Privileged = bool(r.DecodeBool())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Capabilities = nil
+ x.DefaultAddCapabilities = nil
} else {
- yyv18 := &x.Capabilities
- yym19 := z.DecBinary()
- _ = yym19
+ yyv25 := &x.DefaultAddCapabilities
+ yym26 := z.DecBinary()
+ _ = yym26
if false {
} else {
- h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv18), d)
+ h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv25), d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Volumes = nil
+ x.RequiredDropCapabilities = nil
} else {
- yyv20 := &x.Volumes
- yym21 := z.DecBinary()
- _ = yym21
+ yyv27 := &x.RequiredDropCapabilities
+ yym28 := z.DecBinary()
+ _ = yym28
if false {
} else {
- h.decSliceFSType((*[]FSType)(yyv20), d)
+ h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv27), d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostNetwork = false
+ x.AllowedCapabilities = nil
} else {
- x.HostNetwork = bool(r.DecodeBool())
+ yyv29 := &x.AllowedCapabilities
+ yym30 := z.DecBinary()
+ _ = yym30
+ if false {
+ } else {
+ h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv29), d)
+ }
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostPorts = nil
+ x.Volumes = nil
} else {
- yyv23 := &x.HostPorts
- yym24 := z.DecBinary()
- _ = yym24
+ yyv31 := &x.Volumes
+ yym32 := z.DecBinary()
+ _ = yym32
if false {
} else {
- h.decSliceHostPortRange((*[]HostPortRange)(yyv23), d)
+ h.decSliceFSType((*[]FSType)(yyv31), d)
}
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostPID = false
+ x.HostNetwork = false
} else {
- x.HostPID = bool(r.DecodeBool())
+ x.HostNetwork = bool(r.DecodeBool())
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.HostIPC = false
+ x.HostPorts = nil
} else {
- x.HostIPC = bool(r.DecodeBool())
+ yyv34 := &x.HostPorts
+ yym35 := z.DecBinary()
+ _ = yym35
+ if false {
+ } else {
+ h.decSliceHostPortRange((*[]HostPortRange)(yyv34), d)
+ }
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.SELinux = SELinuxStrategyOptions{}
+ x.HostPID = false
+ } else {
+ x.HostPID = bool(r.DecodeBool())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.HostIPC = false
+ } else {
+ x.HostIPC = bool(r.DecodeBool())
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SELinux = SELinuxStrategyOptions{}
} else {
- yyv27 := &x.SELinux
- yyv27.CodecDecodeSelf(d)
+ yyv38 := &x.SELinux
+ yyv38.CodecDecodeSelf(d)
}
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -17381,21 +17521,71 @@ func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if r.TryDecodeAsNil() {
x.RunAsUser = RunAsUserStrategyOptions{}
} else {
- yyv28 := &x.RunAsUser
- yyv28.CodecDecodeSelf(d)
+ yyv39 := &x.RunAsUser
+ yyv39.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
+ } else {
+ yyv40 := &x.SupplementalGroups
+ yyv40.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.FSGroup = FSGroupStrategyOptions{}
+ } else {
+ yyv41 := &x.FSGroup
+ yyv41.CodecDecodeSelf(d)
+ }
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
+ } else {
+ yyb23 = r.CheckBreak()
+ }
+ if yyb23 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ReadOnlyRootFilesystem = false
+ } else {
+ x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
}
for {
- yyj16++
- if yyhl16 {
- yyb16 = yyj16 > l
+ yyj23++
+ if yyhl23 {
+ yyb23 = yyj23 > l
} else {
- yyb16 = r.CheckBreak()
+ yyb23 = r.CheckBreak()
}
- if yyb16 {
+ if yyb23 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj16-1, "")
+ z.DecStructFieldNotFound(yyj23-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -18312,7 +18502,7 @@ func (x *RunAsUserStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
+func (x *FSGroupStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18326,17 +18516,16 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
yysep2 := !z.EncBinary()
yy2arr2 := z.EncBasicHandle().StructToArray
- var yyq2 [4]bool
+ var yyq2 [2]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
- yyq2[0] = true
- yyq2[2] = x.Kind != ""
- yyq2[3] = x.APIVersion != ""
+ yyq2[0] = x.Rule != ""
+ yyq2[1] = len(x.Ranges) != 0
var yynn2 int
if yyr2 || yy2arr2 {
- r.EncodeArrayStart(4)
+ r.EncodeArrayStart(2)
} else {
- yynn2 = 1
+ yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@@ -18348,106 +18537,48 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[0] {
- yy4 := &x.ListMeta
- yym5 := z.EncBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.EncExt(yy4) {
- } else {
- z.EncFallback(yy4)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq2[0] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("metadata"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy6 := &x.ListMeta
- yym7 := z.EncBinary()
- _ = yym7
- if false {
- } else if z.HasExtensions() && z.EncExt(yy6) {
- } else {
- z.EncFallback(yy6)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym9 := z.EncBinary()
- _ = yym9
- if false {
- } else {
- h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
- }
- }
- } else {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("items"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.Items == nil {
- r.EncodeNil()
- } else {
- yym10 := z.EncBinary()
- _ = yym10
- if false {
- } else {
- h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
- }
- }
- }
- if yyr2 || yy2arr2 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[2] {
- yym12 := z.EncBinary()
- _ = yym12
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ x.Rule.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2[2] {
+ if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym13 := z.EncBinary()
- _ = yym13
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
+ x.Rule.CodecEncodeSelf(e)
}
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2[3] {
- yym15 := z.EncBinary()
- _ = yym15
- if false {
+ if yyq2[1] {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
} else {
- r.EncodeString(codecSelferC_UTF81234, "")
+ r.EncodeNil()
}
} else {
- if yyq2[3] {
+ if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("ranges"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym16 := z.EncBinary()
- _ = yym16
- if false {
+ if x.Ranges == nil {
+ r.EncodeNil()
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
}
}
}
@@ -18460,7 +18591,7 @@ func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
-func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18490,7 +18621,7 @@ func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
-func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18512,43 +18643,24 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decod
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
- case "metadata":
+ case "rule":
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Rule = ""
} else {
- yyv4 := &x.ListMeta
- yym5 := z.DecBinary()
- _ = yym5
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv4) {
- } else {
- z.DecFallback(yyv4, false)
- }
+ x.Rule = FSGroupStrategyType(r.DecodeString())
}
- case "items":
+ case "ranges":
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Ranges = nil
} else {
- yyv6 := &x.Items
- yym7 := z.DecBinary()
- _ = yym7
+ yyv5 := &x.Ranges
+ yym6 := z.DecBinary()
+ _ = yym6
if false {
} else {
- h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv6), d)
+ h.decSliceIDRange((*[]IDRange)(yyv5), d)
}
}
- case "kind":
- if r.TryDecodeAsNil() {
- x.Kind = ""
- } else {
- x.Kind = string(r.DecodeString())
- }
- case "apiVersion":
- if r.TryDecodeAsNil() {
- x.APIVersion = ""
- } else {
- x.APIVersion = string(r.DecodeString())
- }
default:
z.DecStructFieldNotFound(-1, yys3)
} // end switch yys3
@@ -18556,107 +18668,2795 @@ func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decod
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
-func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+func (x *FSGroupStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj10 int
- var yyb10 bool
- var yyhl10 bool = l >= 0
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.ListMeta = pkg1_unversioned.ListMeta{}
+ x.Rule = ""
} else {
- yyv11 := &x.ListMeta
- yym12 := z.DecBinary()
- _ = yym12
- if false {
- } else if z.HasExtensions() && z.DecExt(yyv11) {
- } else {
- z.DecFallback(yyv11, false)
- }
+ x.Rule = FSGroupStrategyType(r.DecodeString())
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Items = nil
+ x.Ranges = nil
} else {
- yyv13 := &x.Items
- yym14 := z.DecBinary()
- _ = yym14
+ yyv9 := &x.Ranges
+ yym10 := z.DecBinary()
+ _ = yym10
if false {
} else {
- h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv13), d)
+ h.decSliceIDRange((*[]IDRange)(yyv9), d)
}
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
- } else {
- yyb10 = r.CheckBreak()
- }
- if yyb10 {
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *FSGroupStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *SupplementalGroupsStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Rule != ""
+ yyq2[1] = len(x.Ranges) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ x.Rule.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rule"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.Rule.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Ranges == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ranges"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Ranges == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceIDRange(([]IDRange)(x.Ranges), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *SupplementalGroupsStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "rule":
+ if r.TryDecodeAsNil() {
+ x.Rule = ""
+ } else {
+ x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
+ }
+ case "ranges":
+ if r.TryDecodeAsNil() {
+ x.Ranges = nil
+ } else {
+ yyv5 := &x.Ranges
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv5), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.Kind = ""
+ x.Rule = ""
} else {
- x.Kind = string(r.DecodeString())
+ x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
}
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
- x.APIVersion = ""
+ x.Ranges = nil
} else {
- x.APIVersion = string(r.DecodeString())
+ yyv9 := &x.Ranges
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceIDRange((*[]IDRange)(yyv9), d)
+ }
}
for {
- yyj10++
- if yyhl10 {
- yyb10 = yyj10 > l
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
} else {
- yyb10 = r.CheckBreak()
+ yyb7 = r.CheckBreak()
}
- if yyb10 {
+ if yyb7 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj10-1, "")
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *SupplementalGroupsStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
+func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = NetworkPolicySpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg2_v1.ObjectMeta{}
+ } else {
+ yyv9 := &x.ObjectMeta
+ yyv9.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = NetworkPolicySpec{}
+ } else {
+ yyv10 := &x.Spec
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = len(x.Ingress) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4 := &x.PodSelector
+ yy4.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.PodSelector
+ yy6.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Ingress == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ingress"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Ingress == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "podSelector":
+ if r.TryDecodeAsNil() {
+ x.PodSelector = LabelSelector{}
+ } else {
+ yyv4 := &x.PodSelector
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "ingress":
+ if r.TryDecodeAsNil() {
+ x.Ingress = nil
+ } else {
+ yyv5 := &x.Ingress
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv5), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodSelector = LabelSelector{}
+ } else {
+ yyv8 := &x.PodSelector
+ yyv8.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Ingress = nil
+ } else {
+ yyv9 := &x.Ingress
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv9), d)
+ }
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicyIngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = len(x.Ports) != 0
+ yyq2[1] = len(x.From) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Ports == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("ports"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Ports == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.From == nil {
+ r.EncodeNil()
+ } else {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("from"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.From == nil {
+ r.EncodeNil()
+ } else {
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicyIngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicyIngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "ports":
+ if r.TryDecodeAsNil() {
+ x.Ports = nil
+ } else {
+ yyv4 := &x.Ports
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv4), d)
+ }
+ }
+ case "from":
+ if r.TryDecodeAsNil() {
+ x.From = nil
+ } else {
+ yyv6 := &x.From
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv6), d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicyIngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Ports = nil
+ } else {
+ yyv9 := &x.Ports
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv9), d)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.From = nil
+ } else {
+ yyv11 := &x.From
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv11), d)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicyPort) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.Protocol != nil
+ yyq2[1] = x.Port != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.Protocol == nil {
+ r.EncodeNil()
+ } else {
+ yy4 := *x.Protocol
+ yysf5 := &yy4
+ yysf5.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("protocol"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Protocol == nil {
+ r.EncodeNil()
+ } else {
+ yy6 := *x.Protocol
+ yysf7 := &yy6
+ yysf7.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Port == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Port) {
+ } else if !yym9 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.Port)
+ } else {
+ z.EncFallback(x.Port)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("port"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Port == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Port) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(x.Port)
+ } else {
+ z.EncFallback(x.Port)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicyPort) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicyPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "protocol":
+ if r.TryDecodeAsNil() {
+ if x.Protocol != nil {
+ x.Protocol = nil
+ }
+ } else {
+ if x.Protocol == nil {
+ x.Protocol = new(pkg2_v1.Protocol)
+ }
+ x.Protocol.CodecDecodeSelf(d)
+ }
+ case "port":
+ if r.TryDecodeAsNil() {
+ if x.Port != nil {
+ x.Port = nil
+ }
+ } else {
+ if x.Port == nil {
+ x.Port = new(pkg5_intstr.IntOrString)
+ }
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Port) {
+ } else if !yym6 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.Port)
+ } else {
+ z.DecFallback(x.Port, false)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicyPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj7 int
+ var yyb7 bool
+ var yyhl7 bool = l >= 0
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Protocol != nil {
+ x.Protocol = nil
+ }
+ } else {
+ if x.Protocol == nil {
+ x.Protocol = new(pkg2_v1.Protocol)
+ }
+ x.Protocol.CodecDecodeSelf(d)
+ }
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Port != nil {
+ x.Port = nil
+ }
+ } else {
+ if x.Port == nil {
+ x.Port = new(pkg5_intstr.IntOrString)
+ }
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Port) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(x.Port)
+ } else {
+ z.DecFallback(x.Port, false)
+ }
+ }
+ for {
+ yyj7++
+ if yyhl7 {
+ yyb7 = yyj7 > l
+ } else {
+ yyb7 = r.CheckBreak()
+ }
+ if yyb7 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj7-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicyPeer) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = x.PodSelector != nil
+ yyq2[1] = x.NamespaceSelector != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ if x.PodSelector == nil {
+ r.EncodeNil()
+ } else {
+ x.PodSelector.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.PodSelector == nil {
+ r.EncodeNil()
+ } else {
+ x.PodSelector.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.NamespaceSelector == nil {
+ r.EncodeNil()
+ } else {
+ x.NamespaceSelector.CodecEncodeSelf(e)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("namespaceSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.NamespaceSelector == nil {
+ r.EncodeNil()
+ } else {
+ x.NamespaceSelector.CodecEncodeSelf(e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicyPeer) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicyPeer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "podSelector":
+ if r.TryDecodeAsNil() {
+ if x.PodSelector != nil {
+ x.PodSelector = nil
+ }
+ } else {
+ if x.PodSelector == nil {
+ x.PodSelector = new(LabelSelector)
+ }
+ x.PodSelector.CodecDecodeSelf(d)
+ }
+ case "namespaceSelector":
+ if r.TryDecodeAsNil() {
+ if x.NamespaceSelector != nil {
+ x.NamespaceSelector = nil
+ }
+ } else {
+ if x.NamespaceSelector == nil {
+ x.NamespaceSelector = new(LabelSelector)
+ }
+ x.NamespaceSelector.CodecDecodeSelf(d)
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicyPeer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj6 int
+ var yyb6 bool
+ var yyhl6 bool = l >= 0
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.PodSelector != nil {
+ x.PodSelector = nil
+ }
+ } else {
+ if x.PodSelector == nil {
+ x.PodSelector = new(LabelSelector)
+ }
+ x.PodSelector.CodecDecodeSelf(d)
+ }
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.NamespaceSelector != nil {
+ x.NamespaceSelector = nil
+ }
+ } else {
+ if x.NamespaceSelector == nil {
+ x.NamespaceSelector = new(LabelSelector)
+ }
+ x.NamespaceSelector.CodecDecodeSelf(d)
+ }
+ for {
+ yyj6++
+ if yyhl6 {
+ yyb6 = yyj6 > l
+ } else {
+ yyb6 = r.CheckBreak()
+ }
+ if yyb6 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj6-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *NetworkPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *NetworkPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *NetworkPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *NetworkPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg1_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []CustomMetricTarget{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]CustomMetricTarget, yyrl1)
+ }
+ } else {
+ yyv1 = make([]CustomMetricTarget, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, CustomMetricTarget{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, CustomMetricTarget{}) // var yyz1 CustomMetricTarget
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricTarget{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []CustomMetricTarget{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurrentStatus, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []CustomMetricCurrentStatus{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ }
+ } else {
+ yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, CustomMetricCurrentStatus{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, CustomMetricCurrentStatus{}) // var yyz1 CustomMetricCurrentStatus
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = CustomMetricCurrentStatus{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []CustomMetricCurrentStatus{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutoscaler, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutoscaler, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []HorizontalPodAutoscaler{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 360)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ }
+ } else {
+ yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, HorizontalPodAutoscaler{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, HorizontalPodAutoscaler{}) // var yyz1 HorizontalPodAutoscaler
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = HorizontalPodAutoscaler{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []HorizontalPodAutoscaler{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []APIVersion{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]APIVersion, yyrl1)
+ }
+ } else {
+ yyv1 = make([]APIVersion, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = APIVersion{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, APIVersion{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = APIVersion{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, APIVersion{}) // var yyz1 APIVersion
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = APIVersion{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []APIVersion{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
}
- z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18669,7 +21469,7 @@ func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *c
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18680,7 +21480,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []CustomMetricTarget{}
+ yyv1 = []ThirdPartyResource{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18695,15 +21495,15 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 280)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]CustomMetricTarget, yyrl1)
+ yyv1 = make([]ThirdPartyResource, yyrl1)
}
} else {
- yyv1 = make([]CustomMetricTarget, yyrl1)
+ yyv1 = make([]ThirdPartyResource, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18718,7 +21518,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18727,10 +21527,10 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, CustomMetricTarget{})
+ yyv1 = append(yyv1, ThirdPartyResource{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18744,13 +21544,13 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, CustomMetricTarget{}) // var yyz1 CustomMetricTarget
+ yyv1 = append(yyv1, ThirdPartyResource{}) // var yyz1 ThirdPartyResource
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricTarget{}
+ yyv1[yyj1] = ThirdPartyResource{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18765,7 +21565,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []CustomMetricTarget{}
+ yyv1 = []ThirdPartyResource{}
yyc1 = true
}
}
@@ -18775,7 +21575,7 @@ func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *
}
}
-func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18788,7 +21588,7 @@ func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurre
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurrentStatus, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18799,7 +21599,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []CustomMetricCurrentStatus{}
+ yyv1 = []Deployment{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18814,15 +21614,15 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 792)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ yyv1 = make([]Deployment, yyrl1)
}
} else {
- yyv1 = make([]CustomMetricCurrentStatus, yyrl1)
+ yyv1 = make([]Deployment, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18837,7 +21637,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18846,10 +21646,10 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, CustomMetricCurrentStatus{})
+ yyv1 = append(yyv1, Deployment{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18863,13 +21663,13 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, CustomMetricCurrentStatus{}) // var yyz1 CustomMetricCurrentStatus
+ yyv1 = append(yyv1, Deployment{}) // var yyz1 Deployment
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = CustomMetricCurrentStatus{}
+ yyv1[yyj1] = Deployment{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -18884,7 +21684,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []CustomMetricCurrentStatus{}
+ yyv1 = []Deployment{}
yyc1 = true
}
}
@@ -18894,7 +21694,7 @@ func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurr
}
}
-func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutoscaler, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -18907,7 +21707,7 @@ func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutosc
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutoscaler, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -18918,7 +21718,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HorizontalPodAutoscaler{}
+ yyv1 = []DaemonSet{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -18933,15 +21733,15 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 312)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 720)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ yyv1 = make([]DaemonSet, yyrl1)
}
} else {
- yyv1 = make([]HorizontalPodAutoscaler, yyrl1)
+ yyv1 = make([]DaemonSet, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -18956,7 +21756,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -18965,10 +21765,10 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HorizontalPodAutoscaler{})
+ yyv1 = append(yyv1, DaemonSet{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -18982,13 +21782,13 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HorizontalPodAutoscaler{}) // var yyz1 HorizontalPodAutoscaler
+ yyv1 = append(yyv1, DaemonSet{}) // var yyz1 DaemonSet
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HorizontalPodAutoscaler{}
+ yyv1[yyj1] = DaemonSet{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19003,7 +21803,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HorizontalPodAutoscaler{}
+ yyv1 = []DaemonSet{}
yyc1 = true
}
}
@@ -19013,7 +21813,7 @@ func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutos
}
}
-func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19026,7 +21826,7 @@ func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19037,7 +21837,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []APIVersion{}
+ yyv1 = []ThirdPartyResourceData{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19052,15 +21852,15 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 32)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]APIVersion, yyrl1)
+ yyv1 = make([]ThirdPartyResourceData, yyrl1)
}
} else {
- yyv1 = make([]APIVersion, yyrl1)
+ yyv1 = make([]ThirdPartyResourceData, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19075,7 +21875,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19084,10 +21884,10 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, APIVersion{})
+ yyv1 = append(yyv1, ThirdPartyResourceData{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19101,13 +21901,13 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, APIVersion{}) // var yyz1 APIVersion
+ yyv1 = append(yyv1, ThirdPartyResourceData{}) // var yyz1 ThirdPartyResourceData
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = APIVersion{}
+ yyv1[yyj1] = ThirdPartyResourceData{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19122,7 +21922,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []APIVersion{}
+ yyv1 = []ThirdPartyResourceData{}
yyc1 = true
}
}
@@ -19132,7 +21932,7 @@ func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19145,7 +21945,7 @@ func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *c
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19156,7 +21956,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ThirdPartyResource{}
+ yyv1 = []Job{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19171,15 +21971,15 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 232)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 792)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ThirdPartyResource, yyrl1)
+ yyv1 = make([]Job, yyrl1)
}
} else {
- yyv1 = make([]ThirdPartyResource, yyrl1)
+ yyv1 = make([]Job, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19194,7 +21994,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = Job{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19203,10 +22003,10 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ThirdPartyResource{})
+ yyv1 = append(yyv1, Job{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = Job{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19220,13 +22020,13 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ThirdPartyResource{}) // var yyz1 ThirdPartyResource
+ yyv1 = append(yyv1, Job{}) // var yyz1 Job
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResource{}
+ yyv1[yyj1] = Job{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19241,7 +22041,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ThirdPartyResource{}
+ yyv1 = []Job{}
yyc1 = true
}
}
@@ -19251,7 +22051,7 @@ func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *
}
}
-func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19264,7 +22064,7 @@ func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19275,7 +22075,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Deployment{}
+ yyv1 = []JobCondition{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19290,15 +22090,15 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 640)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Deployment, yyrl1)
+ yyv1 = make([]JobCondition, yyrl1)
}
} else {
- yyv1 = make([]Deployment, yyrl1)
+ yyv1 = make([]JobCondition, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19313,7 +22113,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = JobCondition{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19322,10 +22122,10 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Deployment{})
+ yyv1 = append(yyv1, JobCondition{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = JobCondition{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19339,13 +22139,13 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Deployment{}) // var yyz1 Deployment
+ yyv1 = append(yyv1, JobCondition{}) // var yyz1 JobCondition
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Deployment{}
+ yyv1[yyj1] = JobCondition{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19360,7 +22160,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Deployment{}
+ yyv1 = []JobCondition{}
yyc1 = true
}
}
@@ -19370,7 +22170,7 @@ func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19383,7 +22183,7 @@ func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder)
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19394,7 +22194,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []DaemonSet{}
+ yyv1 = []Ingress{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19409,15 +22209,15 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 568)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 320)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]DaemonSet, yyrl1)
+ yyv1 = make([]Ingress, yyrl1)
}
} else {
- yyv1 = make([]DaemonSet, yyrl1)
+ yyv1 = make([]Ingress, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19432,7 +22232,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19441,10 +22241,10 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, DaemonSet{})
+ yyv1 = append(yyv1, Ingress{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19458,13 +22258,13 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, DaemonSet{}) // var yyz1 DaemonSet
+ yyv1 = append(yyv1, Ingress{}) // var yyz1 Ingress
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = DaemonSet{}
+ yyv1[yyj1] = Ingress{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19479,7 +22279,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []DaemonSet{}
+ yyv1 = []Ingress{}
yyc1 = true
}
}
@@ -19489,7 +22289,7 @@ func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder)
}
}
-func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19502,7 +22302,7 @@ func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceDa
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19513,7 +22313,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ThirdPartyResourceData{}
+ yyv1 = []IngressTLS{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19528,15 +22328,15 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 216)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ThirdPartyResourceData, yyrl1)
+ yyv1 = make([]IngressTLS, yyrl1)
}
} else {
- yyv1 = make([]ThirdPartyResourceData, yyrl1)
+ yyv1 = make([]IngressTLS, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19551,7 +22351,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19560,10 +22360,10 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ThirdPartyResourceData{})
+ yyv1 = append(yyv1, IngressTLS{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19577,13 +22377,13 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ThirdPartyResourceData{}) // var yyz1 ThirdPartyResourceData
+ yyv1 = append(yyv1, IngressTLS{}) // var yyz1 IngressTLS
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ThirdPartyResourceData{}
+ yyv1[yyj1] = IngressTLS{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19598,7 +22398,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ThirdPartyResourceData{}
+ yyv1 = []IngressTLS{}
yyc1 = true
}
}
@@ -19608,7 +22408,7 @@ func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceD
}
}
-func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19621,7 +22421,7 @@ func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19632,7 +22432,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Job{}
+ yyv1 = []IngressRule{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19647,15 +22447,15 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 640)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Job, yyrl1)
+ yyv1 = make([]IngressRule, yyrl1)
}
} else {
- yyv1 = make([]Job, yyrl1)
+ yyv1 = make([]IngressRule, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19670,7 +22470,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19679,10 +22479,10 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Job{})
+ yyv1 = append(yyv1, IngressRule{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19696,13 +22496,13 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Job{}) // var yyz1 Job
+ yyv1 = append(yyv1, IngressRule{}) // var yyz1 IngressRule
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Job{}
+ yyv1[yyj1] = IngressRule{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19717,7 +22517,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Job{}
+ yyv1 = []IngressRule{}
yyc1 = true
}
}
@@ -19727,7 +22527,7 @@ func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19740,7 +22540,7 @@ func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Enc
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19751,7 +22551,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []JobCondition{}
+ yyv1 = []HTTPIngressPath{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19766,15 +22566,15 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 112)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]JobCondition, yyrl1)
+ yyv1 = make([]HTTPIngressPath, yyrl1)
}
} else {
- yyv1 = make([]JobCondition, yyrl1)
+ yyv1 = make([]HTTPIngressPath, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19789,7 +22589,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19798,10 +22598,10 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, JobCondition{})
+ yyv1 = append(yyv1, HTTPIngressPath{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19815,13 +22615,13 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, JobCondition{}) // var yyz1 JobCondition
+ yyv1 = append(yyv1, HTTPIngressPath{}) // var yyz1 HTTPIngressPath
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = JobCondition{}
+ yyv1[yyj1] = HTTPIngressPath{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19836,7 +22636,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []JobCondition{}
+ yyv1 = []HTTPIngressPath{}
yyc1 = true
}
}
@@ -19846,7 +22646,7 @@ func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.De
}
}
-func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequirement, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19859,7 +22659,7 @@ func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequirement, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19870,7 +22670,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []Ingress{}
+ yyv1 = []LabelSelectorRequirement{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -19885,15 +22685,15 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 272)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]Ingress, yyrl1)
+ yyv1 = make([]LabelSelectorRequirement, yyrl1)
}
} else {
- yyv1 = make([]Ingress, yyrl1)
+ yyv1 = make([]LabelSelectorRequirement, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -19908,7 +22708,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = LabelSelectorRequirement{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -19917,10 +22717,10 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, Ingress{})
+ yyv1 = append(yyv1, LabelSelectorRequirement{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = LabelSelectorRequirement{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -19934,13 +22734,13 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, Ingress{}) // var yyz1 Ingress
+ yyv1 = append(yyv1, LabelSelectorRequirement{}) // var yyz1 LabelSelectorRequirement
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = Ingress{}
+ yyv1[yyj1] = LabelSelectorRequirement{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -19955,7 +22755,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []Ingress{}
+ yyv1 = []LabelSelectorRequirement{}
yyc1 = true
}
}
@@ -19965,7 +22765,7 @@ func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -19978,7 +22778,7 @@ func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -19989,7 +22789,7 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IngressTLS{}
+ yyv1 = []ReplicaSet{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20004,15 +22804,15 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 728)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IngressTLS, yyrl1)
+ yyv1 = make([]ReplicaSet, yyrl1)
}
} else {
- yyv1 = make([]IngressTLS, yyrl1)
+ yyv1 = make([]ReplicaSet, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -20027,7 +22827,7 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -20036,10 +22836,10 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IngressTLS{})
+ yyv1 = append(yyv1, ReplicaSet{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -20053,13 +22853,13 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IngressTLS{}) // var yyz1 IngressTLS
+ yyv1 = append(yyv1, ReplicaSet{}) // var yyz1 ReplicaSet
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressTLS{}
+ yyv1[yyj1] = ReplicaSet{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -20074,7 +22874,7 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IngressTLS{}
+ yyv1 = []ReplicaSet{}
yyc1 = true
}
}
@@ -20084,20 +22884,20 @@ func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSlicev1_Capability(v []pkg2_v1.Capability, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy2 := &yyv1
- yy2.CodecEncodeSelf(e)
+ yysf2 := &yyv1
+ yysf2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20108,7 +22908,7 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IngressRule{}
+ yyv1 = []pkg2_v1.Capability{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20121,23 +22921,18 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrg1 := len(yyv1) > 0
- yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IngressRule, yyrl1)
+ yyv1 = make([]pkg2_v1.Capability, yyrl1)
}
} else {
- yyv1 = make([]IngressRule, yyrl1)
+ yyv1 = make([]pkg2_v1.Capability, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
- if yyrg1 {
- copy(yyv1, yyv21)
- }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -20146,22 +22941,20 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv2 := &yyv1[yyj1]
- yyv2.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IngressRule{})
+ yyv1 = append(yyv1, "")
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv3 := &yyv1[yyj1]
- yyv3.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
}
}
@@ -20172,16 +22965,15 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IngressRule{}) // var yyz1 IngressRule
+ yyv1 = append(yyv1, "") // var yyz1 pkg2_v1.Capability
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IngressRule{}
+ yyv1[yyj1] = ""
} else {
- yyv4 := &yyv1[yyj1]
- yyv4.CodecDecodeSelf(d)
+ yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
}
} else {
@@ -20193,7 +22985,7 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IngressRule{}
+ yyv1 = []pkg2_v1.Capability{}
yyc1 = true
}
}
@@ -20203,20 +22995,19 @@ func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Deco
}
}
-func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy2 := &yyv1
- yy2.CodecEncodeSelf(e)
+ yyv1.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20227,7 +23018,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HTTPIngressPath{}
+ yyv1 = []FSType{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20240,23 +23031,18 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrg1 := len(yyv1) > 0
- yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HTTPIngressPath, yyrl1)
+ yyv1 = make([]FSType, yyrl1)
}
} else {
- yyv1 = make([]HTTPIngressPath, yyrl1)
+ yyv1 = make([]FSType, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
- if yyrg1 {
- copy(yyv1, yyv21)
- }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -20265,22 +23051,20 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = ""
} else {
- yyv2 := &yyv1[yyj1]
- yyv2.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HTTPIngressPath{})
+ yyv1 = append(yyv1, "")
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = ""
} else {
- yyv3 := &yyv1[yyj1]
- yyv3.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
}
@@ -20291,16 +23075,15 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HTTPIngressPath{}) // var yyz1 HTTPIngressPath
+ yyv1 = append(yyv1, "") // var yyz1 FSType
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HTTPIngressPath{}
+ yyv1[yyj1] = ""
} else {
- yyv4 := &yyv1[yyj1]
- yyv4.CodecDecodeSelf(d)
+ yyv1[yyj1] = FSType(r.DecodeString())
}
} else {
@@ -20312,7 +23095,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HTTPIngressPath{}
+ yyv1 = []FSType{}
yyc1 = true
}
}
@@ -20322,7 +23105,7 @@ func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1
}
}
-func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequirement, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -20335,7 +23118,7 @@ func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequi
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequirement, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20346,7 +23129,7 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []LabelSelectorRequirement{}
+ yyv1 = []HostPortRange{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20361,15 +23144,15 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 56)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]LabelSelectorRequirement, yyrl1)
+ yyv1 = make([]HostPortRange, yyrl1)
}
} else {
- yyv1 = make([]LabelSelectorRequirement, yyrl1)
+ yyv1 = make([]HostPortRange, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -20384,7 +23167,7 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = LabelSelectorRequirement{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -20393,10 +23176,10 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, LabelSelectorRequirement{})
+ yyv1 = append(yyv1, HostPortRange{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = LabelSelectorRequirement{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -20410,13 +23193,13 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, LabelSelectorRequirement{}) // var yyz1 LabelSelectorRequirement
+ yyv1 = append(yyv1, HostPortRange{}) // var yyz1 HostPortRange
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = LabelSelectorRequirement{}
+ yyv1[yyj1] = HostPortRange{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -20431,7 +23214,7 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []LabelSelectorRequirement{}
+ yyv1 = []HostPortRange{}
yyc1 = true
}
}
@@ -20441,7 +23224,7 @@ func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequ
}
}
-func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -20454,7 +23237,7 @@ func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20465,7 +23248,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []ReplicaSet{}
+ yyv1 = []IDRange{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20480,15 +23263,15 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 576)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]ReplicaSet, yyrl1)
+ yyv1 = make([]IDRange, yyrl1)
}
} else {
- yyv1 = make([]ReplicaSet, yyrl1)
+ yyv1 = make([]IDRange, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -20503,7 +23286,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -20512,10 +23295,10 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, ReplicaSet{})
+ yyv1 = append(yyv1, IDRange{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -20529,13 +23312,13 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, ReplicaSet{}) // var yyz1 ReplicaSet
+ yyv1 = append(yyv1, IDRange{}) // var yyz1 IDRange
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ReplicaSet{}
+ yyv1[yyj1] = IDRange{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -20550,7 +23333,7 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []ReplicaSet{}
+ yyv1 = []IDRange{}
yyc1 = true
}
}
@@ -20560,20 +23343,20 @@ func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSlicev1_Capability(v []pkg2_v1.Capability, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yysf2 := &yyv1
- yysf2.CodecEncodeSelf(e)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20584,7 +23367,7 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []pkg2_v1.Capability{}
+ yyv1 = []PodSecurityPolicy{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20597,18 +23380,23 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 536)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]pkg2_v1.Capability, yyrl1)
+ yyv1 = make([]PodSecurityPolicy, yyrl1)
}
} else {
- yyv1 = make([]pkg2_v1.Capability, yyrl1)
+ yyv1 = make([]PodSecurityPolicy, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -20617,20 +23405,22 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, "")
+ yyv1 = append(yyv1, PodSecurityPolicy{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
}
}
@@ -20641,15 +23431,16 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, "") // var yyz1 pkg2_v1.Capability
+ yyv1 = append(yyv1, PodSecurityPolicy{}) // var yyz1 PodSecurityPolicy
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = PodSecurityPolicy{}
} else {
- yyv1[yyj1] = pkg2_v1.Capability(r.DecodeString())
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
}
} else {
@@ -20661,7 +23452,7 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []pkg2_v1.Capability{}
+ yyv1 = []PodSecurityPolicy{}
yyc1 = true
}
}
@@ -20671,19 +23462,20 @@ func (x codecSelfer1234) decSlicev1_Capability(v *[]pkg2_v1.Capability, d *codec
}
}
-func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyIngressRule(v []NetworkPolicyIngressRule, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv1 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv1.CodecEncodeSelf(e)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyIngressRule(v *[]NetworkPolicyIngressRule, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20694,7 +23486,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []FSType{}
+ yyv1 = []NetworkPolicyIngressRule{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20707,18 +23499,23 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
yyrr1 = yyl1 // len(yyv1)
if yyl1 > cap(yyv1) {
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]FSType, yyrl1)
+ yyv1 = make([]NetworkPolicyIngressRule, yyrl1)
}
} else {
- yyv1 = make([]FSType, yyrl1)
+ yyv1 = make([]NetworkPolicyIngressRule, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
} else if yyl1 != len(yyv1) {
yyv1 = yyv1[:yyl1]
yyc1 = true
@@ -20727,20 +23524,22 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
}
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, "")
+ yyv1 = append(yyv1, NetworkPolicyIngressRule{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
}
}
@@ -20751,15 +23550,16 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, "") // var yyz1 FSType
+ yyv1 = append(yyv1, NetworkPolicyIngressRule{}) // var yyz1 NetworkPolicyIngressRule
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = ""
+ yyv1[yyj1] = NetworkPolicyIngressRule{}
} else {
- yyv1[yyj1] = FSType(r.DecodeString())
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
}
} else {
@@ -20771,7 +23571,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []FSType{}
+ yyv1 = []NetworkPolicyIngressRule{}
yyc1 = true
}
}
@@ -20781,7 +23581,7 @@ func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyPort(v []NetworkPolicyPort, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -20794,7 +23594,7 @@ func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.E
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyPort(v *[]NetworkPolicyPort, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20805,7 +23605,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []HostPortRange{}
+ yyv1 = []NetworkPolicyPort{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20820,15 +23620,15 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]HostPortRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPort, yyrl1)
}
} else {
- yyv1 = make([]HostPortRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPort, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -20843,7 +23643,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -20852,10 +23652,10 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, HostPortRange{})
+ yyv1 = append(yyv1, NetworkPolicyPort{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -20869,13 +23669,13 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, HostPortRange{}) // var yyz1 HostPortRange
+ yyv1 = append(yyv1, NetworkPolicyPort{}) // var yyz1 NetworkPolicyPort
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = HostPortRange{}
+ yyv1[yyj1] = NetworkPolicyPort{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -20890,7 +23690,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []HostPortRange{}
+ yyv1 = []NetworkPolicyPort{}
yyc1 = true
}
}
@@ -20900,7 +23700,7 @@ func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.
}
}
-func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicyPeer(v []NetworkPolicyPeer, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -20913,7 +23713,7 @@ func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicyPeer(v *[]NetworkPolicyPeer, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -20924,7 +23724,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []IDRange{}
+ yyv1 = []NetworkPolicyPeer{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -20944,10 +23744,10 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]IDRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPeer, yyrl1)
}
} else {
- yyv1 = make([]IDRange, yyrl1)
+ yyv1 = make([]NetworkPolicyPeer, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -20962,7 +23762,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -20971,10 +23771,10 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, IDRange{})
+ yyv1 = append(yyv1, NetworkPolicyPeer{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -20988,13 +23788,13 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, IDRange{}) // var yyz1 IDRange
+ yyv1 = append(yyv1, NetworkPolicyPeer{}) // var yyz1 NetworkPolicyPeer
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = IDRange{}
+ yyv1[yyj1] = NetworkPolicyPeer{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -21009,7 +23809,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []IDRange{}
+ yyv1 = []NetworkPolicyPeer{}
yyc1 = true
}
}
@@ -21019,7 +23819,7 @@ func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
}
}
-func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceNetworkPolicy(v []NetworkPolicy, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@@ -21032,7 +23832,7 @@ func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *cod
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
-func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *codec1978.Decoder) {
+func (x codecSelfer1234) decSliceNetworkPolicy(v *[]NetworkPolicy, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@@ -21043,7 +23843,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
_ = yyc1
if yyl1 == 0 {
if yyv1 == nil {
- yyv1 = []PodSecurityPolicy{}
+ yyv1 = []NetworkPolicy{}
yyc1 = true
} else if len(yyv1) != 0 {
yyv1 = yyv1[:0]
@@ -21058,15 +23858,15 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
yyrg1 := len(yyv1) > 0
yyv21 := yyv1
- yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 352)
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
if yyrt1 {
if yyrl1 <= cap(yyv1) {
yyv1 = yyv1[:yyrl1]
} else {
- yyv1 = make([]PodSecurityPolicy, yyrl1)
+ yyv1 = make([]NetworkPolicy, yyrl1)
}
} else {
- yyv1 = make([]PodSecurityPolicy, yyrl1)
+ yyv1 = make([]NetworkPolicy, yyrl1)
}
yyc1 = true
yyrr1 = len(yyv1)
@@ -21081,7 +23881,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
for ; yyj1 < yyrr1; yyj1++ {
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv2 := &yyv1[yyj1]
yyv2.CodecDecodeSelf(d)
@@ -21090,10 +23890,10 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
}
if yyrt1 {
for ; yyj1 < yyl1; yyj1++ {
- yyv1 = append(yyv1, PodSecurityPolicy{})
+ yyv1 = append(yyv1, NetworkPolicy{})
yyh1.ElemContainerState(yyj1)
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv3 := &yyv1[yyj1]
yyv3.CodecDecodeSelf(d)
@@ -21107,13 +23907,13 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
for ; !r.CheckBreak(); yyj1++ {
if yyj1 >= len(yyv1) {
- yyv1 = append(yyv1, PodSecurityPolicy{}) // var yyz1 PodSecurityPolicy
+ yyv1 = append(yyv1, NetworkPolicy{}) // var yyz1 NetworkPolicy
yyc1 = true
}
yyh1.ElemContainerState(yyj1)
if yyj1 < len(yyv1) {
if r.TryDecodeAsNil() {
- yyv1[yyj1] = PodSecurityPolicy{}
+ yyv1[yyj1] = NetworkPolicy{}
} else {
yyv4 := &yyv1[yyj1]
yyv4.CodecDecodeSelf(d)
@@ -21128,7 +23928,7 @@ func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *co
yyv1 = yyv1[:yyj1]
yyc1 = true
} else if yyj1 == 0 && yyv1 == nil {
- yyv1 = []PodSecurityPolicy{}
+ yyv1 = []NetworkPolicy{}
yyc1 = true
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go
similarity index 58%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go
index 0af3a087eb3d7a5c2eba99fb17d9bc262571e67a..7fead65b9512c9015b4260965044957703821e67 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types.go
@@ -26,24 +26,24 @@ import (
// describes the attributes of a scale subresource
type ScaleSpec struct {
// desired number of instances for the scaled object.
- Replicas int32 `json:"replicas,omitempty"`
+ Replicas int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
}
// represents the current status of a scale subresource.
type ScaleStatus struct {
// actual number of observed instances of the scaled object.
- Replicas int32 `json:"replicas"`
+ Replicas int32 `json:"replicas" protobuf:"varint,1,opt,name=replicas"`
- // label query over pods that should match the replicas count. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector map[string]string `json:"selector,omitempty"`
+ // label query over pods that should match the replicas count. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector map[string]string `json:"selector,omitempty" protobuf:"bytes,2,rep,name=selector"`
// label selector for pods that should match the replicas count. This is a serializated
// version of both map-based and more expressive set-based selectors. This is done to
// avoid introspection in the clients. The string will be in the same format as the
// query-param syntax. If the target type only supports map-based selectors, both this
// field and map-based selector field are populated.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- TargetSelector string `json:"targetSelector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ TargetSelector string `json:"targetSelector,omitempty" protobuf:"bytes,3,opt,name=targetSelector"`
}
// +genclient=true,noMethods=true
@@ -51,14 +51,14 @@ type ScaleStatus struct {
// represents a scaling request for a resource.
type Scale struct {
unversioned.TypeMeta `json:",inline"`
- // Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
- // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
- Spec ScaleSpec `json:"spec,omitempty"`
+ // defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ Spec ScaleSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
- // current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.
- Status ScaleStatus `json:"status,omitempty"`
+ // current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.
+ Status ScaleStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// Dummy definition
@@ -68,77 +68,77 @@ type ReplicationControllerDummy struct {
// SubresourceReference contains enough information to let you inspect or modify the referred subresource.
type SubresourceReference struct {
- // Kind of the referent; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds"
- Kind string `json:"kind,omitempty"`
- // Name of the referent; More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names
- Name string `json:"name,omitempty"`
+ // Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
+ // Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names
+ Name string `json:"name,omitempty" protobuf:"bytes,2,opt,name=name"`
// API version of the referent
- APIVersion string `json:"apiVersion,omitempty"`
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"`
// Subresource name of the referent
- Subresource string `json:"subresource,omitempty"`
+ Subresource string `json:"subresource,omitempty" protobuf:"bytes,4,opt,name=subresource"`
}
type CPUTargetUtilization struct {
// fraction of the requested CPU that should be utilized/used,
// e.g. 70 means that 70% of the requested CPU should be in use.
- TargetPercentage int32 `json:"targetPercentage"`
+ TargetPercentage int32 `json:"targetPercentage" protobuf:"varint,1,opt,name=targetPercentage"`
}
// Alpha-level support for Custom Metrics in HPA (as annotations).
type CustomMetricTarget struct {
// Custom Metric name.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Custom Metric value (average).
- TargetValue resource.Quantity `json:"value"`
+ TargetValue resource.Quantity `json:"value" protobuf:"bytes,2,opt,name=value"`
}
type CustomMetricTargetList struct {
- Items []CustomMetricTarget `json:"items"`
+ Items []CustomMetricTarget `json:"items" protobuf:"bytes,1,rep,name=items"`
}
type CustomMetricCurrentStatus struct {
// Custom Metric name.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// Custom Metric value (average).
- CurrentValue resource.Quantity `json:"value"`
+ CurrentValue resource.Quantity `json:"value" protobuf:"bytes,2,opt,name=value"`
}
type CustomMetricCurrentStatusList struct {
- Items []CustomMetricCurrentStatus `json:"items"`
+ Items []CustomMetricCurrentStatus `json:"items" protobuf:"bytes,1,rep,name=items"`
}
// specification of a horizontal pod autoscaler.
type HorizontalPodAutoscalerSpec struct {
// reference to Scale subresource; horizontal pod autoscaler will learn the current resource consumption from its status,
// and will set the desired number of pods by modifying its spec.
- ScaleRef SubresourceReference `json:"scaleRef"`
+ ScaleRef SubresourceReference `json:"scaleRef" protobuf:"bytes,1,opt,name=scaleRef"`
// lower limit for the number of pods that can be set by the autoscaler, default 1.
- MinReplicas *int32 `json:"minReplicas,omitempty"`
+ MinReplicas *int32 `json:"minReplicas,omitempty" protobuf:"varint,2,opt,name=minReplicas"`
// upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
- MaxReplicas int32 `json:"maxReplicas"`
+ MaxReplicas int32 `json:"maxReplicas" protobuf:"varint,3,opt,name=maxReplicas"`
// target average CPU utilization (represented as a percentage of requested CPU) over all the pods;
// if not specified it defaults to the target CPU utilization at 80% of the requested resources.
- CPUUtilization *CPUTargetUtilization `json:"cpuUtilization,omitempty"`
+ CPUUtilization *CPUTargetUtilization `json:"cpuUtilization,omitempty" protobuf:"bytes,4,opt,name=cpuUtilization"`
}
// current status of a horizontal pod autoscaler
type HorizontalPodAutoscalerStatus struct {
// most recent generation observed by this autoscaler.
- ObservedGeneration *int64 `json:"observedGeneration,omitempty"`
+ ObservedGeneration *int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"`
// last time the HorizontalPodAutoscaler scaled the number of pods;
// used by the autoscaler to control how often the number of pods is changed.
- LastScaleTime *unversioned.Time `json:"lastScaleTime,omitempty"`
+ LastScaleTime *unversioned.Time `json:"lastScaleTime,omitempty" protobuf:"bytes,2,opt,name=lastScaleTime"`
// current number of replicas of pods managed by this autoscaler.
- CurrentReplicas int32 `json:"currentReplicas"`
+ CurrentReplicas int32 `json:"currentReplicas" protobuf:"varint,3,opt,name=currentReplicas"`
// desired number of replicas of pods managed by this autoscaler.
- DesiredReplicas int32 `json:"desiredReplicas"`
+ DesiredReplicas int32 `json:"desiredReplicas" protobuf:"varint,4,opt,name=desiredReplicas"`
// 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.
- CurrentCPUUtilizationPercentage *int32 `json:"currentCPUUtilizationPercentage,omitempty"`
+ CurrentCPUUtilizationPercentage *int32 `json:"currentCPUUtilizationPercentage,omitempty" protobuf:"varint,5,opt,name=currentCPUUtilizationPercentage"`
}
// +genclient=true
@@ -146,27 +146,27 @@ type HorizontalPodAutoscalerStatus struct {
// configuration of a horizontal pod autoscaler.
type HorizontalPodAutoscaler struct {
unversioned.TypeMeta `json:",inline"`
- // Standard object metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
- // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.
- Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty"`
+ // behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.
+ Spec HorizontalPodAutoscalerSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// current information about the autoscaler.
- Status HorizontalPodAutoscalerStatus `json:"status,omitempty"`
+ Status HorizontalPodAutoscalerStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// list of horizontal pod autoscaler objects.
type HorizontalPodAutoscalerList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- unversioned.ListMeta `json:"metadata,omitempty"`
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// list of horizontal pod autoscaler objects.
- Items []HorizontalPodAutoscaler `json:"items"`
+ Items []HorizontalPodAutoscaler `json:"items" protobuf:"bytes,2,rep,name=items"`
}
-// +genclient=true
+// +genclient=true,nonNamespaced=true
// A ThirdPartyResource is a generic representation of a resource, it is used by add-ons and plugins to add new resource
// types to the API. It consists of one or more Versions of the api.
@@ -174,13 +174,13 @@ type ThirdPartyResource struct {
unversioned.TypeMeta `json:",inline"`
// Standard object metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Description is the description of this object.
- Description string `json:"description,omitempty"`
+ Description string `json:"description,omitempty" protobuf:"bytes,2,opt,name=description"`
// Versions are versions for this third party object
- Versions []APIVersion `json:"versions,omitempty"`
+ Versions []APIVersion `json:"versions,omitempty" protobuf:"bytes,3,rep,name=versions"`
}
// ThirdPartyResourceList is a list of ThirdPartyResources.
@@ -188,29 +188,26 @@ type ThirdPartyResourceList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- unversioned.ListMeta `json:"metadata,omitempty"`
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of ThirdPartyResources.
- Items []ThirdPartyResource `json:"items"`
+ Items []ThirdPartyResource `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// An APIVersion represents a single concrete version of an object model.
type APIVersion struct {
// Name of this version (e.g. 'v1').
- Name string `json:"name,omitempty"`
-
- // The API group to add this object into, default 'experimental'.
- APIGroup string `json:"apiGroup,omitempty"`
+ Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`
}
// An internal object, used for versioned storage in etcd. Not exposed to the end user.
type ThirdPartyResourceData struct {
unversioned.TypeMeta `json:",inline"`
// Standard object metadata.
- v1.ObjectMeta `json:"metadata,omitempty"`
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Data is the raw JSON data for this data.
- Data []byte `json:"data,omitempty"`
+ Data []byte `json:"data,omitempty" protobuf:"bytes,2,opt,name=data"`
}
// +genclient=true
@@ -219,61 +216,61 @@ type ThirdPartyResourceData struct {
type Deployment struct {
unversioned.TypeMeta `json:",inline"`
// Standard object metadata.
- v1.ObjectMeta `json:"metadata,omitempty"`
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Specification of the desired behavior of the Deployment.
- Spec DeploymentSpec `json:"spec,omitempty"`
+ Spec DeploymentSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Most recently observed status of the Deployment.
- Status DeploymentStatus `json:"status,omitempty"`
+ Status DeploymentStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// DeploymentSpec is the specification of the desired behavior of the Deployment.
type DeploymentSpec struct {
// Number of desired pods. This is a pointer to distinguish between explicit
// zero and not specified. Defaults to 1.
- Replicas *int32 `json:"replicas,omitempty"`
+ Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
// Label selector for pods. Existing ReplicaSets whose pods are
// selected by this will be the ones affected by this deployment.
- Selector *LabelSelector `json:"selector,omitempty"`
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,2,opt,name=selector"`
// Template describes the pods that will be created.
- Template v1.PodTemplateSpec `json:"template"`
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,3,opt,name=template"`
// The deployment strategy to use to replace existing pods with new ones.
- Strategy DeploymentStrategy `json:"strategy,omitempty"`
+ Strategy DeploymentStrategy `json:"strategy,omitempty" protobuf:"bytes,4,opt,name=strategy"`
// 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)
- MinReadySeconds int32 `json:"minReadySeconds,omitempty"`
+ MinReadySeconds int32 `json:"minReadySeconds,omitempty" protobuf:"varint,5,opt,name=minReadySeconds"`
// The number of old ReplicaSets to retain to allow rollback.
// This is a pointer to distinguish between explicit zero and not specified.
- RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"`
+ RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty" protobuf:"varint,6,opt,name=revisionHistoryLimit"`
// Indicates that the deployment is paused and will not be processed by the
// deployment controller.
- Paused bool `json:"paused,omitempty"`
+ Paused bool `json:"paused,omitempty" protobuf:"varint,7,opt,name=paused"`
// The config this deployment is rolling back to. Will be cleared after rollback is done.
- RollbackTo *RollbackConfig `json:"rollbackTo,omitempty"`
+ RollbackTo *RollbackConfig `json:"rollbackTo,omitempty" protobuf:"bytes,8,opt,name=rollbackTo"`
}
// DeploymentRollback stores the information required to rollback a deployment.
type DeploymentRollback struct {
unversioned.TypeMeta `json:",inline"`
// Required: This must match the Name of a deployment.
- Name string `json:"name"`
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
// The annotations to be updated to a deployment
- UpdatedAnnotations map[string]string `json:"updatedAnnotations,omitempty"`
+ UpdatedAnnotations map[string]string `json:"updatedAnnotations,omitempty" protobuf:"bytes,2,rep,name=updatedAnnotations"`
// The config of this deployment rollback.
- RollbackTo RollbackConfig `json:"rollbackTo"`
+ RollbackTo RollbackConfig `json:"rollbackTo" protobuf:"bytes,3,opt,name=rollbackTo"`
}
type RollbackConfig struct {
// The revision to rollback to. If set to 0, rollbck to the last revision.
- Revision int64 `json:"revision,omitempty"`
+ Revision int64 `json:"revision,omitempty" protobuf:"varint,1,opt,name=revision"`
}
const (
@@ -286,14 +283,14 @@ const (
// DeploymentStrategy describes how to replace existing pods with new ones.
type DeploymentStrategy struct {
// Type of deployment. Can be "Recreate" or "RollingUpdate". Default is RollingUpdate.
- Type DeploymentStrategyType `json:"type,omitempty"`
+ Type DeploymentStrategyType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type,casttype=DeploymentStrategyType"`
// Rolling update config params. Present only if DeploymentStrategyType =
// RollingUpdate.
//---
// TODO: Update this to follow our convention for oneOf, whatever we decide it
// to be.
- RollingUpdate *RollingUpdateDeployment `json:"rollingUpdate,omitempty"`
+ RollingUpdate *RollingUpdateDeployment `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"`
}
type DeploymentStrategyType string
@@ -318,7 +315,7 @@ type RollingUpdateDeployment struct {
// can be scaled down further, followed by scaling up the new RC, ensuring
// that the total number of pods available at all times during the update is at
// least 70% of desired pods.
- MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty"`
+ MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,1,opt,name=maxUnavailable"`
// The maximum number of pods that can be scheduled above the desired number of
// pods.
@@ -331,35 +328,35 @@ type RollingUpdateDeployment struct {
// 130% of desired pods. Once old pods have been killed,
// new RC can be scaled up further, ensuring that total number of pods running
// at any time during the update is atmost 130% of desired pods.
- MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty"`
+ MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,2,opt,name=maxSurge"`
}
// DeploymentStatus is the most recently observed status of the Deployment.
type DeploymentStatus struct {
// The generation observed by the deployment controller.
- ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+ ObservedGeneration int64 `json:"observedGeneration,omitempty" protobuf:"varint,1,opt,name=observedGeneration"`
// Total number of non-terminated pods targeted by this deployment (their labels match the selector).
- Replicas int32 `json:"replicas,omitempty"`
+ Replicas int32 `json:"replicas,omitempty" protobuf:"varint,2,opt,name=replicas"`
// Total number of non-terminated pods targeted by this deployment that have the desired template spec.
- UpdatedReplicas int32 `json:"updatedReplicas,omitempty"`
+ UpdatedReplicas int32 `json:"updatedReplicas,omitempty" protobuf:"varint,3,opt,name=updatedReplicas"`
// Total number of available pods (ready for at least minReadySeconds) targeted by this deployment.
- AvailableReplicas int32 `json:"availableReplicas,omitempty"`
+ AvailableReplicas int32 `json:"availableReplicas,omitempty" protobuf:"varint,4,opt,name=availableReplicas"`
// Total number of unavailable pods targeted by this deployment.
- UnavailableReplicas int32 `json:"unavailableReplicas,omitempty"`
+ UnavailableReplicas int32 `json:"unavailableReplicas,omitempty" protobuf:"varint,5,opt,name=unavailableReplicas"`
}
// DeploymentList is a list of Deployments.
type DeploymentList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- unversioned.ListMeta `json:"metadata,omitempty"`
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of Deployments.
- Items []Deployment `json:"items"`
+ Items []Deployment `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// TODO(madhusudancs): Uncomment while implementing DaemonSet updates.
@@ -413,15 +410,15 @@ type DaemonSetSpec struct {
// Selector is a label query over pods that are managed by the daemon set.
// Must match in order to be controlled.
// If empty, defaulted to labels on Pod template.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector *LabelSelector `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,1,opt,name=selector"`
// Template is the 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: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template
- Template v1.PodTemplateSpec `json:"template"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,2,opt,name=template"`
// TODO(madhusudancs): Uncomment while implementing DaemonSet updates.
/* Commenting out for v1.2. We are planning to bring these fields back with a more robust DaemonSet update implementation in v1.3, hence not deleting but just commenting these fields out.
@@ -450,18 +447,18 @@ const (
type DaemonSetStatus struct {
// CurrentNumberScheduled is the number of nodes that are running at least 1
// daemon pod and are supposed to run the daemon pod.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md
- CurrentNumberScheduled int32 `json:"currentNumberScheduled"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ CurrentNumberScheduled int32 `json:"currentNumberScheduled" protobuf:"varint,1,opt,name=currentNumberScheduled"`
// NumberMisscheduled is the number of nodes that are running the daemon pod, but are
// not supposed to run the daemon pod.
- // More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md
- NumberMisscheduled int32 `json:"numberMisscheduled"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ NumberMisscheduled int32 `json:"numberMisscheduled" protobuf:"varint,2,opt,name=numberMisscheduled"`
// DesiredNumberScheduled is the total number of nodes that should be running the daemon
// pod (including nodes correctly running the daemon pod).
- // More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md
- DesiredNumberScheduled int32 `json:"desiredNumberScheduled"`
+ // More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md
+ DesiredNumberScheduled int32 `json:"desiredNumberScheduled" protobuf:"varint,3,opt,name=desiredNumberScheduled"`
}
// +genclient=true
@@ -470,41 +467,41 @@ type DaemonSetStatus struct {
type DaemonSet struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the desired behavior of this daemon set.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec DaemonSetSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec DaemonSetSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status is 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status DaemonSetStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status DaemonSetStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// DaemonSetList is a collection of daemon sets.
type DaemonSetList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is a list of daemon sets.
- Items []DaemonSet `json:"items"`
+ Items []DaemonSet `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// ThirdPartyResrouceDataList is a list of ThirdPartyResourceData.
type ThirdPartyResourceDataList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of ThirdpartyResourceData.
- Items []ThirdPartyResourceData `json:"items"`
+ Items []ThirdPartyResourceData `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// +genclient=true
@@ -513,27 +510,27 @@ type ThirdPartyResourceDataList struct {
type Job struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec is a structure defining the expected behavior of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec JobSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec JobSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status is a structure describing current status of a job.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status JobStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status JobStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// JobList is a collection of jobs.
type JobList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of Job.
- Items []Job `json:"items"`
+ Items []Job `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// JobSpec describes how the job execution will look like.
@@ -543,64 +540,64 @@ type JobSpec struct {
// 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Parallelism *int32 `json:"parallelism,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Parallelism *int32 `json:"parallelism,omitempty" protobuf:"varint,1,opt,name=parallelism"`
// Completions 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Completions *int32 `json:"completions,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Completions *int32 `json:"completions,omitempty" protobuf:"varint,2,opt,name=completions"`
// Optional duration in seconds relative to the startTime that the job may be active
// before the system tries to terminate it; value must be positive integer
- ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty"`
+ ActiveDeadlineSeconds *int64 `json:"activeDeadlineSeconds,omitempty" protobuf:"varint,3,opt,name=activeDeadlineSeconds"`
// Selector is a label query over pods that should match the pod count.
// Normally, the system sets this field for you.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector *LabelSelector `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,4,opt,name=selector"`
// AutoSelector controls generation of pod labels and pod selectors.
// It was not present in the original extensions/v1beta1 Job definition, but exists
// to allow conversion from batch/v1 Jobs, where it corresponds to, but has the opposite
// meaning as, ManualSelector.
- // More info: http://releases.k8s.io/release-1.2/docs/design/selector-generation.md
- AutoSelector *bool `json:"autoSelector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md
+ AutoSelector *bool `json:"autoSelector,omitempty" protobuf:"varint,5,opt,name=autoSelector"`
// Template is the object that describes the pod that will be created when
// executing a job.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Template v1.PodTemplateSpec `json:"template"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Template v1.PodTemplateSpec `json:"template" protobuf:"bytes,6,opt,name=template"`
}
// JobStatus represents the current state of a Job.
type JobStatus struct {
// Conditions represent the latest available observations of an object's current state.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md
- Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md
+ Conditions []JobCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
// StartTime represents time when the job was acknowledged by the Job Manager.
// It is not guaranteed to be set in happens-before order across separate operations.
// It is represented in RFC3339 form and is in UTC.
- StartTime *unversioned.Time `json:"startTime,omitempty"`
+ StartTime *unversioned.Time `json:"startTime,omitempty" protobuf:"bytes,2,opt,name=startTime"`
// CompletionTime 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.
- CompletionTime *unversioned.Time `json:"completionTime,omitempty"`
+ CompletionTime *unversioned.Time `json:"completionTime,omitempty" protobuf:"bytes,3,opt,name=completionTime"`
// Active is the number of actively running pods.
- Active int32 `json:"active,omitempty"`
+ Active int32 `json:"active,omitempty" protobuf:"varint,4,opt,name=active"`
// Succeeded is the number of pods which reached Phase Succeeded.
- Succeeded int32 `json:"succeeded,omitempty"`
+ Succeeded int32 `json:"succeeded,omitempty" protobuf:"varint,5,opt,name=succeeded"`
// Failed is the number of pods which reached Phase Failed.
- Failed int32 `json:"failed,omitempty"`
+ Failed int32 `json:"failed,omitempty" protobuf:"varint,6,opt,name=failed"`
}
type JobConditionType string
@@ -616,17 +613,17 @@ const (
// JobCondition describes current state of a job.
type JobCondition struct {
// Type of job condition, Complete or Failed.
- Type JobConditionType `json:"type"`
+ Type JobConditionType `json:"type" protobuf:"bytes,1,opt,name=type,casttype=JobConditionType"`
// Status of the condition, one of True, False, Unknown.
- Status v1.ConditionStatus `json:"status"`
+ Status v1.ConditionStatus `json:"status" protobuf:"bytes,2,opt,name=status,casttype=k8s.io/kubernetes/pkg/api/v1.ConditionStatus"`
// Last time the condition was checked.
- LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty"`
+ LastProbeTime unversioned.Time `json:"lastProbeTime,omitempty" protobuf:"bytes,3,opt,name=lastProbeTime"`
// Last time the condition transit from one status to another.
- LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty"`
+ LastTransitionTime unversioned.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
// (brief) reason for the condition's last transition.
- Reason string `json:"reason,omitempty"`
+ Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
// Human readable message indicating details about last transition.
- Message string `json:"message,omitempty"`
+ Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`
}
// +genclient=true
@@ -638,27 +635,27 @@ type JobCondition struct {
type Ingress struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec is the desired state of the Ingress.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec IngressSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec IngressSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// Status is the current state of the Ingress.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status IngressStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status IngressStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// IngressList is a collection of Ingress.
type IngressList struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is the list of Ingress.
- Items []Ingress `json:"items"`
+ Items []Ingress `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// IngressSpec describes the Ingress the user wishes to exist.
@@ -667,18 +664,18 @@ type IngressSpec struct {
// rule. At least one of 'backend' or 'rules' must be specified. This field
// is optional to allow the loadbalancer controller or defaulting logic to
// specify a global default.
- Backend *IngressBackend `json:"backend,omitempty"`
+ Backend *IngressBackend `json:"backend,omitempty" protobuf:"bytes,1,opt,name=backend"`
// 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.
- TLS []IngressTLS `json:"tls,omitempty"`
+ TLS []IngressTLS `json:"tls,omitempty" protobuf:"bytes,2,rep,name=tls"`
// A list of host rules used to configure the Ingress. If unspecified, or
// no rule matches, all traffic is sent to the default backend.
- Rules []IngressRule `json:"rules,omitempty"`
+ Rules []IngressRule `json:"rules,omitempty" protobuf:"bytes,3,rep,name=rules"`
// TODO: Add the ability to specify load-balancer IP through claims
}
@@ -688,20 +685,20 @@ type IngressTLS struct {
// 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.
- Hosts []string `json:"hosts,omitempty"`
+ Hosts []string `json:"hosts,omitempty" protobuf:"bytes,1,rep,name=hosts"`
// SecretName is the name of the secret used to terminate SSL traffic on 443.
// Field is left optional to allow SSL 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.
- SecretName string `json:"secretName,omitempty"`
+ SecretName string `json:"secretName,omitempty" protobuf:"bytes,2,opt,name=secretName"`
// TODO: Consider specifying different modes of termination, protocols etc.
}
// IngressStatus describe the current state of the Ingress.
type IngressStatus struct {
// LoadBalancer contains the current status of the load-balancer.
- LoadBalancer v1.LoadBalancerStatus `json:"loadBalancer,omitempty"`
+ LoadBalancer v1.LoadBalancerStatus `json:"loadBalancer,omitempty" protobuf:"bytes,1,opt,name=loadBalancer"`
}
// IngressRule represents the rules mapping the paths under a specified host to
@@ -720,13 +717,13 @@ type IngressRule struct {
// 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 string `json:"host,omitempty"`
+ Host string `json:"host,omitempty" protobuf:"bytes,1,opt,name=host"`
// IngressRuleValue represents a rule to route requests for this IngressRule.
// If unspecified, the rule defaults to a http catch-all. Whether that sends
// just traffic matching the host to the default backend or all traffic to the
// default backend, is left to the controller fulfilling the Ingress. Http is
// currently the only supported IngressRuleValue.
- IngressRuleValue `json:",inline,omitempty"`
+ IngressRuleValue `json:",inline,omitempty" protobuf:"bytes,2,opt,name=ingressRuleValue"`
}
// IngressRuleValue represents a rule to apply against incoming requests. If the
@@ -740,7 +737,7 @@ type IngressRuleValue struct {
// 2. Consider adding fields for ingress-type specific global options
// usable by a loadbalancer, like http keep-alive.
- HTTP *HTTPIngressRuleValue `json:"http,omitempty"`
+ HTTP *HTTPIngressRuleValue `json:"http,omitempty" protobuf:"bytes,1,opt,name=http"`
}
// HTTPIngressRuleValue is a list of http selectors pointing to backends.
@@ -750,7 +747,7 @@ type IngressRuleValue struct {
// or '#'.
type HTTPIngressRuleValue struct {
// A collection of paths that map requests to backends.
- Paths []HTTPIngressPath `json:"paths"`
+ Paths []HTTPIngressPath `json:"paths" protobuf:"bytes,1,rep,name=paths"`
// TODO: Consider adding fields for ingress-type specific global
// options usable by a loadbalancer, like http keep-alive.
}
@@ -765,29 +762,29 @@ type HTTPIngressPath struct {
// part of a URL as defined by RFC 3986. Paths must begin with
// a '/'. If unspecified, the path defaults to a catch all sending
// traffic to the backend.
- Path string `json:"path,omitempty"`
+ Path string `json:"path,omitempty" protobuf:"bytes,1,opt,name=path"`
// Backend defines the referenced service endpoint to which the traffic
// will be forwarded to.
- Backend IngressBackend `json:"backend"`
+ Backend IngressBackend `json:"backend" protobuf:"bytes,2,opt,name=backend"`
}
// IngressBackend describes all endpoints for a given service and port.
type IngressBackend struct {
// Specifies the name of the referenced service.
- ServiceName string `json:"serviceName"`
+ ServiceName string `json:"serviceName" protobuf:"bytes,1,opt,name=serviceName"`
// Specifies the port of the referenced service.
- ServicePort intstr.IntOrString `json:"servicePort"`
+ ServicePort intstr.IntOrString `json:"servicePort" protobuf:"bytes,2,opt,name=servicePort"`
}
// ExportOptions is the query options to the standard REST get call.
type ExportOptions struct {
unversioned.TypeMeta `json:",inline"`
// Should this value be exported. Export strips fields that a user can not specify.
- Export bool `json:"export"`
+ Export bool `json:"export" protobuf:"varint,1,opt,name=export"`
// Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'
- Exact bool `json:"exact"`
+ Exact bool `json:"exact" protobuf:"varint,2,opt,name=exact"`
}
// ListOptions is the query options to a standard REST list call.
@@ -796,18 +793,18 @@ type ListOptions struct {
// A selector to restrict the list of returned objects by their labels.
// Defaults to everything.
- LabelSelector string `json:"labelSelector,omitempty"`
+ LabelSelector string `json:"labelSelector,omitempty" protobuf:"bytes,1,opt,name=labelSelector"`
// A selector to restrict the list of returned objects by their fields.
// Defaults to everything.
- FieldSelector string `json:"fieldSelector,omitempty"`
+ FieldSelector string `json:"fieldSelector,omitempty" protobuf:"bytes,2,opt,name=fieldSelector"`
// Watch for changes to the described resources and return them as a stream of
// add, update, and remove notifications. Specify resourceVersion.
- Watch bool `json:"watch,omitempty"`
+ Watch bool `json:"watch,omitempty" protobuf:"varint,3,opt,name=watch"`
// When specified with a watch call, shows changes that occur after that particular version of a resource.
// Defaults to changes from the beginning of history.
- ResourceVersion string `json:"resourceVersion,omitempty"`
+ ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,4,opt,name=resourceVersion"`
// Timeout for the list/watch call.
- TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty"`
+ TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" protobuf:"varint,5,opt,name=timeoutSeconds"`
}
// A label selector is a label query over a set of resources. The result of matchLabels and
@@ -817,24 +814,24 @@ type LabelSelector struct {
// 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.
- MatchLabels map[string]string `json:"matchLabels,omitempty"`
+ MatchLabels map[string]string `json:"matchLabels,omitempty" protobuf:"bytes,1,rep,name=matchLabels"`
// matchExpressions is a list of label selector requirements. The requirements are ANDed.
- MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty"`
+ MatchExpressions []LabelSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,2,rep,name=matchExpressions"`
}
// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type LabelSelectorRequirement struct {
// key is the label key that the selector applies to.
- Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key"`
+ Key string `json:"key" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,1,opt,name=key"`
// operator represents a key's relationship to a set of values.
// Valid operators ard In, NotIn, Exists and DoesNotExist.
- Operator LabelSelectorOperator `json:"operator"`
+ Operator LabelSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=LabelSelectorOperator"`
// 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.
- Values []string `json:"values,omitempty"`
+ Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
}
// A label selector operator is the set of operators that can be used in a selector requirement.
@@ -855,31 +852,31 @@ type ReplicaSet struct {
// 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Spec defines the specification of the desired behavior of the ReplicaSet.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Spec ReplicaSetSpec `json:"spec,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Spec ReplicaSetSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
// 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status
- Status ReplicaSetStatus `json:"status,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status
+ Status ReplicaSetStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}
// ReplicaSetList is a collection of ReplicaSets.
type ReplicaSetList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// List of ReplicaSets.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md
- Items []ReplicaSet `json:"items"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md
+ Items []ReplicaSet `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// ReplicaSetSpec is the specification of a ReplicaSet.
@@ -887,73 +884,97 @@ type ReplicaSetSpec struct {
// Replicas is the number of desired replicas.
// This is a pointer to distinguish between explicit zero and unspecified.
// Defaults to 1.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller
- Replicas *int32 `json:"replicas,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ Replicas *int32 `json:"replicas,omitempty" protobuf:"varint,1,opt,name=replicas"`
// Selector is a label query over pods that should match the replica count.
// If the 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 replica set.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors
- Selector *LabelSelector `json:"selector,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors
+ Selector *LabelSelector `json:"selector,omitempty" protobuf:"bytes,2,opt,name=selector"`
// Template is the object that describes the pod that will be created if
// insufficient replicas are detected.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template
- Template v1.PodTemplateSpec `json:"template,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template
+ Template v1.PodTemplateSpec `json:"template,omitempty" protobuf:"bytes,3,opt,name=template"`
}
// ReplicaSetStatus represents the current status of a ReplicaSet.
type ReplicaSetStatus struct {
// Replicas is the most recently oberved number of replicas.
- // More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller
- Replicas int32 `json:"replicas"`
+ // More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller
+ Replicas int32 `json:"replicas" protobuf:"varint,1,opt,name=replicas"`
// The number of pods that have labels matching the labels of the pod template of the replicaset.
- FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`
+ FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty" protobuf:"varint,2,opt,name=fullyLabeledReplicas"`
// ObservedGeneration reflects the generation of the most recently observed ReplicaSet.
- ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+ ObservedGeneration int64 `json:"observedGeneration,omitempty" protobuf:"varint,3,opt,name=observedGeneration"`
}
+// +genclient=true,nonNamespaced=true
+
// Pod Security Policy governs the ability to make requests that affect the Security Context
// that will be applied to a pod and container.
type PodSecurityPolicy struct {
unversioned.TypeMeta `json:",inline"`
// Standard object's metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- v1.ObjectMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// spec defines the policy enforced.
- Spec PodSecurityPolicySpec `json:"spec,omitempty"`
+ Spec PodSecurityPolicySpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
}
// Pod Security Policy Spec defines the policy enforced.
type PodSecurityPolicySpec struct {
// privileged determines if a pod can request to be run as privileged.
- Privileged bool `json:"privileged,omitempty"`
- // capabilities is a list of capabilities that can be added.
- Capabilities []v1.Capability `json:"capabilities,omitempty"`
+ Privileged bool `json:"privileged,omitempty" protobuf:"varint,1,opt,name=privileged"`
+ // 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 capabiility in both
+ // DefaultAddCapabilities and RequiredDropCapabilities.
+ DefaultAddCapabilities []v1.Capability `json:"defaultAddCapabilities,omitempty" protobuf:"bytes,2,rep,name=defaultAddCapabilities,casttype=k8s.io/kubernetes/pkg/api/v1.Capability"`
+ // RequiredDropCapabilities are the capabilities that will be dropped from the container. These
+ // are required to be dropped and cannot be added.
+ RequiredDropCapabilities []v1.Capability `json:"requiredDropCapabilities,omitempty" protobuf:"bytes,3,rep,name=requiredDropCapabilities,casttype=k8s.io/kubernetes/pkg/api/v1.Capability"`
+ // 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.
+ AllowedCapabilities []v1.Capability `json:"allowedCapabilities,omitempty" protobuf:"bytes,4,rep,name=allowedCapabilities,casttype=k8s.io/kubernetes/pkg/api/v1.Capability"`
// volumes is a white list of allowed volume plugins. Empty indicates that all plugins
// may be used.
- Volumes []FSType `json:"volumes,omitempty"`
+ Volumes []FSType `json:"volumes,omitempty" protobuf:"bytes,5,rep,name=volumes,casttype=FSType"`
// hostNetwork determines if the policy allows the use of HostNetwork in the pod spec.
- HostNetwork bool `json:"hostNetwork,omitempty"`
+ HostNetwork bool `json:"hostNetwork,omitempty" protobuf:"varint,6,opt,name=hostNetwork"`
// hostPorts determines which host port ranges are allowed to be exposed.
- HostPorts []HostPortRange `json:"hostPorts,omitempty"`
+ HostPorts []HostPortRange `json:"hostPorts,omitempty" protobuf:"bytes,7,rep,name=hostPorts"`
// hostPID determines if the policy allows the use of HostPID in the pod spec.
- HostPID bool `json:"hostPID,omitempty"`
+ HostPID bool `json:"hostPID,omitempty" protobuf:"varint,8,opt,name=hostPID"`
// hostIPC determines if the policy allows the use of HostIPC in the pod spec.
- HostIPC bool `json:"hostIPC,omitempty"`
+ HostIPC bool `json:"hostIPC,omitempty" protobuf:"varint,9,opt,name=hostIPC"`
// seLinux is the strategy that will dictate the allowable labels that may be set.
- SELinux SELinuxStrategyOptions `json:"seLinux,omitempty"`
+ SELinux SELinuxStrategyOptions `json:"seLinux" protobuf:"bytes,10,opt,name=seLinux"`
// runAsUser is the strategy that will dictate the allowable RunAsUser values that may be set.
- RunAsUser RunAsUserStrategyOptions `json:"runAsUser,omitempty"`
+ RunAsUser RunAsUserStrategyOptions `json:"runAsUser" protobuf:"bytes,11,opt,name=runAsUser"`
+ // SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext.
+ SupplementalGroups SupplementalGroupsStrategyOptions `json:"supplementalGroups" protobuf:"bytes,12,opt,name=supplementalGroups"`
+ // FSGroup is the strategy that will dictate what fs group is used by the SecurityContext.
+ FSGroup FSGroupStrategyOptions `json:"fsGroup" protobuf:"bytes,13,opt,name=fsGroup"`
+ // 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.
+ ReadOnlyRootFilesystem bool `json:"readOnlyRootFilesystem,omitempty" protobuf:"varint,14,opt,name=readOnlyRootFilesystem"`
}
// FS Type gives strong typing to different file systems that are used by volumes.
type FSType string
var (
+ AzureFile FSType = "azureFile"
+ Flocker FSType = "flocker"
+ FlexVolume FSType = "flexVolume"
HostPath FSType = "hostPath"
EmptyDir FSType = "emptyDir"
GCEPersistentDisk FSType = "gcePersistentDisk"
@@ -969,24 +990,26 @@ var (
CephFS FSType = "cephFS"
DownwardAPI FSType = "downwardAPI"
FC FSType = "fc"
+ ConfigMap FSType = "configMap"
+ All FSType = "*"
)
// Host Port Range 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.
type HostPortRange struct {
// min is the start of the range, inclusive.
- Min int32 `json:"min"`
+ Min int32 `json:"min" protobuf:"varint,1,opt,name=min"`
// max is the end of the range, inclusive.
- Max int32 `json:"max"`
+ Max int32 `json:"max" protobuf:"varint,2,opt,name=max"`
}
// SELinux Strategy Options defines the strategy type and any options used to create the strategy.
type SELinuxStrategyOptions struct {
// type is the strategy that will dictate the allowable labels that may be set.
- Rule SELinuxStrategy `json:"rule"`
+ Rule SELinuxStrategy `json:"rule" protobuf:"bytes,1,opt,name=rule,casttype=SELinuxStrategy"`
// seLinuxOptions required to run as; required for MustRunAs
- // More info: http://releases.k8s.io/release-1.2/docs/design/security_context.md#security-context
- SELinuxOptions *v1.SELinuxOptions `json:"seLinuxOptions,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md#security-context
+ SELinuxOptions *v1.SELinuxOptions `json:"seLinuxOptions,omitempty" protobuf:"bytes,2,opt,name=seLinuxOptions"`
}
// SELinuxStrategy denotes strategy types for generating SELinux options for a
@@ -1003,17 +1026,17 @@ const (
// Run A sUser Strategy Options defines the strategy type and any options used to create the strategy.
type RunAsUserStrategyOptions struct {
// Rule is the strategy that will dictate the allowable RunAsUser values that may be set.
- Rule RunAsUserStrategy `json:"rule"`
+ Rule RunAsUserStrategy `json:"rule" protobuf:"bytes,1,opt,name=rule,casttype=RunAsUserStrategy"`
// Ranges are the allowed ranges of uids that may be used.
- Ranges []IDRange `json:"ranges,omitempty"`
+ Ranges []IDRange `json:"ranges,omitempty" protobuf:"bytes,2,rep,name=ranges"`
}
// ID Range provides a min/max of an allowed range of IDs.
type IDRange struct {
// Min is the start of the range, inclusive.
- Min int64 `json:"min"`
+ Min int64 `json:"min" protobuf:"varint,1,opt,name=min"`
// Max is the end of the range, inclusive.
- Max int64 `json:"max"`
+ Max int64 `json:"max" protobuf:"varint,2,opt,name=max"`
}
// RunAsUserStrategy denotes strategy types for generating RunAsUser values for a
@@ -1029,13 +1052,144 @@ const (
RunAsUserStrategyRunAsAny RunAsUserStrategy = "RunAsAny"
)
+// FSGroupStrategyOptions defines the strategy type and options used to create the strategy.
+type FSGroupStrategyOptions struct {
+ // Rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
+ Rule FSGroupStrategyType `json:"rule,omitempty" protobuf:"bytes,1,opt,name=rule,casttype=FSGroupStrategyType"`
+ // 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.
+ Ranges []IDRange `json:"ranges,omitempty" protobuf:"bytes,2,rep,name=ranges"`
+}
+
+// FSGroupStrategyType denotes strategy types for generating FSGroup values for a
+// SecurityContext
+type FSGroupStrategyType string
+
+const (
+ // container must have FSGroup of X applied.
+ FSGroupStrategyMustRunAs FSGroupStrategyType = "MustRunAs"
+ // container may make requests for any FSGroup labels.
+ FSGroupStrategyRunAsAny FSGroupStrategyType = "RunAsAny"
+)
+
+// SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy.
+type SupplementalGroupsStrategyOptions struct {
+ // Rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
+ Rule SupplementalGroupsStrategyType `json:"rule,omitempty" protobuf:"bytes,1,opt,name=rule,casttype=SupplementalGroupsStrategyType"`
+ // 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.
+ Ranges []IDRange `json:"ranges,omitempty" protobuf:"bytes,2,rep,name=ranges"`
+}
+
+// SupplementalGroupsStrategyType denotes strategy types for determining valid supplemental
+// groups for a SecurityContext.
+type SupplementalGroupsStrategyType string
+
+const (
+ // container must run as a particular gid.
+ SupplementalGroupsStrategyMustRunAs SupplementalGroupsStrategyType = "MustRunAs"
+ // container may make requests for any gid.
+ SupplementalGroupsStrategyRunAsAny SupplementalGroupsStrategyType = "RunAsAny"
+)
+
// Pod Security Policy List is a list of PodSecurityPolicy objects.
type PodSecurityPolicyList struct {
unversioned.TypeMeta `json:",inline"`
// Standard list metadata.
- // More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata
- unversioned.ListMeta `json:"metadata,omitempty"`
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is a list of schema objects.
+ Items []PodSecurityPolicy `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+type NetworkPolicy struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Specification of the desired behavior for this NetworkPolicy.
+ Spec NetworkPolicySpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+}
+
+type NetworkPolicySpec struct {
+ // 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.
+ PodSelector LabelSelector `json:"podSelector" protobuf:"bytes,1,opt,name=podSelector"`
+
+ // List of ingress rules to be applied to the selected pods.
+ // Traffic is allowed to a pod if namespace.networkPolicy.ingress.isolation is undefined and cluster policy allows it,
+ // 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 affect ingress isolation.
+ // If this field is present and contains at least one rule, this policy allows any traffic
+ // which matches at least one of the ingress rules in this list.
+ Ingress []NetworkPolicyIngressRule `json:"ingress,omitempty" protobuf:"bytes,2,rep,name=ingress"`
+}
+
+// This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from.
+type NetworkPolicyIngressRule struct {
+ // 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 not provided, this rule matches all ports (traffic not restricted by port).
+ // If this field is empty, this rule matches no ports (no traffic matches).
+ // 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.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ Ports []NetworkPolicyPort `json:"ports,omitempty" protobuf:"bytes,1,rep,name=ports"`
+
+ // 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 not provided, this rule matches all sources (traffic not restricted by source).
+ // If this field is empty, this rule matches no sources (no traffic matches).
+ // If this field is present and contains at least on item, this rule allows traffic only if the
+ // traffic matches at least one item in the from list.
+ // TODO: Update this to be a pointer to slice as soon as auto-generation supports it.
+ From []NetworkPolicyPeer `json:"from,omitempty" protobuf:"bytes,2,rep,name=from"`
+}
+
+type NetworkPolicyPort struct {
+ // Optional. The protocol (TCP or UDP) which traffic must match.
+ // If not specified, this field defaults to TCP.
+ Protocol *v1.Protocol `json:"protocol,omitempty" protobuf:"bytes,1,opt,name=protocol,casttype=k8s.io/kubernetes/pkg/api/v1.Protocol"`
+
+ // If specified, 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.
+ Port *intstr.IntOrString `json:"port,omitempty" protobuf:"bytes,2,opt,name=port"`
+}
+
+type NetworkPolicyPeer struct {
+ // Exactly one of the following must be specified.
+
+ // This is a label selector which selects Pods in this namespace.
+ // This field follows standard label selector semantics.
+ // If not provided, this selector selects no pods.
+ // If present but empty, this selector selects all pods in this namespace.
+ PodSelector *LabelSelector `json:"podSelector,omitempty" protobuf:"bytes,1,opt,name=podSelector"`
+
+ // Selects Namespaces using cluster scoped-labels. This
+ // matches all pods in all namespaces selected by this label selector.
+ // This field follows standard label selector semantics.
+ // If omitted, this selector selects no namespaces.
+ // If present but empty, this selector selects all namespaces.
+ NamespaceSelector *LabelSelector `json:"namespaceSelector,omitempty" protobuf:"bytes,2,opt,name=namespaceSelector"`
+}
+
+// Network Policy List is a list of NetworkPolicy objects.
+type NetworkPolicyList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard list metadata.
+ // More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
// Items is a list of schema objects.
- Items []PodSecurityPolicy `json:"items"`
+ Items []NetworkPolicy `json:"items" protobuf:"bytes,2,rep,name=items"`
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go
similarity index 76%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go
rename to vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go
index 8780d7ad4871f8bc0ad727182262d812868b8c7b..1864a965828d49ca1cc3f0be4c2c1b5f88c40f89 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/v1beta1/types_swagger_doc_generated.go
@@ -1,5 +1,5 @@
/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
+Copyright 2016 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -28,9 +28,8 @@ package v1beta1
// AUTO-GENERATED FUNCTIONS START HERE
var map_APIVersion = map[string]string{
- "": "An APIVersion represents a single concrete version of an object model.",
- "name": "Name of this version (e.g. 'v1').",
- "apiGroup": "The API group to add this object into, default 'experimental'.",
+ "": "An APIVersion represents a single concrete version of an object model.",
+ "name": "Name of this version (e.g. 'v1').",
}
func (APIVersion) SwaggerDoc() map[string]string {
@@ -66,9 +65,9 @@ func (CustomMetricTarget) SwaggerDoc() map[string]string {
var map_DaemonSet = map[string]string{
"": "DaemonSet represents the configuration of a daemon set.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the desired behavior of this daemon set. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status is 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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the desired behavior of this daemon set. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is 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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (DaemonSet) SwaggerDoc() map[string]string {
@@ -77,7 +76,7 @@ func (DaemonSet) SwaggerDoc() map[string]string {
var map_DaemonSetList = map[string]string{
"": "DaemonSetList is a collection of daemon sets.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is a list of daemon sets.",
}
@@ -87,8 +86,8 @@ func (DaemonSetList) SwaggerDoc() map[string]string {
var map_DaemonSetSpec = map[string]string{
"": "DaemonSetSpec is the specification of a daemon set.",
- "selector": "Selector is a label query over pods that are managed by the daemon set. Must match in order to be controlled. If empty, defaulted to labels on Pod template. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "template": "Template is the 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: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template",
+ "selector": "Selector is a label query over pods that are managed by the daemon set. Must match in order to be controlled. If empty, defaulted to labels on Pod template. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "template": "Template is the 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: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template",
}
func (DaemonSetSpec) SwaggerDoc() map[string]string {
@@ -97,9 +96,9 @@ func (DaemonSetSpec) SwaggerDoc() map[string]string {
var map_DaemonSetStatus = map[string]string{
"": "DaemonSetStatus represents the current status of a daemon set.",
- "currentNumberScheduled": "CurrentNumberScheduled is the number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md",
- "numberMisscheduled": "NumberMisscheduled is the number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md",
- "desiredNumberScheduled": "DesiredNumberScheduled is the total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: http://releases.k8s.io/release-1.2/docs/admin/daemons.md",
+ "currentNumberScheduled": "CurrentNumberScheduled is the number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md",
+ "numberMisscheduled": "NumberMisscheduled is the number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md",
+ "desiredNumberScheduled": "DesiredNumberScheduled is the total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: http://releases.k8s.io/release-1.3/docs/admin/daemons.md",
}
func (DaemonSetStatus) SwaggerDoc() map[string]string {
@@ -187,6 +186,16 @@ func (ExportOptions) SwaggerDoc() map[string]string {
return map_ExportOptions
}
+var map_FSGroupStrategyOptions = map[string]string{
+ "": "FSGroupStrategyOptions defines the strategy type and options used to create the strategy.",
+ "rule": "Rule is the strategy that will dictate what FSGroup is used in the SecurityContext.",
+ "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.",
+}
+
+func (FSGroupStrategyOptions) SwaggerDoc() map[string]string {
+ return map_FSGroupStrategyOptions
+}
+
var map_HTTPIngressPath = map[string]string{
"": "HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend.",
"path": "Path is a extended POSIX regex as defined by IEEE Std 1003.1, (i.e this follows the egrep/unix syntax, not the perl syntax) 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 '/'. If unspecified, the path defaults to a catch all sending traffic to the backend.",
@@ -208,8 +217,8 @@ func (HTTPIngressRuleValue) SwaggerDoc() map[string]string {
var map_HorizontalPodAutoscaler = map[string]string{
"": "configuration of a horizontal pod autoscaler.",
- "metadata": "Standard object metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "behaviour of autoscaler. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.",
+ "metadata": "Standard object metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "behaviour of autoscaler. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.",
"status": "current information about the autoscaler.",
}
@@ -274,9 +283,9 @@ func (IDRange) SwaggerDoc() map[string]string {
var map_Ingress = map[string]string{
"": "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.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec is the desired state of the Ingress. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status is the current state of the Ingress. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec is the desired state of the Ingress. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is the current state of the Ingress. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Ingress) SwaggerDoc() map[string]string {
@@ -295,7 +304,7 @@ func (IngressBackend) SwaggerDoc() map[string]string {
var map_IngressList = map[string]string{
"": "IngressList is a collection of Ingress.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is the list of Ingress.",
}
@@ -352,9 +361,9 @@ func (IngressTLS) SwaggerDoc() map[string]string {
var map_Job = map[string]string{
"": "Job represents the configuration of a single job.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec is a structure defining the expected behavior of a job. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec is a structure defining the expected behavior of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "Status is a structure describing current status of a job. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (Job) SwaggerDoc() map[string]string {
@@ -377,7 +386,7 @@ func (JobCondition) SwaggerDoc() map[string]string {
var map_JobList = map[string]string{
"": "JobList is a collection of jobs.",
- "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is the list of Job.",
}
@@ -387,12 +396,12 @@ func (JobList) SwaggerDoc() map[string]string {
var map_JobSpec = map[string]string{
"": "JobSpec describes how the job execution will look like.",
- "parallelism": "Parallelism 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
- "completions": "Completions 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: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "parallelism": "Parallelism 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
+ "completions": "Completions 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: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
"activeDeadlineSeconds": "Optional duration in seconds relative to the startTime that the job may be active before the system tries to terminate it; value must be positive integer",
- "selector": "Selector is a label query over pods that should match the pod count. Normally, the system sets this field for you. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "autoSelector": "AutoSelector controls generation of pod labels and pod selectors. It was not present in the original extensions/v1beta1 Job definition, but exists to allow conversion from batch/v1 Jobs, where it corresponds to, but has the opposite meaning as, ManualSelector. More info: http://releases.k8s.io/release-1.2/docs/design/selector-generation.md",
- "template": "Template is the object that describes the pod that will be created when executing a job. More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "selector": "Selector is a label query over pods that should match the pod count. Normally, the system sets this field for you. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "autoSelector": "AutoSelector controls generation of pod labels and pod selectors. It was not present in the original extensions/v1beta1 Job definition, but exists to allow conversion from batch/v1 Jobs, where it corresponds to, but has the opposite meaning as, ManualSelector. More info: http://releases.k8s.io/release-1.3/docs/design/selector-generation.md",
+ "template": "Template is the object that describes the pod that will be created when executing a job. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
}
func (JobSpec) SwaggerDoc() map[string]string {
@@ -401,7 +410,7 @@ func (JobSpec) SwaggerDoc() map[string]string {
var map_JobStatus = map[string]string{
"": "JobStatus represents the current state of a Job.",
- "conditions": "Conditions represent the latest available observations of an object's current state. More info: http://releases.k8s.io/release-1.2/docs/user-guide/jobs.md",
+ "conditions": "Conditions represent the latest available observations of an object's current state. More info: http://releases.k8s.io/release-1.3/docs/user-guide/jobs.md",
"startTime": "StartTime represents time when the job was acknowledged by the Job Manager. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC.",
"completionTime": "CompletionTime 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.",
"active": "Active is the number of actively running pods.",
@@ -447,9 +456,65 @@ func (ListOptions) SwaggerDoc() map[string]string {
return map_ListOptions
}
+var map_NetworkPolicy = map[string]string{
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Specification of the desired behavior for this NetworkPolicy.",
+}
+
+func (NetworkPolicy) SwaggerDoc() map[string]string {
+ return map_NetworkPolicy
+}
+
+var map_NetworkPolicyIngressRule = map[string]string{
+ "": "This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from.",
+ "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 not provided, this rule matches all ports (traffic not restricted by port). If this field is empty, this rule matches no ports (no traffic matches). 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.",
+ "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 not provided, this rule matches all sources (traffic not restricted by source). If this field is empty, this rule matches no sources (no traffic matches). If this field is present and contains at least on item, this rule allows traffic only if the traffic matches at least one item in the from list.",
+}
+
+func (NetworkPolicyIngressRule) SwaggerDoc() map[string]string {
+ return map_NetworkPolicyIngressRule
+}
+
+var map_NetworkPolicyList = map[string]string{
+ "": "Network Policy List is a list of NetworkPolicy objects.",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "items": "Items is a list of schema objects.",
+}
+
+func (NetworkPolicyList) SwaggerDoc() map[string]string {
+ return map_NetworkPolicyList
+}
+
+var map_NetworkPolicyPeer = map[string]string{
+ "podSelector": "This is a label selector which selects Pods in this namespace. This field follows standard label selector semantics. If not provided, this selector selects no pods. If present but empty, this selector selects all pods in this namespace.",
+ "namespaceSelector": "Selects Namespaces using cluster scoped-labels. This matches all pods in all namespaces selected by this label selector. This field follows standard label selector semantics. If omitted, this selector selects no namespaces. If present but empty, this selector selects all namespaces.",
+}
+
+func (NetworkPolicyPeer) SwaggerDoc() map[string]string {
+ return map_NetworkPolicyPeer
+}
+
+var map_NetworkPolicyPort = map[string]string{
+ "protocol": "Optional. The protocol (TCP or UDP) which traffic must match. If not specified, this field defaults to TCP.",
+ "port": "If specified, 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.",
+}
+
+func (NetworkPolicyPort) SwaggerDoc() map[string]string {
+ return map_NetworkPolicyPort
+}
+
+var map_NetworkPolicySpec = map[string]string{
+ "podSelector": "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.",
+ "ingress": "List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if namespace.networkPolicy.ingress.isolation is undefined and cluster policy allows it, 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 affect ingress isolation. If this field is present and contains at least one rule, this policy allows any traffic which matches at least one of the ingress rules in this list.",
+}
+
+func (NetworkPolicySpec) SwaggerDoc() map[string]string {
+ return map_NetworkPolicySpec
+}
+
var map_PodSecurityPolicy = map[string]string{
"": "Pod Security Policy governs the ability to make requests that affect the Security Context that will be applied to a pod and container.",
- "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard object's metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"spec": "spec defines the policy enforced.",
}
@@ -459,7 +524,7 @@ func (PodSecurityPolicy) SwaggerDoc() map[string]string {
var map_PodSecurityPolicyList = map[string]string{
"": "Pod Security Policy List is a list of PodSecurityPolicy objects.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is a list of schema objects.",
}
@@ -468,16 +533,21 @@ func (PodSecurityPolicyList) SwaggerDoc() map[string]string {
}
var map_PodSecurityPolicySpec = map[string]string{
- "": "Pod Security Policy Spec defines the policy enforced.",
- "privileged": "privileged determines if a pod can request to be run as privileged.",
- "capabilities": "capabilities is a list of capabilities that can be added.",
- "volumes": "volumes is a white list of allowed volume plugins. Empty indicates that all plugins may be used.",
- "hostNetwork": "hostNetwork determines if the policy allows the use of HostNetwork in the pod spec.",
- "hostPorts": "hostPorts determines which host port ranges are allowed to be exposed.",
- "hostPID": "hostPID determines if the policy allows the use of HostPID in the pod spec.",
- "hostIPC": "hostIPC determines if the policy allows the use of HostIPC in the pod spec.",
- "seLinux": "seLinux is the strategy that will dictate the allowable labels that may be set.",
- "runAsUser": "runAsUser is the strategy that will dictate the allowable RunAsUser values that may be set.",
+ "": "Pod Security Policy Spec defines the policy enforced.",
+ "privileged": "privileged determines if a pod can request to be run as privileged.",
+ "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 capabiility in both DefaultAddCapabilities and RequiredDropCapabilities.",
+ "requiredDropCapabilities": "RequiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added.",
+ "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.",
+ "volumes": "volumes is a white list of allowed volume plugins. Empty indicates that all plugins may be used.",
+ "hostNetwork": "hostNetwork determines if the policy allows the use of HostNetwork in the pod spec.",
+ "hostPorts": "hostPorts determines which host port ranges are allowed to be exposed.",
+ "hostPID": "hostPID determines if the policy allows the use of HostPID in the pod spec.",
+ "hostIPC": "hostIPC determines if the policy allows the use of HostIPC in the pod spec.",
+ "seLinux": "seLinux is the strategy that will dictate the allowable labels that may be set.",
+ "runAsUser": "runAsUser is the strategy that will dictate the allowable RunAsUser values that may be set.",
+ "supplementalGroups": "SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext.",
+ "fsGroup": "FSGroup is the strategy that will dictate what fs group is used by the SecurityContext.",
+ "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.",
}
func (PodSecurityPolicySpec) SwaggerDoc() map[string]string {
@@ -486,9 +556,9 @@ func (PodSecurityPolicySpec) SwaggerDoc() map[string]string {
var map_ReplicaSet = map[string]string{
"": "ReplicaSet represents the configuration of a ReplicaSet.",
- "metadata": "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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
- "spec": "Spec defines the specification of the desired behavior of the ReplicaSet. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
- "status": "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: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status",
+ "metadata": "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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
+ "spec": "Spec defines the specification of the desired behavior of the ReplicaSet. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
+ "status": "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: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status",
}
func (ReplicaSet) SwaggerDoc() map[string]string {
@@ -497,8 +567,8 @@ func (ReplicaSet) SwaggerDoc() map[string]string {
var map_ReplicaSetList = map[string]string{
"": "ReplicaSetList is a collection of ReplicaSets.",
- "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds",
- "items": "List of ReplicaSets. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md",
+ "metadata": "Standard list metadata. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "items": "List of ReplicaSets. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md",
}
func (ReplicaSetList) SwaggerDoc() map[string]string {
@@ -507,9 +577,9 @@ func (ReplicaSetList) SwaggerDoc() map[string]string {
var map_ReplicaSetSpec = map[string]string{
"": "ReplicaSetSpec is the specification of a ReplicaSet.",
- "replicas": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
- "selector": "Selector is a label query over pods that should match the replica count. If the 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 replica set. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "template": "Template is the object that describes the pod that will be created if insufficient replicas are detected. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#pod-template",
+ "replicas": "Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
+ "selector": "Selector is a label query over pods that should match the replica count. If the 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 replica set. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "template": "Template is the object that describes the pod that will be created if insufficient replicas are detected. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#pod-template",
}
func (ReplicaSetSpec) SwaggerDoc() map[string]string {
@@ -518,7 +588,7 @@ func (ReplicaSetSpec) SwaggerDoc() map[string]string {
var map_ReplicaSetStatus = map[string]string{
"": "ReplicaSetStatus represents the current status of a ReplicaSet.",
- "replicas": "Replicas is the most recently oberved number of replicas. More info: http://releases.k8s.io/release-1.2/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
+ "replicas": "Replicas is the most recently oberved number of replicas. More info: http://releases.k8s.io/release-1.3/docs/user-guide/replication-controller.md#what-is-a-replication-controller",
"fullyLabeledReplicas": "The number of pods that have labels matching the labels of the pod template of the replicaset.",
"observedGeneration": "ObservedGeneration reflects the generation of the most recently observed ReplicaSet.",
}
@@ -566,7 +636,7 @@ func (RunAsUserStrategyOptions) SwaggerDoc() map[string]string {
var map_SELinuxStrategyOptions = map[string]string{
"": "SELinux Strategy Options defines the strategy type and any options used to create the strategy.",
"rule": "type is the strategy that will dictate the allowable labels that may be set.",
- "seLinuxOptions": "seLinuxOptions required to run as; required for MustRunAs More info: http://releases.k8s.io/release-1.2/docs/design/security_context.md#security-context",
+ "seLinuxOptions": "seLinuxOptions required to run as; required for MustRunAs More info: http://releases.k8s.io/release-1.3/docs/design/security_context.md#security-context",
}
func (SELinuxStrategyOptions) SwaggerDoc() map[string]string {
@@ -575,9 +645,9 @@ func (SELinuxStrategyOptions) SwaggerDoc() map[string]string {
var map_Scale = map[string]string{
"": "represents a scaling request for a resource.",
- "metadata": "Standard object metadata; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata.",
- "spec": "defines the behavior of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status.",
- "status": "current status of the scale. More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#spec-and-status. Read-only.",
+ "metadata": "Standard object metadata; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata.",
+ "spec": "defines the behavior of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status.",
+ "status": "current status of the scale. More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#spec-and-status. Read-only.",
}
func (Scale) SwaggerDoc() map[string]string {
@@ -596,8 +666,8 @@ func (ScaleSpec) SwaggerDoc() map[string]string {
var map_ScaleStatus = map[string]string{
"": "represents the current status of a scale subresource.",
"replicas": "actual number of observed instances of the scaled object.",
- "selector": "label query over pods that should match the replicas count. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
- "targetSelector": "label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: http://releases.k8s.io/release-1.2/docs/user-guide/labels.md#label-selectors",
+ "selector": "label query over pods that should match the replicas count. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
+ "targetSelector": "label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: http://releases.k8s.io/release-1.3/docs/user-guide/labels.md#label-selectors",
}
func (ScaleStatus) SwaggerDoc() map[string]string {
@@ -606,8 +676,8 @@ func (ScaleStatus) SwaggerDoc() map[string]string {
var map_SubresourceReference = map[string]string{
"": "SubresourceReference contains enough information to let you inspect or modify the referred subresource.",
- "kind": "Kind of the referent; More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#types-kinds\"",
- "name": "Name of the referent; More info: http://releases.k8s.io/release-1.2/docs/user-guide/identifiers.md#names",
+ "kind": "Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds",
+ "name": "Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names",
"apiVersion": "API version of the referent",
"subresource": "Subresource name of the referent",
}
@@ -616,6 +686,16 @@ func (SubresourceReference) SwaggerDoc() map[string]string {
return map_SubresourceReference
}
+var map_SupplementalGroupsStrategyOptions = map[string]string{
+ "": "SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy.",
+ "rule": "Rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.",
+ "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.",
+}
+
+func (SupplementalGroupsStrategyOptions) SwaggerDoc() map[string]string {
+ return map_SupplementalGroupsStrategyOptions
+}
+
var map_ThirdPartyResource = map[string]string{
"": "A ThirdPartyResource is a generic representation of a resource, it is used by add-ons and plugins to add new resource types to the API. It consists of one or more Versions of the api.",
"metadata": "Standard object metadata",
@@ -639,7 +719,7 @@ func (ThirdPartyResourceData) SwaggerDoc() map[string]string {
var map_ThirdPartyResourceDataList = map[string]string{
"": "ThirdPartyResrouceDataList is a list of ThirdPartyResourceData.",
- "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.2/docs/devel/api-conventions.md#metadata",
+ "metadata": "Standard list metadata More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#metadata",
"items": "Items is the list of ThirdpartyResourceData.",
}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go b/vendor/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go
new file mode 100644
index 0000000000000000000000000000000000000000..d0405c3770f5e3cd4b758f645963ca5cafdc272f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go
@@ -0,0 +1,746 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 validation
+
+import (
+ "fmt"
+ "net"
+ "reflect"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ unversionedvalidation "k8s.io/kubernetes/pkg/api/unversioned/validation"
+ apivalidation "k8s.io/kubernetes/pkg/api/validation"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/labels"
+ psputil "k8s.io/kubernetes/pkg/security/podsecuritypolicy/util"
+ "k8s.io/kubernetes/pkg/util/intstr"
+ "k8s.io/kubernetes/pkg/util/sets"
+ "k8s.io/kubernetes/pkg/util/validation"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+func ValidateThirdPartyResourceUpdate(update, old *extensions.ThirdPartyResource) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))...)
+ allErrs = append(allErrs, ValidateThirdPartyResource(update)...)
+ return allErrs
+}
+
+func ValidateThirdPartyResourceName(name string, prefix bool) []string {
+ // Make sure it's a valid DNS subdomain
+ if msgs := apivalidation.NameIsDNSSubdomain(name, prefix); len(msgs) != 0 {
+ return msgs
+ }
+
+ // Make sure it's at least three segments (kind + two-segment group name)
+ if !prefix {
+ parts := strings.Split(name, ".")
+ if len(parts) < 3 {
+ return []string{"must be at least three segments long: <kind>.<domain>.<tld>"}
+ }
+ }
+
+ return nil
+}
+
+func ValidateThirdPartyResource(obj *extensions.ThirdPartyResource) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&obj.ObjectMeta, false, ValidateThirdPartyResourceName, field.NewPath("metadata"))...)
+
+ versions := sets.String{}
+ for ix := range obj.Versions {
+ version := &obj.Versions[ix]
+ if len(version.Name) == 0 {
+ allErrs = append(allErrs, field.Invalid(field.NewPath("versions").Index(ix).Child("name"), version, "must not be empty"))
+ } else {
+ for _, msg := range validation.IsDNS1123Label(version.Name) {
+ allErrs = append(allErrs, field.Invalid(field.NewPath("versions").Index(ix).Child("name"), version, msg))
+ }
+ }
+ if versions.Has(version.Name) {
+ allErrs = append(allErrs, field.Duplicate(field.NewPath("versions").Index(ix).Child("name"), version))
+ }
+ versions.Insert(version.Name)
+ }
+ return allErrs
+}
+
+// ValidateDaemonSet tests if required fields in the DaemonSet are set.
+func ValidateDaemonSet(ds *extensions.DaemonSet) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMeta(&ds.ObjectMeta, true, ValidateDaemonSetName, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateDaemonSetSpec(&ds.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateDaemonSetUpdate tests if required fields in the DaemonSet are set.
+func ValidateDaemonSetUpdate(ds, oldDS *extensions.DaemonSet) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&ds.ObjectMeta, &oldDS.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateDaemonSetSpec(&ds.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// validateDaemonSetStatus validates a DaemonSetStatus
+func validateDaemonSetStatus(status *extensions.DaemonSetStatus, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.CurrentNumberScheduled), fldPath.Child("currentNumberScheduled"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.NumberMisscheduled), fldPath.Child("numberMisscheduled"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.DesiredNumberScheduled), fldPath.Child("desiredNumberScheduled"))...)
+ return allErrs
+}
+
+// ValidateDaemonSetStatus validates tests if required fields in the DaemonSet Status section
+func ValidateDaemonSetStatusUpdate(ds, oldDS *extensions.DaemonSet) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&ds.ObjectMeta, &oldDS.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, validateDaemonSetStatus(&ds.Status, field.NewPath("status"))...)
+ return allErrs
+}
+
+// ValidateDaemonSetSpec tests if required fields in the DaemonSetSpec are set.
+func ValidateDaemonSetSpec(spec *extensions.DaemonSetSpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, fldPath.Child("selector"))...)
+
+ selector, err := unversioned.LabelSelectorAsSelector(spec.Selector)
+ if err == nil && !selector.Matches(labels.Set(spec.Template.Labels)) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("template", "metadata", "labels"), spec.Template.Labels, "`selector` does not match template `labels`"))
+ }
+ if spec.Selector != nil && len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is not valid for daemonset."))
+ }
+
+ allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(&spec.Template, fldPath.Child("template"))...)
+ // Daemons typically run on more than one node, so mark Read-Write persistent disks as invalid.
+ allErrs = append(allErrs, apivalidation.ValidateReadOnlyPersistentDisks(spec.Template.Spec.Volumes, fldPath.Child("template", "spec", "volumes"))...)
+ // RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
+ if spec.Template.Spec.RestartPolicy != api.RestartPolicyAlways {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("template", "spec", "restartPolicy"), spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
+ }
+ return allErrs
+}
+
+// ValidateDaemonSetName can be used to check whether the given daemon set name is valid.
+// Prefix indicates this name will be used as part of generation, in which case
+// trailing dashes are allowed.
+var ValidateDaemonSetName = apivalidation.NameIsDNSSubdomain
+
+// Validates that the given name can be used as a deployment name.
+var ValidateDeploymentName = apivalidation.NameIsDNSSubdomain
+
+func ValidatePositiveIntOrPercent(intOrPercent intstr.IntOrString, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if intOrPercent.Type == intstr.String {
+ if !validation.IsValidPercent(intOrPercent.StrVal) {
+ allErrs = append(allErrs, field.Invalid(fldPath, intOrPercent, "must be an integer or percentage (e.g '5%')"))
+ }
+ } else if intOrPercent.Type == intstr.Int {
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(intOrPercent.IntValue()), fldPath)...)
+ }
+ return allErrs
+}
+
+func getPercentValue(intOrStringValue intstr.IntOrString) (int, bool) {
+ if intOrStringValue.Type != intstr.String || !validation.IsValidPercent(intOrStringValue.StrVal) {
+ return 0, false
+ }
+ value, _ := strconv.Atoi(intOrStringValue.StrVal[:len(intOrStringValue.StrVal)-1])
+ return value, true
+}
+
+func getIntOrPercentValue(intOrStringValue intstr.IntOrString) int {
+ value, isPercent := getPercentValue(intOrStringValue)
+ if isPercent {
+ return value
+ }
+ return intOrStringValue.IntValue()
+}
+
+func IsNotMoreThan100Percent(intOrStringValue intstr.IntOrString, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ value, isPercent := getPercentValue(intOrStringValue)
+ if !isPercent || value <= 100 {
+ return nil
+ }
+ allErrs = append(allErrs, field.Invalid(fldPath, intOrStringValue, "must not be greater than 100%"))
+ return allErrs
+}
+
+func ValidateRollingUpdateDeployment(rollingUpdate *extensions.RollingUpdateDeployment, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
+ allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)
+ if getIntOrPercentValue(rollingUpdate.MaxUnavailable) == 0 && getIntOrPercentValue(rollingUpdate.MaxSurge) == 0 {
+ // Both MaxSurge and MaxUnavailable cannot be zero.
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("maxUnavailable"), rollingUpdate.MaxUnavailable, "may not be 0 when `maxSurge` is 0"))
+ }
+ // Validate that MaxUnavailable is not more than 100%.
+ allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
+ return allErrs
+}
+
+func ValidateDeploymentStrategy(strategy *extensions.DeploymentStrategy, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ switch strategy.Type {
+ case extensions.RecreateDeploymentStrategyType:
+ if strategy.RollingUpdate != nil {
+ allErrs = append(allErrs, field.Forbidden(fldPath.Child("rollingUpdate"), "may not be specified when strategy `type` is '"+string(extensions.RecreateDeploymentStrategyType+"'")))
+ }
+ case extensions.RollingUpdateDeploymentStrategyType:
+ // This should never happen since it's set and checked in defaults.go
+ if strategy.RollingUpdate == nil {
+ allErrs = append(allErrs, field.Required(fldPath.Child("rollingUpdate"), "this should be defaulted and never be nil"))
+ } else {
+ allErrs = append(allErrs, ValidateRollingUpdateDeployment(strategy.RollingUpdate, fldPath.Child("rollingUpdate"))...)
+ }
+ default:
+ validValues := []string{string(extensions.RecreateDeploymentStrategyType), string(extensions.RollingUpdateDeploymentStrategyType)}
+ allErrs = append(allErrs, field.NotSupported(fldPath, strategy, validValues))
+ }
+ return allErrs
+}
+
+func ValidateRollback(rollback *extensions.RollbackConfig, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ v := rollback.Revision
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(v), fldPath.Child("version"))...)
+ return allErrs
+}
+
+// Validates given deployment spec.
+func ValidateDeploymentSpec(spec *extensions.DeploymentSpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.Replicas), fldPath.Child("replicas"))...)
+
+ if spec.Selector == nil {
+ allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
+ } else {
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, fldPath.Child("selector"))...)
+ if len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is not valid for deployment."))
+ }
+ }
+
+ selector, err := unversioned.LabelSelectorAsSelector(spec.Selector)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "invalid label selector."))
+ } else {
+ allErrs = append(allErrs, ValidatePodTemplateSpecForReplicaSet(&spec.Template, selector, spec.Replicas, fldPath.Child("template"))...)
+ }
+
+ allErrs = append(allErrs, ValidateDeploymentStrategy(&spec.Strategy, fldPath.Child("strategy"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds"))...)
+ if spec.RevisionHistoryLimit != nil {
+ // zero is a valid RevisionHistoryLimit
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.RevisionHistoryLimit), fldPath.Child("revisionHistoryLimit"))...)
+ }
+ if spec.RollbackTo != nil {
+ allErrs = append(allErrs, ValidateRollback(spec.RollbackTo, fldPath.Child("rollback"))...)
+ }
+ return allErrs
+}
+
+// Validates given deployment status.
+func ValidateDeploymentStatus(status *extensions.DeploymentStatus, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(status.ObservedGeneration, fldPath.Child("observedGeneration"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Replicas), fldPath.Child("replicas"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UpdatedReplicas), fldPath.Child("updatedReplicas"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.AvailableReplicas), fldPath.Child("availableReplicas"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UnavailableReplicas), fldPath.Child("unavailableReplicas"))...)
+ return allErrs
+}
+
+func ValidateDeploymentUpdate(update, old *extensions.Deployment) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateDeploymentSpec(&update.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+func ValidateDeploymentStatusUpdate(update, old *extensions.Deployment) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateDeploymentStatus(&update.Status, field.NewPath("status"))...)
+ return allErrs
+}
+
+func ValidateDeployment(obj *extensions.Deployment) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMeta(&obj.ObjectMeta, true, ValidateDeploymentName, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateDeploymentSpec(&obj.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+func ValidateDeploymentRollback(obj *extensions.DeploymentRollback) field.ErrorList {
+ allErrs := apivalidation.ValidateAnnotations(obj.UpdatedAnnotations, field.NewPath("updatedAnnotations"))
+ if len(obj.Name) == 0 {
+ allErrs = append(allErrs, field.Required(field.NewPath("name"), "name is required"))
+ }
+ allErrs = append(allErrs, ValidateRollback(&obj.RollbackTo, field.NewPath("rollback"))...)
+ return allErrs
+}
+
+func ValidateThirdPartyResourceDataUpdate(update, old *extensions.ThirdPartyResourceData) field.ErrorList {
+ return apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))
+}
+
+func ValidateThirdPartyResourceData(obj *extensions.ThirdPartyResourceData) field.ErrorList {
+ return apivalidation.ValidateObjectMeta(&obj.ObjectMeta, true, apivalidation.NameIsDNSLabel, field.NewPath("metadata"))
+}
+
+// ValidateIngress tests if required fields in the Ingress are set.
+func ValidateIngress(ingress *extensions.Ingress) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMeta(&ingress.ObjectMeta, true, ValidateIngressName, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateIngressSpec(&ingress.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateIngressName validates that the given name can be used as an Ingress name.
+var ValidateIngressName = apivalidation.NameIsDNSSubdomain
+
+func validateIngressTLS(spec *extensions.IngressSpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ // TODO: Perform a more thorough validation of spec.TLS.Hosts that takes
+ // the wildcard spec from RFC 6125 into account.
+ return allErrs
+}
+
+// ValidateIngressSpec tests if required fields in the IngressSpec are set.
+func ValidateIngressSpec(spec *extensions.IngressSpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ // TODO: Is a default backend mandatory?
+ if spec.Backend != nil {
+ allErrs = append(allErrs, validateIngressBackend(spec.Backend, fldPath.Child("backend"))...)
+ } else if len(spec.Rules) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath, spec.Rules, "either `backend` or `rules` must be specified"))
+ }
+ if len(spec.Rules) > 0 {
+ allErrs = append(allErrs, validateIngressRules(spec.Rules, fldPath.Child("rules"))...)
+ }
+ if len(spec.TLS) > 0 {
+ allErrs = append(allErrs, validateIngressTLS(spec, fldPath.Child("tls"))...)
+ }
+ return allErrs
+}
+
+// ValidateIngressUpdate tests if required fields in the Ingress are set.
+func ValidateIngressUpdate(ingress, oldIngress *extensions.Ingress) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&ingress.ObjectMeta, &oldIngress.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateIngressSpec(&ingress.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateIngressStatusUpdate tests if required fields in the Ingress are set when updating status.
+func ValidateIngressStatusUpdate(ingress, oldIngress *extensions.Ingress) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMetaUpdate(&ingress.ObjectMeta, &oldIngress.ObjectMeta, field.NewPath("metadata"))
+ allErrs = append(allErrs, apivalidation.ValidateLoadBalancerStatus(&ingress.Status.LoadBalancer, field.NewPath("status", "loadBalancer"))...)
+ return allErrs
+}
+
+func validateIngressRules(IngressRules []extensions.IngressRule, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if len(IngressRules) == 0 {
+ return append(allErrs, field.Required(fldPath, ""))
+ }
+ for i, ih := range IngressRules {
+ if len(ih.Host) > 0 {
+ // TODO: Ports and ips are allowed in the host part of a url
+ // according to RFC 3986, consider allowing them.
+ for _, msg := range validation.IsDNS1123Subdomain(ih.Host) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("host"), ih.Host, msg))
+ }
+ if isIP := (net.ParseIP(ih.Host) != nil); isIP {
+ allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("host"), ih.Host, "must be a DNS name, not an IP address"))
+ }
+ }
+ allErrs = append(allErrs, validateIngressRuleValue(&ih.IngressRuleValue, fldPath.Index(0))...)
+ }
+ return allErrs
+}
+
+func validateIngressRuleValue(ingressRule *extensions.IngressRuleValue, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if ingressRule.HTTP != nil {
+ allErrs = append(allErrs, validateHTTPIngressRuleValue(ingressRule.HTTP, fldPath.Child("http"))...)
+ }
+ return allErrs
+}
+
+func validateHTTPIngressRuleValue(httpIngressRuleValue *extensions.HTTPIngressRuleValue, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if len(httpIngressRuleValue.Paths) == 0 {
+ allErrs = append(allErrs, field.Required(fldPath.Child("paths"), ""))
+ }
+ for i, rule := range httpIngressRuleValue.Paths {
+ if len(rule.Path) > 0 {
+ if !strings.HasPrefix(rule.Path, "/") {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("paths").Index(i).Child("path"), rule.Path, "must be an absolute path"))
+ }
+ // TODO: More draconian path regex validation.
+ // Path must be a valid regex. This is the basic requirement.
+ // In addition to this any characters not allowed in a path per
+ // RFC 3986 section-3.3 cannot appear as a literal in the regex.
+ // Consider the example: http://host/valid?#bar, everything after
+ // the last '/' is a valid regex that matches valid#bar, which
+ // isn't a valid path, because the path terminates at the first ?
+ // or #. A more sophisticated form of validation would detect that
+ // the user is confusing url regexes with path regexes.
+ _, err := regexp.CompilePOSIX(rule.Path)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("paths").Index(i).Child("path"), rule.Path, "must be a valid regex"))
+ }
+ }
+ allErrs = append(allErrs, validateIngressBackend(&rule.Backend, fldPath.Child("backend"))...)
+ }
+ return allErrs
+}
+
+// validateIngressBackend tests if a given backend is valid.
+func validateIngressBackend(backend *extensions.IngressBackend, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ // All backends must reference a single local service by name, and a single service port by name or number.
+ if len(backend.ServiceName) == 0 {
+ return append(allErrs, field.Required(fldPath.Child("serviceName"), ""))
+ } else {
+ for _, msg := range apivalidation.ValidateServiceName(backend.ServiceName, false) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("serviceName"), backend.ServiceName, msg))
+ }
+ }
+ if backend.ServicePort.Type == intstr.String {
+ for _, msg := range validation.IsDNS1123Label(backend.ServicePort.StrVal) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("servicePort"), backend.ServicePort.StrVal, msg))
+ }
+ if !validation.IsValidPortName(backend.ServicePort.StrVal) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("servicePort"), backend.ServicePort.StrVal, apivalidation.PortNameErrorMsg))
+ }
+ } else if !validation.IsValidPortNum(backend.ServicePort.IntValue()) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("servicePort"), backend.ServicePort, apivalidation.PortRangeErrorMsg))
+ }
+ return allErrs
+}
+
+func ValidateScale(scale *extensions.Scale) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&scale.ObjectMeta, true, apivalidation.NameIsDNSSubdomain, field.NewPath("metadata"))...)
+
+ if scale.Spec.Replicas < 0 {
+ allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "replicas"), scale.Spec.Replicas, "must be greater than or equal to 0"))
+ }
+
+ return allErrs
+}
+
+// ValidateReplicaSetName can be used to check whether the given ReplicaSet
+// name is valid.
+// Prefix indicates this name will be used as part of generation, in which case
+// trailing dashes are allowed.
+var ValidateReplicaSetName = apivalidation.NameIsDNSSubdomain
+
+// ValidateReplicaSet tests if required fields in the ReplicaSet are set.
+func ValidateReplicaSet(rs *extensions.ReplicaSet) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMeta(&rs.ObjectMeta, true, ValidateReplicaSetName, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateReplicaSetSpec(&rs.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateReplicaSetUpdate tests if required fields in the ReplicaSet are set.
+func ValidateReplicaSetUpdate(rs, oldRs *extensions.ReplicaSet) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&rs.ObjectMeta, &oldRs.ObjectMeta, field.NewPath("metadata"))...)
+ allErrs = append(allErrs, ValidateReplicaSetSpec(&rs.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateReplicaSetStatusUpdate tests if required fields in the ReplicaSet are set.
+func ValidateReplicaSetStatusUpdate(rs, oldRs *extensions.ReplicaSet) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&rs.ObjectMeta, &oldRs.ObjectMeta, field.NewPath("metadata"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(rs.Status.Replicas), field.NewPath("status", "replicas"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(rs.Status.FullyLabeledReplicas), field.NewPath("status", "fullyLabeledReplicas"))...)
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(rs.Status.ObservedGeneration), field.NewPath("status", "observedGeneration"))...)
+ return allErrs
+}
+
+// ValidateReplicaSetSpec tests if required fields in the ReplicaSet spec are set.
+func ValidateReplicaSetSpec(spec *extensions.ReplicaSetSpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.Replicas), fldPath.Child("replicas"))...)
+
+ if spec.Selector == nil {
+ allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
+ } else {
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, fldPath.Child("selector"))...)
+ if len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is not valid for deployment."))
+ }
+ }
+
+ selector, err := unversioned.LabelSelectorAsSelector(spec.Selector)
+ if err != nil {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "invalid label selector."))
+ } else {
+ allErrs = append(allErrs, ValidatePodTemplateSpecForReplicaSet(&spec.Template, selector, spec.Replicas, fldPath.Child("template"))...)
+ }
+ return allErrs
+}
+
+// Validates the given template and ensures that it is in accordance with the desired selector and replicas.
+func ValidatePodTemplateSpecForReplicaSet(template *api.PodTemplateSpec, selector labels.Selector, replicas int32, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if template == nil {
+ allErrs = append(allErrs, field.Required(fldPath, ""))
+ } else {
+ if !selector.Empty() {
+ // Verify that the ReplicaSet selector matches the labels in template.
+ labels := labels.Set(template.Labels)
+ if !selector.Matches(labels) {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("metadata", "labels"), template.Labels, "`selector` does not match template `labels`"))
+ }
+ }
+ allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(template, fldPath)...)
+ if replicas > 1 {
+ allErrs = append(allErrs, apivalidation.ValidateReadOnlyPersistentDisks(template.Spec.Volumes, fldPath.Child("spec", "volumes"))...)
+ }
+ // RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
+ if template.Spec.RestartPolicy != api.RestartPolicyAlways {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("spec", "restartPolicy"), template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
+ }
+ }
+ return allErrs
+}
+
+// ValidatePodSecurityPolicyName can be used to check whether the given
+// pod security policy name is valid.
+// Prefix indicates this name will be used as part of generation, in which case
+// trailing dashes are allowed.
+var ValidatePodSecurityPolicyName = apivalidation.NameIsDNSSubdomain
+
+func ValidatePodSecurityPolicy(psp *extensions.PodSecurityPolicy) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&psp.ObjectMeta, false, ValidatePodSecurityPolicyName, field.NewPath("metadata"))...)
+ allErrs = append(allErrs, ValidatePodSecurityPolicySpec(&psp.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+func ValidatePodSecurityPolicySpec(spec *extensions.PodSecurityPolicySpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ allErrs = append(allErrs, validatePSPRunAsUser(fldPath.Child("runAsUser"), &spec.RunAsUser)...)
+ allErrs = append(allErrs, validatePSPSELinux(fldPath.Child("seLinux"), &spec.SELinux)...)
+ allErrs = append(allErrs, validatePSPSupplementalGroup(fldPath.Child("supplementalGroups"), &spec.SupplementalGroups)...)
+ allErrs = append(allErrs, validatePSPFSGroup(fldPath.Child("fsGroup"), &spec.FSGroup)...)
+ allErrs = append(allErrs, validatePodSecurityPolicyVolumes(fldPath, spec.Volumes)...)
+ allErrs = append(allErrs, validatePSPCapsAgainstDrops(spec.RequiredDropCapabilities, spec.DefaultAddCapabilities, field.NewPath("defaultAddCapabilities"))...)
+ allErrs = append(allErrs, validatePSPCapsAgainstDrops(spec.RequiredDropCapabilities, spec.AllowedCapabilities, field.NewPath("allowedCapabilities"))...)
+
+ return allErrs
+}
+
+// validatePSPSELinux validates the SELinux fields of PodSecurityPolicy.
+func validatePSPSELinux(fldPath *field.Path, seLinux *extensions.SELinuxStrategyOptions) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ // ensure the selinux strategy has a valid rule
+ supportedSELinuxRules := sets.NewString(string(extensions.SELinuxStrategyMustRunAs),
+ string(extensions.SELinuxStrategyRunAsAny))
+ if !supportedSELinuxRules.Has(string(seLinux.Rule)) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("rule"), seLinux.Rule, supportedSELinuxRules.List()))
+ }
+
+ return allErrs
+}
+
+// validatePSPRunAsUser validates the RunAsUser fields of PodSecurityPolicy.
+func validatePSPRunAsUser(fldPath *field.Path, runAsUser *extensions.RunAsUserStrategyOptions) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ // ensure the user strategy has a valid rule
+ supportedRunAsUserRules := sets.NewString(string(extensions.RunAsUserStrategyMustRunAs),
+ string(extensions.RunAsUserStrategyMustRunAsNonRoot),
+ string(extensions.RunAsUserStrategyRunAsAny))
+ if !supportedRunAsUserRules.Has(string(runAsUser.Rule)) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("rule"), runAsUser.Rule, supportedRunAsUserRules.List()))
+ }
+
+ // validate range settings
+ for idx, rng := range runAsUser.Ranges {
+ allErrs = append(allErrs, validateIDRanges(fldPath.Child("ranges").Index(idx), rng)...)
+ }
+
+ return allErrs
+}
+
+// validatePSPFSGroup validates the FSGroupStrategyOptions fields of the PodSecurityPolicy.
+func validatePSPFSGroup(fldPath *field.Path, groupOptions *extensions.FSGroupStrategyOptions) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ supportedRules := sets.NewString(
+ string(extensions.FSGroupStrategyMustRunAs),
+ string(extensions.FSGroupStrategyRunAsAny),
+ )
+ if !supportedRules.Has(string(groupOptions.Rule)) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("rule"), groupOptions.Rule, supportedRules.List()))
+ }
+
+ for idx, rng := range groupOptions.Ranges {
+ allErrs = append(allErrs, validateIDRanges(fldPath.Child("ranges").Index(idx), rng)...)
+ }
+ return allErrs
+}
+
+// validatePSPSupplementalGroup validates the SupplementalGroupsStrategyOptions fields of the PodSecurityPolicy.
+func validatePSPSupplementalGroup(fldPath *field.Path, groupOptions *extensions.SupplementalGroupsStrategyOptions) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ supportedRules := sets.NewString(
+ string(extensions.SupplementalGroupsStrategyRunAsAny),
+ string(extensions.SupplementalGroupsStrategyMustRunAs),
+ )
+ if !supportedRules.Has(string(groupOptions.Rule)) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("rule"), groupOptions.Rule, supportedRules.List()))
+ }
+
+ for idx, rng := range groupOptions.Ranges {
+ allErrs = append(allErrs, validateIDRanges(fldPath.Child("ranges").Index(idx), rng)...)
+ }
+ return allErrs
+}
+
+// validatePodSecurityPolicyVolumes validates the volume fields of PodSecurityPolicy.
+func validatePodSecurityPolicyVolumes(fldPath *field.Path, volumes []extensions.FSType) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allowed := psputil.GetAllFSTypesAsSet()
+ // add in the * value since that is a pseudo type that is not included by default
+ allowed.Insert(string(extensions.All))
+ for _, v := range volumes {
+ if !allowed.Has(string(v)) {
+ allErrs = append(allErrs, field.NotSupported(fldPath.Child("volumes"), v, allowed.List()))
+ }
+ }
+
+ return allErrs
+}
+
+// validateIDRanges ensures the range is valid.
+func validateIDRanges(fldPath *field.Path, rng extensions.IDRange) field.ErrorList {
+ allErrs := field.ErrorList{}
+
+ // if 0 <= Min <= Max then we do not need to validate max. It is always greater than or
+ // equal to 0 and Min.
+ if rng.Min < 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("min"), rng.Min, "min cannot be negative"))
+ }
+ if rng.Max < 0 {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("max"), rng.Max, "max cannot be negative"))
+ }
+ if rng.Min > rng.Max {
+ allErrs = append(allErrs, field.Invalid(fldPath.Child("min"), rng.Min, "min cannot be greater than max"))
+ }
+
+ return allErrs
+}
+
+// validatePSPCapsAgainstDrops ensures an allowed cap is not listed in the required drops.
+func validatePSPCapsAgainstDrops(requiredDrops []api.Capability, capsToCheck []api.Capability, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ if requiredDrops == nil {
+ return allErrs
+ }
+ for _, cap := range capsToCheck {
+ if hasCap(cap, requiredDrops) {
+ allErrs = append(allErrs, field.Invalid(fldPath, cap,
+ fmt.Sprintf("capability is listed in %s and requiredDropCapabilities", fldPath.String())))
+ }
+ }
+ return allErrs
+}
+
+// hasCap checks for needle in haystack.
+func hasCap(needle api.Capability, haystack []api.Capability) bool {
+ for _, c := range haystack {
+ if needle == c {
+ return true
+ }
+ }
+ return false
+}
+
+// ValidatePodSecurityPolicyUpdate validates a PSP for updates.
+func ValidatePodSecurityPolicyUpdate(old *extensions.PodSecurityPolicy, new *extensions.PodSecurityPolicy) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&old.ObjectMeta, &new.ObjectMeta, field.NewPath("metadata"))...)
+ allErrs = append(allErrs, ValidatePodSecurityPolicySpec(&new.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateNetworkPolicyName can be used to check whether the given networkpolicy
+// name is valid.
+func ValidateNetworkPolicyName(name string, prefix bool) []string {
+ return apivalidation.NameIsDNSSubdomain(name, prefix)
+}
+
+// ValidateNetworkPolicySpec tests if required fields in the networkpolicy spec are set.
+func ValidateNetworkPolicySpec(spec *extensions.NetworkPolicySpec, fldPath *field.Path) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(&spec.PodSelector, fldPath.Child("podSelector"))...)
+
+ // Validate ingress rules.
+ for _, i := range spec.Ingress {
+ // TODO: Update From to be a pointer to slice as soon as auto-generation supports it.
+ for _, f := range i.From {
+ numFroms := 0
+ if f.PodSelector != nil {
+ numFroms++
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(f.PodSelector, fldPath.Child("podSelector"))...)
+ }
+ if f.NamespaceSelector != nil {
+ if numFroms > 0 {
+ allErrs = append(allErrs, field.Forbidden(fldPath, "may not specify more than 1 from type"))
+ } else {
+ numFroms++
+ allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(f.NamespaceSelector, fldPath.Child("namespaces"))...)
+ }
+ }
+
+ if numFroms == 0 {
+ // At least one of PodSelector and NamespaceSelector must be defined.
+ allErrs = append(allErrs, field.Required(fldPath, "must specify a from type"))
+ }
+ }
+ }
+ return allErrs
+}
+
+// ValidateNetworkPolicy validates a networkpolicy.
+func ValidateNetworkPolicy(np *extensions.NetworkPolicy) field.ErrorList {
+ allErrs := apivalidation.ValidateObjectMeta(&np.ObjectMeta, true, ValidateNetworkPolicyName, field.NewPath("metadata"))
+ allErrs = append(allErrs, ValidateNetworkPolicySpec(&np.Spec, field.NewPath("spec"))...)
+ return allErrs
+}
+
+// ValidateNetworkPolicyUpdate tests if an update to a NetworkPolicy is valid.
+func ValidateNetworkPolicyUpdate(update, old *extensions.NetworkPolicy) field.ErrorList {
+ allErrs := field.ErrorList{}
+ allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))...)
+ if !reflect.DeepEqual(update.Spec, old.Spec) {
+ allErrs = append(allErrs, field.Forbidden(field.NewPath("spec"), "updates to networkpolicy spec are forbidden."))
+ }
+ return allErrs
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..390e4b4a7b48855802a75b46e138ecceb3dc92c6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/deep_copy_generated.go
@@ -0,0 +1,101 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package policy
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ intstr "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_policy_PodDisruptionBudget,
+ DeepCopy_policy_PodDisruptionBudgetList,
+ DeepCopy_policy_PodDisruptionBudgetSpec,
+ DeepCopy_policy_PodDisruptionBudgetStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_policy_PodDisruptionBudget(in PodDisruptionBudget, out *PodDisruptionBudget, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_policy_PodDisruptionBudgetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_policy_PodDisruptionBudgetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_policy_PodDisruptionBudgetList(in PodDisruptionBudgetList, out *PodDisruptionBudgetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PodDisruptionBudget, len(in))
+ for i := range in {
+ if err := DeepCopy_policy_PodDisruptionBudget(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_policy_PodDisruptionBudgetSpec(in PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, c *conversion.Cloner) error {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.MinAvailable, &out.MinAvailable, c); err != nil {
+ return err
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ return nil
+}
+
+func DeepCopy_policy_PodDisruptionBudgetStatus(in PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, c *conversion.Cloner) error {
+ out.PodDisruptionAllowed = in.PodDisruptionAllowed
+ out.CurrentHealthy = in.CurrentHealthy
+ out.DesiredHealthy = in.DesiredHealthy
+ out.ExpectedPods = in.ExpectedPods
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/install/install.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/install/install.go
rename to vendor/k8s.io/kubernetes/pkg/apis/policy/install/install.go
index e83c91cc4a20d7e16abd8c84181bfce6983b1867..7882a0c53108f6b1593c44b61a726f4f62bc6db6 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/install/install.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/install/install.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package install installs the metrics API group, making it available as
+// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install
@@ -28,13 +28,13 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apimachinery"
"k8s.io/kubernetes/pkg/apimachinery/registered"
- "k8s.io/kubernetes/pkg/apis/metrics"
- "k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
+ "k8s.io/kubernetes/pkg/apis/policy"
+ "k8s.io/kubernetes/pkg/apis/policy/v1alpha1"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets"
)
-const importPrefix = "k8s.io/kubernetes/pkg/apis/metrics"
+const importPrefix = "k8s.io/kubernetes/pkg/apis/policy"
var accessor = meta.NewAccessor()
@@ -50,7 +50,7 @@ func init() {
}
}
if len(externalVersions) == 0 {
- glog.V(4).Infof("No version is registered for group %v", metrics.GroupName)
+ glog.V(4).Infof("No version is registered for group %v", policy.GroupName)
return
}
@@ -107,14 +107,14 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor,
}, nil
default:
- g, _ := registered.Group(metrics.GroupName)
+ g, _ := registered.Group(policy.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
}
}
func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
// add the internal version to Scheme
- metrics.AddToScheme(api.Scheme)
+ policy.AddToScheme(api.Scheme)
// add the enabled external versions to Scheme
for _, v := range externalVersions {
if !registered.IsEnabledVersion(v) {
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/register.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..76ea1a55244f008f4b16a58a3b9c4fa71a812c94
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/register.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 policy
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "policy"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ // Add the API to Scheme.
+ addKnownTypes(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ // TODO this gets cleaned up when the types are fixed
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &PodDisruptionBudget{},
+ &PodDisruptionBudgetList{},
+ )
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..08be370f15847fb3415d79038ca79680b2b25258
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/types.generated.go
@@ -0,0 +1,1440 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package policy
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg3_api "k8s.io/kubernetes/pkg/api"
+ pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg4_types "k8s.io/kubernetes/pkg/types"
+ pkg1_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg3_api.ObjectMeta
+ var v1 pkg2_unversioned.LabelSelector
+ var v2 pkg4_types.UID
+ var v3 pkg1_intstr.IntOrString
+ var v4 time.Time
+ _, _, _, _, _ = v0, v1, v2, v3, v4
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = x.Selector != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.MinAvailable
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy4)
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("minAvailable"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.MinAvailable
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy6)
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "minAvailable":
+ if r.TryDecodeAsNil() {
+ x.MinAvailable = pkg1_intstr.IntOrString{}
+ } else {
+ yyv4 := &x.MinAvailable
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4)
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MinAvailable = pkg1_intstr.IntOrString{}
+ } else {
+ yyv9 := &x.MinAvailable
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv9)
+ } else {
+ z.DecFallback(yyv9, false)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudgetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 4
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeBool(bool(x.PodDisruptionAllowed))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("disruptionAllowed"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeBool(bool(x.PodDisruptionAllowed))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentHealthy))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("currentHealthy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentHealthy))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredHealthy))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("desiredHealthy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredHealthy))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ExpectedPods))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("expectedPods"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ExpectedPods))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "disruptionAllowed":
+ if r.TryDecodeAsNil() {
+ x.PodDisruptionAllowed = false
+ } else {
+ x.PodDisruptionAllowed = bool(r.DecodeBool())
+ }
+ case "currentHealthy":
+ if r.TryDecodeAsNil() {
+ x.CurrentHealthy = 0
+ } else {
+ x.CurrentHealthy = int32(r.DecodeInt(32))
+ }
+ case "desiredHealthy":
+ if r.TryDecodeAsNil() {
+ x.DesiredHealthy = 0
+ } else {
+ x.DesiredHealthy = int32(r.DecodeInt(32))
+ }
+ case "expectedPods":
+ if r.TryDecodeAsNil() {
+ x.ExpectedPods = 0
+ } else {
+ x.ExpectedPods = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodDisruptionAllowed = false
+ } else {
+ x.PodDisruptionAllowed = bool(r.DecodeBool())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.CurrentHealthy = 0
+ } else {
+ x.CurrentHealthy = int32(r.DecodeInt(32))
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DesiredHealthy = 0
+ } else {
+ x.DesiredHealthy = int32(r.DecodeInt(32))
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ExpectedPods = 0
+ } else {
+ x.ExpectedPods = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudget) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudget) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_api.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = PodDisruptionBudgetSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = PodDisruptionBudgetStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_api.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = PodDisruptionBudgetSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = PodDisruptionBudgetStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudgetList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePodDisruptionBudget(([]PodDisruptionBudget)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePodDisruptionBudget(([]PodDisruptionBudget)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePodDisruptionBudget((*[]PodDisruptionBudget)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePodDisruptionBudget((*[]PodDisruptionBudget)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSlicePodDisruptionBudget(v []PodDisruptionBudget, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePodDisruptionBudget(v *[]PodDisruptionBudget, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PodDisruptionBudget{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PodDisruptionBudget, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PodDisruptionBudget, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PodDisruptionBudget{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PodDisruptionBudget{}) // var yyz1 PodDisruptionBudget
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PodDisruptionBudget{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/types.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..2ecf41bcffd3410381fcad2b72252ce6ec0aacfd
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/types.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 policy
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+// PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.
+type PodDisruptionBudgetSpec struct {
+ // The minimum number of pods that must be available simultaneously. This
+ // can be either an integer or a string specifying a percentage, e.g. "28%".
+ MinAvailable intstr.IntOrString `json:"minAvailable,omitempty"`
+
+ // Label query over pods whose evictions are managed by the disruption
+ // budget.
+ Selector *unversioned.LabelSelector `json:"selector,omitempty"`
+}
+
+// PodDisruptionBudgetStatus represents information about the status of a
+// PodDisruptionBudget. Status may trail the actual state of a system.
+type PodDisruptionBudgetStatus struct {
+ // Whether or not a disruption is currently allowed.
+ PodDisruptionAllowed bool `json:"disruptionAllowed"`
+
+ // current number of healthy pods
+ CurrentHealthy int32 `json:"currentHealthy"`
+
+ // minimum desired number of healthy pods
+ DesiredHealthy int32 `json:"desiredHealthy"`
+
+ // total number of pods counted by this disruption budget
+ ExpectedPods int32 `json:"expectedPods"`
+}
+
+// +genclient=true,noMethods=true
+
+// PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods
+type PodDisruptionBudget struct {
+ unversioned.TypeMeta `json:",inline"`
+ api.ObjectMeta `json:"metadata,omitempty"`
+
+ // Specification of the desired behavior of the PodDisruptionBudget.
+ Spec PodDisruptionBudgetSpec `json:"spec,omitempty"`
+ // Most recently observed status of the PodDisruptionBudget.
+ Status PodDisruptionBudgetStatus `json:"status,omitempty"`
+}
+
+// PodDisruptionBudgetList is a collection of PodDisruptionBudgets.
+type PodDisruptionBudgetList struct {
+ unversioned.TypeMeta `json:",inline"`
+ unversioned.ListMeta `json:"metadata,omitempty"`
+ Items []PodDisruptionBudget `json:"items"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..23aaa9a3787ded86b146dfe9c7948955cf481a53
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/conversion_generated.go
@@ -0,0 +1,183 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ policy "k8s.io/kubernetes/pkg/apis/policy"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget,
+ Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget,
+ Convert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList,
+ Convert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList,
+ Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec,
+ Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec,
+ Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus,
+ Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in *PodDisruptionBudget, out *policy.PodDisruptionBudget, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in *PodDisruptionBudget, out *policy.PodDisruptionBudget, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(in, out, s)
+}
+
+func autoConvert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in *policy.PodDisruptionBudget, out *PodDisruptionBudget, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if err := Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(&in.Spec, &out.Spec, s); err != nil {
+ return err
+ }
+ if err := Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(&in.Status, &out.Status, s); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in *policy.PodDisruptionBudget, out *PodDisruptionBudget, s conversion.Scope) error {
+ return autoConvert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(in, out, s)
+}
+
+func autoConvert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in *PodDisruptionBudgetList, out *policy.PodDisruptionBudgetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]policy.PodDisruptionBudget, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_PodDisruptionBudget_To_policy_PodDisruptionBudget(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in *PodDisruptionBudgetList, out *policy.PodDisruptionBudgetList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PodDisruptionBudgetList_To_policy_PodDisruptionBudgetList(in, out, s)
+}
+
+func autoConvert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in *policy.PodDisruptionBudgetList, out *PodDisruptionBudgetList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]PodDisruptionBudget, len(*in))
+ for i := range *in {
+ if err := Convert_policy_PodDisruptionBudget_To_v1alpha1_PodDisruptionBudget(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in *policy.PodDisruptionBudgetList, out *PodDisruptionBudgetList, s conversion.Scope) error {
+ return autoConvert_policy_PodDisruptionBudgetList_To_v1alpha1_PodDisruptionBudgetList(in, out, s)
+}
+
+func autoConvert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in *PodDisruptionBudgetSpec, out *policy.PodDisruptionBudgetSpec, s conversion.Scope) error {
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MinAvailable, &out.MinAvailable, s); err != nil {
+ return err
+ }
+ out.Selector = in.Selector
+ return nil
+}
+
+func Convert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in *PodDisruptionBudgetSpec, out *policy.PodDisruptionBudgetSpec, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PodDisruptionBudgetSpec_To_policy_PodDisruptionBudgetSpec(in, out, s)
+}
+
+func autoConvert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in *policy.PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, s conversion.Scope) error {
+ if err := api.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MinAvailable, &out.MinAvailable, s); err != nil {
+ return err
+ }
+ out.Selector = in.Selector
+ return nil
+}
+
+func Convert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in *policy.PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, s conversion.Scope) error {
+ return autoConvert_policy_PodDisruptionBudgetSpec_To_v1alpha1_PodDisruptionBudgetSpec(in, out, s)
+}
+
+func autoConvert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in *PodDisruptionBudgetStatus, out *policy.PodDisruptionBudgetStatus, s conversion.Scope) error {
+ out.PodDisruptionAllowed = in.PodDisruptionAllowed
+ out.CurrentHealthy = in.CurrentHealthy
+ out.DesiredHealthy = in.DesiredHealthy
+ out.ExpectedPods = in.ExpectedPods
+ return nil
+}
+
+func Convert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in *PodDisruptionBudgetStatus, out *policy.PodDisruptionBudgetStatus, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PodDisruptionBudgetStatus_To_policy_PodDisruptionBudgetStatus(in, out, s)
+}
+
+func autoConvert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in *policy.PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, s conversion.Scope) error {
+ out.PodDisruptionAllowed = in.PodDisruptionAllowed
+ out.CurrentHealthy = in.CurrentHealthy
+ out.DesiredHealthy = in.DesiredHealthy
+ out.ExpectedPods = in.ExpectedPods
+ return nil
+}
+
+func Convert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in *policy.PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, s conversion.Scope) error {
+ return autoConvert_policy_PodDisruptionBudgetStatus_To_v1alpha1_PodDisruptionBudgetStatus(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..74680aff846a4114a2b12083f4ef31adc60d1e7c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/deep_copy_generated.go
@@ -0,0 +1,102 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ intstr "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1alpha1_PodDisruptionBudget,
+ DeepCopy_v1alpha1_PodDisruptionBudgetList,
+ DeepCopy_v1alpha1_PodDisruptionBudgetSpec,
+ DeepCopy_v1alpha1_PodDisruptionBudgetStatus,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1alpha1_PodDisruptionBudget(in PodDisruptionBudget, out *PodDisruptionBudget, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1alpha1_PodDisruptionBudgetSpec(in.Spec, &out.Spec, c); err != nil {
+ return err
+ }
+ if err := DeepCopy_v1alpha1_PodDisruptionBudgetStatus(in.Status, &out.Status, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PodDisruptionBudgetList(in PodDisruptionBudgetList, out *PodDisruptionBudgetList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]PodDisruptionBudget, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_PodDisruptionBudget(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PodDisruptionBudgetSpec(in PodDisruptionBudgetSpec, out *PodDisruptionBudgetSpec, c *conversion.Cloner) error {
+ if err := intstr.DeepCopy_intstr_IntOrString(in.MinAvailable, &out.MinAvailable, c); err != nil {
+ return err
+ }
+ if in.Selector != nil {
+ in, out := in.Selector, &out.Selector
+ *out = new(unversioned.LabelSelector)
+ if err := unversioned.DeepCopy_unversioned_LabelSelector(*in, *out, c); err != nil {
+ return err
+ }
+ } else {
+ out.Selector = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PodDisruptionBudgetStatus(in PodDisruptionBudgetStatus, out *PodDisruptionBudgetStatus, c *conversion.Cloner) error {
+ out.PodDisruptionAllowed = in.PodDisruptionAllowed
+ out.CurrentHealthy = in.CurrentHealthy
+ out.DesiredHealthy = in.DesiredHealthy
+ out.ExpectedPods = in.ExpectedPods
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..5cb716c2995239778fc5dbfe925a2ca1ae57d461
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/doc.go
@@ -0,0 +1,21 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 policy is for any kind of policy object. Suitable examples, even if
+// they aren't all here, are PodDisruptionBudget, PodSecurityPolicy,
+// NetworkPolicy, etc.
+// +genconversion=true
+package v1alpha1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..867a6b0a6dda2296739d306580f5a03ca6c8d628
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.pb.go
@@ -0,0 +1,903 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1alpha1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.proto
+
+ It has these top-level messages:
+ PodDisruptionBudget
+ PodDisruptionBudgetList
+ PodDisruptionBudgetSpec
+ PodDisruptionBudgetStatus
+*/
+package v1alpha1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import k8s_io_kubernetes_pkg_api_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *PodDisruptionBudget) Reset() { *m = PodDisruptionBudget{} }
+func (m *PodDisruptionBudget) String() string { return proto.CompactTextString(m) }
+func (*PodDisruptionBudget) ProtoMessage() {}
+
+func (m *PodDisruptionBudgetList) Reset() { *m = PodDisruptionBudgetList{} }
+func (m *PodDisruptionBudgetList) String() string { return proto.CompactTextString(m) }
+func (*PodDisruptionBudgetList) ProtoMessage() {}
+
+func (m *PodDisruptionBudgetSpec) Reset() { *m = PodDisruptionBudgetSpec{} }
+func (m *PodDisruptionBudgetSpec) String() string { return proto.CompactTextString(m) }
+func (*PodDisruptionBudgetSpec) ProtoMessage() {}
+
+func (m *PodDisruptionBudgetStatus) Reset() { *m = PodDisruptionBudgetStatus{} }
+func (m *PodDisruptionBudgetStatus) String() string { return proto.CompactTextString(m) }
+func (*PodDisruptionBudgetStatus) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*PodDisruptionBudget)(nil), "k8s.io.kubernetes.pkg.apis.policy.v1alpha1.PodDisruptionBudget")
+ proto.RegisterType((*PodDisruptionBudgetList)(nil), "k8s.io.kubernetes.pkg.apis.policy.v1alpha1.PodDisruptionBudgetList")
+ proto.RegisterType((*PodDisruptionBudgetSpec)(nil), "k8s.io.kubernetes.pkg.apis.policy.v1alpha1.PodDisruptionBudgetSpec")
+ proto.RegisterType((*PodDisruptionBudgetStatus)(nil), "k8s.io.kubernetes.pkg.apis.policy.v1alpha1.PodDisruptionBudgetStatus")
+}
+func (m *PodDisruptionBudget) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodDisruptionBudget) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
+ n2, err := m.Spec.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
+ n3, err := m.Status.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *PodDisruptionBudgetList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodDisruptionBudgetList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n4, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PodDisruptionBudgetSpec) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodDisruptionBudgetSpec) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.MinAvailable.Size()))
+ n5, err := m.MinAvailable.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ if m.Selector != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
+ n6, err := m.Selector.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ }
+ return i, nil
+}
+
+func (m *PodDisruptionBudgetStatus) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PodDisruptionBudgetStatus) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ if m.PodDisruptionAllowed {
+ data[i] = 1
+ } else {
+ data[i] = 0
+ }
+ i++
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.CurrentHealthy))
+ data[i] = 0x18
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.DesiredHealthy))
+ data[i] = 0x20
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ExpectedPods))
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *PodDisruptionBudget) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Spec.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Status.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *PodDisruptionBudgetList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PodDisruptionBudgetSpec) Size() (n int) {
+ var l int
+ _ = l
+ l = m.MinAvailable.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Selector != nil {
+ l = m.Selector.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *PodDisruptionBudgetStatus) Size() (n int) {
+ var l int
+ _ = l
+ n += 2
+ n += 1 + sovGenerated(uint64(m.CurrentHealthy))
+ n += 1 + sovGenerated(uint64(m.DesiredHealthy))
+ n += 1 + sovGenerated(uint64(m.ExpectedPods))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *PodDisruptionBudget) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodDisruptionBudget: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodDisruptionBudget: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodDisruptionBudgetList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodDisruptionBudgetList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodDisruptionBudgetList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, PodDisruptionBudget{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodDisruptionBudgetSpec) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodDisruptionBudgetSpec: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodDisruptionBudgetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MinAvailable", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.MinAvailable.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Selector == nil {
+ m.Selector = &k8s_io_kubernetes_pkg_api_unversioned.LabelSelector{}
+ }
+ if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PodDisruptionBudgetStatus) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PodDisruptionBudgetStatus: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PodDisruptionBudgetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PodDisruptionAllowed", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ v |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.PodDisruptionAllowed = bool(v != 0)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CurrentHealthy", wireType)
+ }
+ m.CurrentHealthy = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.CurrentHealthy |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DesiredHealthy", wireType)
+ }
+ m.DesiredHealthy = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.DesiredHealthy |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ExpectedPods", wireType)
+ }
+ m.ExpectedPods = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.ExpectedPods |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..866d0ae57882c6da59d64333b7778e5c58b83d59
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/generated.proto
@@ -0,0 +1,77 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.policy.v1alpha1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1alpha1";
+
+// PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods
+message PodDisruptionBudget {
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Specification of the desired behavior of the PodDisruptionBudget.
+ optional PodDisruptionBudgetSpec spec = 2;
+
+ // Most recently observed status of the PodDisruptionBudget.
+ optional PodDisruptionBudgetStatus status = 3;
+}
+
+// PodDisruptionBudgetList is a collection of PodDisruptionBudgets.
+message PodDisruptionBudgetList {
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ repeated PodDisruptionBudget items = 2;
+}
+
+// PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.
+message PodDisruptionBudgetSpec {
+ // The minimum number of pods that must be available simultaneously. This
+ // can be either an integer or a string specifying a percentage, e.g. "28%".
+ optional k8s.io.kubernetes.pkg.util.intstr.IntOrString minAvailable = 1;
+
+ // Label query over pods whose evictions are managed by the disruption
+ // budget.
+ optional k8s.io.kubernetes.pkg.api.unversioned.LabelSelector selector = 2;
+}
+
+// PodDisruptionBudgetStatus represents information about the status of a
+// PodDisruptionBudget. Status may trail the actual state of a system.
+message PodDisruptionBudgetStatus {
+ // Whether or not a disruption is currently allowed.
+ optional bool disruptionAllowed = 1;
+
+ // current number of healthy pods
+ optional int32 currentHealthy = 2;
+
+ // minimum desired number of healthy pods
+ optional int32 desiredHealthy = 3;
+
+ // total number of pods counted by this disruption budget
+ optional int32 expectedPods = 4;
+}
+
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/register.go
similarity index 78%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/register.go
rename to vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/register.go
index c943d54687d0cf69abcb5b4e7383c776bd5d5b99..a6a94d96d007a56878ce9b46161ee19d02fb3eb4 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/v1alpha1/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/register.go
@@ -20,27 +20,31 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/runtime"
+ versionedwatch "k8s.io/kubernetes/pkg/watch/versioned"
)
// GroupName is the group name use in this package
-const GroupName = "metrics"
+const GroupName = "policy"
// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1alpha1"}
func AddToScheme(scheme *runtime.Scheme) {
- // Add the API to Scheme.
addKnownTypes(scheme)
+ /*
+ addDefaultingFuncs(scheme)
+ addConversionFuncs(scheme)
+ */
}
// Adds the list of known types to api.Scheme.
func addKnownTypes(scheme *runtime.Scheme) {
scheme.AddKnownTypes(SchemeGroupVersion,
- &RawNode{},
- &RawPod{},
+ &PodDisruptionBudget{},
+ &PodDisruptionBudgetList{},
+ &v1.ListOptions{},
&v1.DeleteOptions{},
)
+ // Add the watch version that applies
+ versionedwatch.AddToGroupVersion(scheme, SchemeGroupVersion)
}
-
-func (obj *RawNode) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *RawPod) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ed4308bcc643e1c6c50f3d09e170a7e8d7a37a1
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.generated.go
@@ -0,0 +1,1440 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v1alpha1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_v1 "k8s.io/kubernetes/pkg/api/v1"
+ pkg4_types "k8s.io/kubernetes/pkg/types"
+ pkg1_intstr "k8s.io/kubernetes/pkg/util/intstr"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_unversioned.LabelSelector
+ var v1 pkg3_v1.ObjectMeta
+ var v2 pkg4_types.UID
+ var v3 pkg1_intstr.IntOrString
+ var v4 time.Time
+ _, _, _, _, _ = v0, v1, v2, v3, v4
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [2]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = x.Selector != nil
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(2)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.MinAvailable
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy4)
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("minAvailable"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.MinAvailable
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy6)
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("selector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Selector == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.Selector) {
+ } else {
+ z.EncFallback(x.Selector)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "minAvailable":
+ if r.TryDecodeAsNil() {
+ x.MinAvailable = pkg1_intstr.IntOrString{}
+ } else {
+ yyv4 := &x.MinAvailable
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else if !yym5 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4)
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "selector":
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.MinAvailable = pkg1_intstr.IntOrString{}
+ } else {
+ yyv9 := &x.MinAvailable
+ yym10 := z.DecBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv9)
+ } else {
+ z.DecFallback(yyv9, false)
+ }
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ if x.Selector != nil {
+ x.Selector = nil
+ }
+ } else {
+ if x.Selector == nil {
+ x.Selector = new(pkg2_unversioned.LabelSelector)
+ }
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x.Selector) {
+ } else {
+ z.DecFallback(x.Selector, false)
+ }
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudgetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 4
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeBool(bool(x.PodDisruptionAllowed))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("disruptionAllowed"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeBool(bool(x.PodDisruptionAllowed))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentHealthy))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("currentHealthy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeInt(int64(x.CurrentHealthy))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredHealthy))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("desiredHealthy"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeInt(int64(x.DesiredHealthy))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ExpectedPods))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("expectedPods"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ExpectedPods))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "disruptionAllowed":
+ if r.TryDecodeAsNil() {
+ x.PodDisruptionAllowed = false
+ } else {
+ x.PodDisruptionAllowed = bool(r.DecodeBool())
+ }
+ case "currentHealthy":
+ if r.TryDecodeAsNil() {
+ x.CurrentHealthy = 0
+ } else {
+ x.CurrentHealthy = int32(r.DecodeInt(32))
+ }
+ case "desiredHealthy":
+ if r.TryDecodeAsNil() {
+ x.DesiredHealthy = 0
+ } else {
+ x.DesiredHealthy = int32(r.DecodeInt(32))
+ }
+ case "expectedPods":
+ if r.TryDecodeAsNil() {
+ x.ExpectedPods = 0
+ } else {
+ x.ExpectedPods = int32(r.DecodeInt(32))
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.PodDisruptionAllowed = false
+ } else {
+ x.PodDisruptionAllowed = bool(r.DecodeBool())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.CurrentHealthy = 0
+ } else {
+ x.CurrentHealthy = int32(r.DecodeInt(32))
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.DesiredHealthy = 0
+ } else {
+ x.DesiredHealthy = int32(r.DecodeInt(32))
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ExpectedPods = 0
+ } else {
+ x.ExpectedPods = int32(r.DecodeInt(32))
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudget) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[1] = true
+ yyq2[2] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 0
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy9 := &x.Spec
+ yy9.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("spec"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy11 := &x.Spec
+ yy11.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yy14 := &x.Status
+ yy14.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("status"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy16 := &x.Status
+ yy16.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym23 := z.EncBinary()
+ _ = yym23
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudget) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "spec":
+ if r.TryDecodeAsNil() {
+ x.Spec = PodDisruptionBudgetSpec{}
+ } else {
+ yyv5 := &x.Spec
+ yyv5.CodecDecodeSelf(d)
+ }
+ case "status":
+ if r.TryDecodeAsNil() {
+ x.Status = PodDisruptionBudgetStatus{}
+ } else {
+ yyv6 := &x.Status
+ yyv6.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Spec = PodDisruptionBudgetSpec{}
+ } else {
+ yyv11 := &x.Spec
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Status = PodDisruptionBudgetStatus{}
+ } else {
+ yyv12 := &x.Status
+ yyv12.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *PodDisruptionBudgetList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePodDisruptionBudget(([]PodDisruptionBudget)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePodDisruptionBudget(([]PodDisruptionBudget)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PodDisruptionBudgetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSlicePodDisruptionBudget((*[]PodDisruptionBudget)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PodDisruptionBudgetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSlicePodDisruptionBudget((*[]PodDisruptionBudget)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSlicePodDisruptionBudget(v []PodDisruptionBudget, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePodDisruptionBudget(v *[]PodDisruptionBudget, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PodDisruptionBudget{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 296)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PodDisruptionBudget, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PodDisruptionBudget, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PodDisruptionBudget{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PodDisruptionBudget{}) // var yyz1 PodDisruptionBudget
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PodDisruptionBudget{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PodDisruptionBudget{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..1f3265ae272e1013c2e996958754dcef1043f6ce
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types.go
@@ -0,0 +1,71 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/util/intstr"
+)
+
+// PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.
+type PodDisruptionBudgetSpec struct {
+ // The minimum number of pods that must be available simultaneously. This
+ // can be either an integer or a string specifying a percentage, e.g. "28%".
+ MinAvailable intstr.IntOrString `json:"minAvailable,omitempty" protobuf:"bytes,1,opt,name=minAvailable"`
+
+ // Label query over pods whose evictions are managed by the disruption
+ // budget.
+ Selector *unversioned.LabelSelector `json:"selector,omitempty" protobuf:"bytes,2,opt,name=selector"`
+}
+
+// PodDisruptionBudgetStatus represents information about the status of a
+// PodDisruptionBudget. Status may trail the actual state of a system.
+type PodDisruptionBudgetStatus struct {
+ // Whether or not a disruption is currently allowed.
+ PodDisruptionAllowed bool `json:"disruptionAllowed" protobuf:"varint,1,opt,name=disruptionAllowed"`
+
+ // current number of healthy pods
+ CurrentHealthy int32 `json:"currentHealthy" protobuf:"varint,2,opt,name=currentHealthy"`
+
+ // minimum desired number of healthy pods
+ DesiredHealthy int32 `json:"desiredHealthy" protobuf:"varint,3,opt,name=desiredHealthy"`
+
+ // total number of pods counted by this disruption budget
+ ExpectedPods int32 `json:"expectedPods" protobuf:"varint,4,opt,name=expectedPods"`
+}
+
+// +genclient=true,noMethods=true
+
+// PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods
+type PodDisruptionBudget struct {
+ unversioned.TypeMeta `json:",inline"`
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Specification of the desired behavior of the PodDisruptionBudget.
+ Spec PodDisruptionBudgetSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+ // Most recently observed status of the PodDisruptionBudget.
+ Status PodDisruptionBudgetStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// PodDisruptionBudgetList is a collection of PodDisruptionBudgets.
+type PodDisruptionBudgetList struct {
+ unversioned.TypeMeta `json:",inline"`
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+ Items []PodDisruptionBudget `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types_swagger_doc_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ca1782f4f98e161df49405e97f2a7bf5cf73b96
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/policy/v1alpha1/types_swagger_doc_generated.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+// This file contains a collection of methods that can be used from go-restful to
+// generate Swagger API documentation for its models. Please read this PR for more
+// information on the implementation: https://github.com/emicklei/go-restful/pull/215
+//
+// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if
+// they are on one line! For multiple line or blocks that you want to ignore use ---.
+// Any context after a --- is ignored.
+//
+// Those methods can be generated by using hack/update-generated-swagger-docs.sh
+
+// AUTO-GENERATED FUNCTIONS START HERE
+var map_PodDisruptionBudget = map[string]string{
+ "": "PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods",
+ "spec": "Specification of the desired behavior of the PodDisruptionBudget.",
+ "status": "Most recently observed status of the PodDisruptionBudget.",
+}
+
+func (PodDisruptionBudget) SwaggerDoc() map[string]string {
+ return map_PodDisruptionBudget
+}
+
+var map_PodDisruptionBudgetList = map[string]string{
+ "": "PodDisruptionBudgetList is a collection of PodDisruptionBudgets.",
+}
+
+func (PodDisruptionBudgetList) SwaggerDoc() map[string]string {
+ return map_PodDisruptionBudgetList
+}
+
+var map_PodDisruptionBudgetSpec = map[string]string{
+ "": "PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.",
+ "minAvailable": "The minimum number of pods that must be available simultaneously. This can be either an integer or a string specifying a percentage, e.g. \"28%\".",
+ "selector": "Label query over pods whose evictions are managed by the disruption budget.",
+}
+
+func (PodDisruptionBudgetSpec) SwaggerDoc() map[string]string {
+ return map_PodDisruptionBudgetSpec
+}
+
+var map_PodDisruptionBudgetStatus = map[string]string{
+ "": "PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.",
+ "disruptionAllowed": "Whether or not a disruption is currently allowed.",
+ "currentHealthy": "current number of healthy pods",
+ "desiredHealthy": "minimum desired number of healthy pods",
+ "expectedPods": "total number of pods counted by this disruption budget",
+}
+
+func (PodDisruptionBudgetStatus) SwaggerDoc() map[string]string {
+ return map_PodDisruptionBudgetStatus
+}
+
+// AUTO-GENERATED FUNCTIONS END HERE
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..5e9339a989bcb3b19e3beccdbe3b455689705f35
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/deep_copy_generated.go
@@ -0,0 +1,274 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package rbac
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ runtime "k8s.io/kubernetes/pkg/runtime"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_rbac_ClusterRole,
+ DeepCopy_rbac_ClusterRoleBinding,
+ DeepCopy_rbac_ClusterRoleBindingList,
+ DeepCopy_rbac_ClusterRoleList,
+ DeepCopy_rbac_PolicyRule,
+ DeepCopy_rbac_Role,
+ DeepCopy_rbac_RoleBinding,
+ DeepCopy_rbac_RoleBindingList,
+ DeepCopy_rbac_RoleList,
+ DeepCopy_rbac_Subject,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_rbac_ClusterRole(in ClusterRole, out *ClusterRole, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_PolicyRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_ClusterRoleBinding(in ClusterRoleBinding, out *ClusterRoleBinding, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := in.Subjects, &out.Subjects
+ *out = make([]Subject, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_Subject(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ if err := api.DeepCopy_api_ObjectReference(in.RoleRef, &out.RoleRef, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_rbac_ClusterRoleBindingList(in ClusterRoleBindingList, out *ClusterRoleBindingList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ClusterRoleBinding, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_ClusterRoleBinding(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_ClusterRoleList(in ClusterRoleList, out *ClusterRoleList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ClusterRole, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_ClusterRole(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_PolicyRule(in PolicyRule, out *PolicyRule, c *conversion.Cloner) error {
+ if in.Verbs != nil {
+ in, out := in.Verbs, &out.Verbs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Verbs = nil
+ }
+ if in.AttributeRestrictions == nil {
+ out.AttributeRestrictions = nil
+ } else if newVal, err := c.DeepCopy(in.AttributeRestrictions); err != nil {
+ return err
+ } else {
+ out.AttributeRestrictions = newVal.(runtime.Object)
+ }
+ if in.APIGroups != nil {
+ in, out := in.APIGroups, &out.APIGroups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.APIGroups = nil
+ }
+ if in.Resources != nil {
+ in, out := in.Resources, &out.Resources
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Resources = nil
+ }
+ if in.ResourceNames != nil {
+ in, out := in.ResourceNames, &out.ResourceNames
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.ResourceNames = nil
+ }
+ if in.NonResourceURLs != nil {
+ in, out := in.NonResourceURLs, &out.NonResourceURLs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.NonResourceURLs = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_Role(in Role, out *Role, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_PolicyRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_RoleBinding(in RoleBinding, out *RoleBinding, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := api.DeepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := in.Subjects, &out.Subjects
+ *out = make([]Subject, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_Subject(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ if err := api.DeepCopy_api_ObjectReference(in.RoleRef, &out.RoleRef, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_rbac_RoleBindingList(in RoleBindingList, out *RoleBindingList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]RoleBinding, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_RoleBinding(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_RoleList(in RoleList, out *RoleList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Role, len(in))
+ for i := range in {
+ if err := DeepCopy_rbac_Role(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_rbac_Subject(in Subject, out *Subject, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.APIVersion = in.APIVersion
+ out.Name = in.Name
+ out.Namespace = in.Namespace
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..15f91da2c380a5f39cd45b92204537bc63b8f125
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +groupName=rbac.authorization.k8s.io
+package rbac
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/install/install.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/install/install.go
new file mode 100644
index 0000000000000000000000000000000000000000..8cac247f4cad6ecf7be27349a0470b7cff942b2b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/install/install.go
@@ -0,0 +1,130 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 install installs the batch API group, making it available as
+// an option to all of the API encoding/decoding machinery.
+package install
+
+import (
+ "fmt"
+
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apimachinery"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/apis/rbac/v1alpha1"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/sets"
+)
+
+const importPrefix = "k8s.io/kubernetes/pkg/apis/rbac"
+
+var accessor = meta.NewAccessor()
+
+// availableVersions lists all known external versions for this group from most preferred to least preferred
+var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
+
+func init() {
+ registered.RegisterVersions(availableVersions)
+ externalVersions := []unversioned.GroupVersion{}
+ for _, v := range availableVersions {
+ if registered.IsAllowedVersion(v) {
+ externalVersions = append(externalVersions, v)
+ }
+ }
+ if len(externalVersions) == 0 {
+ glog.V(4).Infof("No version is registered for group %v", rbac.GroupName)
+ return
+ }
+
+ if err := registered.EnableVersions(externalVersions...); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+ if err := enableVersions(externalVersions); err != nil {
+ glog.V(4).Infof("%v", err)
+ return
+ }
+}
+
+// TODO: enableVersions should be centralized rather than spread in each API
+// group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+ addVersionsToScheme(externalVersions...)
+ preferredExternalVersion := externalVersions[0]
+
+ groupMeta := apimachinery.GroupMeta{
+ GroupVersion: preferredExternalVersion,
+ GroupVersions: externalVersions,
+ RESTMapper: newRESTMapper(externalVersions),
+ SelfLinker: runtime.SelfLinker(accessor),
+ InterfacesFor: interfacesFor,
+ }
+
+ if err := registered.RegisterGroup(groupMeta); err != nil {
+ return err
+ }
+ api.RegisterRESTMapper(groupMeta.RESTMapper)
+ return nil
+}
+
+func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
+ rootScoped := sets.NewString(
+ "ClusterRole",
+ "ClusterRoleBinding",
+ )
+
+ ignoredKinds := sets.NewString()
+
+ return api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
+}
+
+// interfacesFor returns the default Codec and ResourceVersioner for a given version
+// string, or an error if the version is not known.
+func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+ switch version {
+ case v1alpha1.SchemeGroupVersion:
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: accessor,
+ }, nil
+ default:
+ g, _ := registered.Group(rbac.GroupName)
+ return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+ }
+}
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+ // add the internal version to Scheme
+ rbac.AddToScheme(api.Scheme)
+ // add the enabled external versions to Scheme
+ for _, v := range externalVersions {
+ if !registered.IsEnabledVersion(v) {
+ glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+ continue
+ }
+ switch v {
+ case v1alpha1.SchemeGroupVersion:
+ v1alpha1.AddToScheme(api.Scheme)
+ }
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/register.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..58464d74d7e14da829e14d64dcaf0efc940f30e7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/register.go
@@ -0,0 +1,64 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 rbac
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+const GroupName = "rbac.authorization.k8s.io"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) unversioned.GroupKind {
+ return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns back a Group qualified GroupResource
+func Resource(resource string) unversioned.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ // Add the API to Scheme.
+ addKnownTypes(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Role{},
+ &RoleBinding{},
+ &RoleBindingList{},
+ &RoleList{},
+
+ &ClusterRole{},
+ &ClusterRoleBinding{},
+ &ClusterRoleBindingList{},
+ &ClusterRoleList{},
+
+ &api.ListOptions{},
+ &api.DeleteOptions{},
+ &api.ExportOptions{},
+ )
+ versioned.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/types.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..a35eb7db957260f33ee9255676c19e3c8a1dcb07
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/types.go
@@ -0,0 +1,176 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 rbac
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Authorization is calculated against
+// 1. evaluation of ClusterRoleBindings - short circuit on match
+// 2. evaluation of RoleBindings in the namespace requested - short circuit on match
+// 3. deny by default
+
+const (
+ APIGroupAll = "*"
+ ResourceAll = "*"
+ VerbAll = "*"
+ NonResourceAll = "*"
+
+ GroupKind = "Group"
+ ServiceAccountKind = "ServiceAccount"
+ UserKind = "User"
+
+ UserAll = "*"
+)
+
+// 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.
+type PolicyRule struct {
+ // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds.
+ Verbs []string
+ // AttributeRestrictions will vary depending on what the Authorizer/AuthorizationAttributeBuilder pair supports.
+ // If the Authorizer does not recognize how to handle the AttributeRestrictions, the Authorizer should report an error.
+ AttributeRestrictions runtime.Object
+ // 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.
+ APIGroups []string
+ // Resources is a list of resources this rule applies to. ResourceAll represents all resources.
+ Resources []string
+ // ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.
+ ResourceNames []string
+ // 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
+ // If an action is not a resource API request, then the URL is split on '/' and is checked against the NonResourceURLs to look for a match.
+ // Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding.
+ NonResourceURLs []string
+}
+
+// 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.
+type Subject struct {
+ // 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.
+ Kind string
+ // APIVersion holds the API group and version of the referenced object. For non-object references such as "Group" and "User" this is
+ // expected to be API version of this API group. For example "rbac/v1alpha1".
+ APIVersion string
+ // Name of the object being referenced.
+ Name string
+ // 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.
+ Namespace string
+}
+
+// +genclient=true
+
+// Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
+type Role struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ api.ObjectMeta
+
+ // Rules holds all the PolicyRules for this Role
+ Rules []PolicyRule
+}
+
+// +genclient=true
+
+// 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.
+type RoleBinding struct {
+ unversioned.TypeMeta
+ api.ObjectMeta
+
+ // Subjects holds references to the objects the role applies to.
+ Subjects []Subject
+
+ // 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.
+ RoleRef api.ObjectReference
+}
+
+// RoleBindingList is a collection of RoleBindings
+type RoleBindingList struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ unversioned.ListMeta
+
+ // Items is a list of roleBindings
+ Items []RoleBinding
+}
+
+// RoleList is a collection of Roles
+type RoleList struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ unversioned.ListMeta
+
+ // Items is a list of roles
+ Items []Role
+}
+
+// +genclient=true,nonNamespaced=true
+
+// ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.
+type ClusterRole struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ api.ObjectMeta
+
+ // Rules holds all the PolicyRules for this ClusterRole
+ Rules []PolicyRule
+}
+
+// +genclient=true,nonNamespaced=true
+
+// ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace,
+// and adds who information via Subject.
+type ClusterRoleBinding struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ api.ObjectMeta
+
+ // Subjects holds references to the objects the role applies to.
+ Subjects []Subject
+
+ // RoleRef can only reference a ClusterRole in the global namespace.
+ // If the RoleRef cannot be resolved, the Authorizer must return an error.
+ RoleRef api.ObjectReference
+}
+
+// ClusterRoleBindingList is a collection of ClusterRoleBindings
+type ClusterRoleBindingList struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ unversioned.ListMeta
+
+ // Items is a list of ClusterRoleBindings
+ Items []ClusterRoleBinding
+}
+
+// ClusterRoleList is a collection of ClusterRoles
+type ClusterRoleList struct {
+ unversioned.TypeMeta
+ // Standard object's metadata.
+ unversioned.ListMeta
+
+ // Items is a list of ClusterRoles
+ Items []ClusterRole
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/conversion_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/conversion_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..f176aa090663578306a4dde72ac3d0aa8e3c71a9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/conversion_generated.go
@@ -0,0 +1,536 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by conversion-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ rbac "k8s.io/kubernetes/pkg/apis/rbac"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ runtime "k8s.io/kubernetes/pkg/runtime"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedConversionFuncs(
+ Convert_v1alpha1_ClusterRole_To_rbac_ClusterRole,
+ Convert_rbac_ClusterRole_To_v1alpha1_ClusterRole,
+ Convert_v1alpha1_ClusterRoleBinding_To_rbac_ClusterRoleBinding,
+ Convert_rbac_ClusterRoleBinding_To_v1alpha1_ClusterRoleBinding,
+ Convert_v1alpha1_ClusterRoleBindingList_To_rbac_ClusterRoleBindingList,
+ Convert_rbac_ClusterRoleBindingList_To_v1alpha1_ClusterRoleBindingList,
+ Convert_v1alpha1_ClusterRoleList_To_rbac_ClusterRoleList,
+ Convert_rbac_ClusterRoleList_To_v1alpha1_ClusterRoleList,
+ Convert_v1alpha1_PolicyRule_To_rbac_PolicyRule,
+ Convert_rbac_PolicyRule_To_v1alpha1_PolicyRule,
+ Convert_v1alpha1_Role_To_rbac_Role,
+ Convert_rbac_Role_To_v1alpha1_Role,
+ Convert_v1alpha1_RoleBinding_To_rbac_RoleBinding,
+ Convert_rbac_RoleBinding_To_v1alpha1_RoleBinding,
+ Convert_v1alpha1_RoleBindingList_To_rbac_RoleBindingList,
+ Convert_rbac_RoleBindingList_To_v1alpha1_RoleBindingList,
+ Convert_v1alpha1_RoleList_To_rbac_RoleList,
+ Convert_rbac_RoleList_To_v1alpha1_RoleList,
+ Convert_v1alpha1_Subject_To_rbac_Subject,
+ Convert_rbac_Subject_To_v1alpha1_Subject,
+ ); err != nil {
+ // if one of the conversion functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func autoConvert_v1alpha1_ClusterRole_To_rbac_ClusterRole(in *ClusterRole, out *rbac.ClusterRole, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]rbac.PolicyRule, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_PolicyRule_To_rbac_PolicyRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_ClusterRole_To_rbac_ClusterRole(in *ClusterRole, out *rbac.ClusterRole, s conversion.Scope) error {
+ return autoConvert_v1alpha1_ClusterRole_To_rbac_ClusterRole(in, out, s)
+}
+
+func autoConvert_rbac_ClusterRole_To_v1alpha1_ClusterRole(in *rbac.ClusterRole, out *ClusterRole, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_PolicyRule_To_v1alpha1_PolicyRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_rbac_ClusterRole_To_v1alpha1_ClusterRole(in *rbac.ClusterRole, out *ClusterRole, s conversion.Scope) error {
+ return autoConvert_rbac_ClusterRole_To_v1alpha1_ClusterRole(in, out, s)
+}
+
+func autoConvert_v1alpha1_ClusterRoleBinding_To_rbac_ClusterRoleBinding(in *ClusterRoleBinding, out *rbac.ClusterRoleBinding, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := &in.Subjects, &out.Subjects
+ *out = make([]rbac.Subject, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_Subject_To_rbac_Subject(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.RoleRef, &out.RoleRef, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1alpha1_ClusterRoleBinding_To_rbac_ClusterRoleBinding(in *ClusterRoleBinding, out *rbac.ClusterRoleBinding, s conversion.Scope) error {
+ return autoConvert_v1alpha1_ClusterRoleBinding_To_rbac_ClusterRoleBinding(in, out, s)
+}
+
+func autoConvert_rbac_ClusterRoleBinding_To_v1alpha1_ClusterRoleBinding(in *rbac.ClusterRoleBinding, out *ClusterRoleBinding, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := &in.Subjects, &out.Subjects
+ *out = make([]Subject, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_Subject_To_v1alpha1_Subject(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.RoleRef, &out.RoleRef, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_rbac_ClusterRoleBinding_To_v1alpha1_ClusterRoleBinding(in *rbac.ClusterRoleBinding, out *ClusterRoleBinding, s conversion.Scope) error {
+ return autoConvert_rbac_ClusterRoleBinding_To_v1alpha1_ClusterRoleBinding(in, out, s)
+}
+
+func autoConvert_v1alpha1_ClusterRoleBindingList_To_rbac_ClusterRoleBindingList(in *ClusterRoleBindingList, out *rbac.ClusterRoleBindingList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]rbac.ClusterRoleBinding, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_ClusterRoleBinding_To_rbac_ClusterRoleBinding(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_ClusterRoleBindingList_To_rbac_ClusterRoleBindingList(in *ClusterRoleBindingList, out *rbac.ClusterRoleBindingList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_ClusterRoleBindingList_To_rbac_ClusterRoleBindingList(in, out, s)
+}
+
+func autoConvert_rbac_ClusterRoleBindingList_To_v1alpha1_ClusterRoleBindingList(in *rbac.ClusterRoleBindingList, out *ClusterRoleBindingList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ClusterRoleBinding, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_ClusterRoleBinding_To_v1alpha1_ClusterRoleBinding(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_rbac_ClusterRoleBindingList_To_v1alpha1_ClusterRoleBindingList(in *rbac.ClusterRoleBindingList, out *ClusterRoleBindingList, s conversion.Scope) error {
+ return autoConvert_rbac_ClusterRoleBindingList_To_v1alpha1_ClusterRoleBindingList(in, out, s)
+}
+
+func autoConvert_v1alpha1_ClusterRoleList_To_rbac_ClusterRoleList(in *ClusterRoleList, out *rbac.ClusterRoleList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]rbac.ClusterRole, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_ClusterRole_To_rbac_ClusterRole(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_ClusterRoleList_To_rbac_ClusterRoleList(in *ClusterRoleList, out *rbac.ClusterRoleList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_ClusterRoleList_To_rbac_ClusterRoleList(in, out, s)
+}
+
+func autoConvert_rbac_ClusterRoleList_To_v1alpha1_ClusterRoleList(in *rbac.ClusterRoleList, out *ClusterRoleList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]ClusterRole, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_ClusterRole_To_v1alpha1_ClusterRole(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_rbac_ClusterRoleList_To_v1alpha1_ClusterRoleList(in *rbac.ClusterRoleList, out *ClusterRoleList, s conversion.Scope) error {
+ return autoConvert_rbac_ClusterRoleList_To_v1alpha1_ClusterRoleList(in, out, s)
+}
+
+func autoConvert_v1alpha1_PolicyRule_To_rbac_PolicyRule(in *PolicyRule, out *rbac.PolicyRule, s conversion.Scope) error {
+ out.Verbs = in.Verbs
+ if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.AttributeRestrictions, &out.AttributeRestrictions, s); err != nil {
+ return err
+ }
+ out.APIGroups = in.APIGroups
+ out.Resources = in.Resources
+ out.ResourceNames = in.ResourceNames
+ out.NonResourceURLs = in.NonResourceURLs
+ return nil
+}
+
+func Convert_v1alpha1_PolicyRule_To_rbac_PolicyRule(in *PolicyRule, out *rbac.PolicyRule, s conversion.Scope) error {
+ return autoConvert_v1alpha1_PolicyRule_To_rbac_PolicyRule(in, out, s)
+}
+
+func autoConvert_rbac_PolicyRule_To_v1alpha1_PolicyRule(in *rbac.PolicyRule, out *PolicyRule, s conversion.Scope) error {
+ out.Verbs = in.Verbs
+ if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.AttributeRestrictions, &out.AttributeRestrictions, s); err != nil {
+ return err
+ }
+ out.APIGroups = in.APIGroups
+ out.Resources = in.Resources
+ out.ResourceNames = in.ResourceNames
+ out.NonResourceURLs = in.NonResourceURLs
+ return nil
+}
+
+func Convert_rbac_PolicyRule_To_v1alpha1_PolicyRule(in *rbac.PolicyRule, out *PolicyRule, s conversion.Scope) error {
+ return autoConvert_rbac_PolicyRule_To_v1alpha1_PolicyRule(in, out, s)
+}
+
+func autoConvert_v1alpha1_Role_To_rbac_Role(in *Role, out *rbac.Role, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]rbac.PolicyRule, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_PolicyRule_To_rbac_PolicyRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_Role_To_rbac_Role(in *Role, out *rbac.Role, s conversion.Scope) error {
+ return autoConvert_v1alpha1_Role_To_rbac_Role(in, out, s)
+}
+
+func autoConvert_rbac_Role_To_v1alpha1_Role(in *rbac.Role, out *Role, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := &in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_PolicyRule_To_v1alpha1_PolicyRule(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func Convert_rbac_Role_To_v1alpha1_Role(in *rbac.Role, out *Role, s conversion.Scope) error {
+ return autoConvert_rbac_Role_To_v1alpha1_Role(in, out, s)
+}
+
+func autoConvert_v1alpha1_RoleBinding_To_rbac_RoleBinding(in *RoleBinding, out *rbac.RoleBinding, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := &in.Subjects, &out.Subjects
+ *out = make([]rbac.Subject, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_Subject_To_rbac_Subject(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.RoleRef, &out.RoleRef, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_v1alpha1_RoleBinding_To_rbac_RoleBinding(in *RoleBinding, out *rbac.RoleBinding, s conversion.Scope) error {
+ return autoConvert_v1alpha1_RoleBinding_To_rbac_RoleBinding(in, out, s)
+}
+
+func autoConvert_rbac_RoleBinding_To_v1alpha1_RoleBinding(in *rbac.RoleBinding, out *RoleBinding, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := &in.Subjects, &out.Subjects
+ *out = make([]Subject, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_Subject_To_v1alpha1_Subject(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ // TODO: Inefficient conversion - can we improve it?
+ if err := s.Convert(&in.RoleRef, &out.RoleRef, 0); err != nil {
+ return err
+ }
+ return nil
+}
+
+func Convert_rbac_RoleBinding_To_v1alpha1_RoleBinding(in *rbac.RoleBinding, out *RoleBinding, s conversion.Scope) error {
+ return autoConvert_rbac_RoleBinding_To_v1alpha1_RoleBinding(in, out, s)
+}
+
+func autoConvert_v1alpha1_RoleBindingList_To_rbac_RoleBindingList(in *RoleBindingList, out *rbac.RoleBindingList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]rbac.RoleBinding, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_RoleBinding_To_rbac_RoleBinding(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_RoleBindingList_To_rbac_RoleBindingList(in *RoleBindingList, out *rbac.RoleBindingList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_RoleBindingList_To_rbac_RoleBindingList(in, out, s)
+}
+
+func autoConvert_rbac_RoleBindingList_To_v1alpha1_RoleBindingList(in *rbac.RoleBindingList, out *RoleBindingList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]RoleBinding, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_RoleBinding_To_v1alpha1_RoleBinding(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_rbac_RoleBindingList_To_v1alpha1_RoleBindingList(in *rbac.RoleBindingList, out *RoleBindingList, s conversion.Scope) error {
+ return autoConvert_rbac_RoleBindingList_To_v1alpha1_RoleBindingList(in, out, s)
+}
+
+func autoConvert_v1alpha1_RoleList_To_rbac_RoleList(in *RoleList, out *rbac.RoleList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]rbac.Role, len(*in))
+ for i := range *in {
+ if err := Convert_v1alpha1_Role_To_rbac_Role(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_v1alpha1_RoleList_To_rbac_RoleList(in *RoleList, out *rbac.RoleList, s conversion.Scope) error {
+ return autoConvert_v1alpha1_RoleList_To_rbac_RoleList(in, out, s)
+}
+
+func autoConvert_rbac_RoleList_To_v1alpha1_RoleList(in *rbac.RoleList, out *RoleList, s conversion.Scope) error {
+ if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
+ return err
+ }
+ if err := api.Convert_unversioned_ListMeta_To_unversioned_ListMeta(&in.ListMeta, &out.ListMeta, s); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]Role, len(*in))
+ for i := range *in {
+ if err := Convert_rbac_Role_To_v1alpha1_Role(&(*in)[i], &(*out)[i], s); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func Convert_rbac_RoleList_To_v1alpha1_RoleList(in *rbac.RoleList, out *RoleList, s conversion.Scope) error {
+ return autoConvert_rbac_RoleList_To_v1alpha1_RoleList(in, out, s)
+}
+
+func autoConvert_v1alpha1_Subject_To_rbac_Subject(in *Subject, out *rbac.Subject, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.APIVersion = in.APIVersion
+ out.Name = in.Name
+ out.Namespace = in.Namespace
+ return nil
+}
+
+func Convert_v1alpha1_Subject_To_rbac_Subject(in *Subject, out *rbac.Subject, s conversion.Scope) error {
+ return autoConvert_v1alpha1_Subject_To_rbac_Subject(in, out, s)
+}
+
+func autoConvert_rbac_Subject_To_v1alpha1_Subject(in *rbac.Subject, out *Subject, s conversion.Scope) error {
+ out.Kind = in.Kind
+ out.APIVersion = in.APIVersion
+ out.Name = in.Name
+ out.Namespace = in.Namespace
+ return nil
+}
+
+func Convert_rbac_Subject_To_v1alpha1_Subject(in *rbac.Subject, out *Subject, s conversion.Scope) error {
+ return autoConvert_rbac_Subject_To_v1alpha1_Subject(in, out, s)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..f898a434baf592ceadf09a85c1e191c26b401940
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/deep_copy_generated.go
@@ -0,0 +1,271 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ v1 "k8s.io/kubernetes/pkg/api/v1"
+ conversion "k8s.io/kubernetes/pkg/conversion"
+ runtime "k8s.io/kubernetes/pkg/runtime"
+)
+
+func init() {
+ if err := api.Scheme.AddGeneratedDeepCopyFuncs(
+ DeepCopy_v1alpha1_ClusterRole,
+ DeepCopy_v1alpha1_ClusterRoleBinding,
+ DeepCopy_v1alpha1_ClusterRoleBindingList,
+ DeepCopy_v1alpha1_ClusterRoleList,
+ DeepCopy_v1alpha1_PolicyRule,
+ DeepCopy_v1alpha1_Role,
+ DeepCopy_v1alpha1_RoleBinding,
+ DeepCopy_v1alpha1_RoleBindingList,
+ DeepCopy_v1alpha1_RoleList,
+ DeepCopy_v1alpha1_Subject,
+ ); err != nil {
+ // if one of the deep copy functions is malformed, detect it immediately.
+ panic(err)
+ }
+}
+
+func DeepCopy_v1alpha1_ClusterRole(in ClusterRole, out *ClusterRole, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_PolicyRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_ClusterRoleBinding(in ClusterRoleBinding, out *ClusterRoleBinding, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := in.Subjects, &out.Subjects
+ *out = make([]Subject, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_Subject(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ if err := v1.DeepCopy_v1_ObjectReference(in.RoleRef, &out.RoleRef, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_ClusterRoleBindingList(in ClusterRoleBindingList, out *ClusterRoleBindingList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ClusterRoleBinding, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_ClusterRoleBinding(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_ClusterRoleList(in ClusterRoleList, out *ClusterRoleList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]ClusterRole, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_ClusterRole(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_PolicyRule(in PolicyRule, out *PolicyRule, c *conversion.Cloner) error {
+ if in.Verbs != nil {
+ in, out := in.Verbs, &out.Verbs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Verbs = nil
+ }
+ if err := runtime.DeepCopy_runtime_RawExtension(in.AttributeRestrictions, &out.AttributeRestrictions, c); err != nil {
+ return err
+ }
+ if in.APIGroups != nil {
+ in, out := in.APIGroups, &out.APIGroups
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.APIGroups = nil
+ }
+ if in.Resources != nil {
+ in, out := in.Resources, &out.Resources
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.Resources = nil
+ }
+ if in.ResourceNames != nil {
+ in, out := in.ResourceNames, &out.ResourceNames
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.ResourceNames = nil
+ }
+ if in.NonResourceURLs != nil {
+ in, out := in.NonResourceURLs, &out.NonResourceURLs
+ *out = make([]string, len(in))
+ copy(*out, in)
+ } else {
+ out.NonResourceURLs = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_Role(in Role, out *Role, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Rules != nil {
+ in, out := in.Rules, &out.Rules
+ *out = make([]PolicyRule, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_PolicyRule(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Rules = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_RoleBinding(in RoleBinding, out *RoleBinding, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := v1.DeepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil {
+ return err
+ }
+ if in.Subjects != nil {
+ in, out := in.Subjects, &out.Subjects
+ *out = make([]Subject, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_Subject(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Subjects = nil
+ }
+ if err := v1.DeepCopy_v1_ObjectReference(in.RoleRef, &out.RoleRef, c); err != nil {
+ return err
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_RoleBindingList(in RoleBindingList, out *RoleBindingList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]RoleBinding, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_RoleBinding(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_RoleList(in RoleList, out *RoleList, c *conversion.Cloner) error {
+ if err := unversioned.DeepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if err := unversioned.DeepCopy_unversioned_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil {
+ return err
+ }
+ if in.Items != nil {
+ in, out := in.Items, &out.Items
+ *out = make([]Role, len(in))
+ for i := range in {
+ if err := DeepCopy_v1alpha1_Role(in[i], &(*out)[i], c); err != nil {
+ return err
+ }
+ }
+ } else {
+ out.Items = nil
+ }
+ return nil
+}
+
+func DeepCopy_v1alpha1_Subject(in Subject, out *Subject, c *conversion.Cloner) error {
+ out.Kind = in.Kind
+ out.APIVersion = in.APIVersion
+ out.Name = in.Name
+ out.Namespace = in.Namespace
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/doc.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..6873ebb101ff0aff758b9e3a91cb31b076dd9e63
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/doc.go
@@ -0,0 +1,19 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// +groupName=rbac.authorization.k8s.io
+// +genconversion=true
+package v1alpha1
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..54b03ed15d1de9c9216a5c68146b71e174a09b06
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.pb.go
@@ -0,0 +1,2209 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package v1alpha1 is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.proto
+
+ It has these top-level messages:
+ ClusterRole
+ ClusterRoleBinding
+ ClusterRoleBindingList
+ ClusterRoleList
+ PolicyRule
+ Role
+ RoleBinding
+ RoleBindingList
+ RoleList
+ Subject
+*/
+package v1alpha1
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *ClusterRole) Reset() { *m = ClusterRole{} }
+func (m *ClusterRole) String() string { return proto.CompactTextString(m) }
+func (*ClusterRole) ProtoMessage() {}
+
+func (m *ClusterRoleBinding) Reset() { *m = ClusterRoleBinding{} }
+func (m *ClusterRoleBinding) String() string { return proto.CompactTextString(m) }
+func (*ClusterRoleBinding) ProtoMessage() {}
+
+func (m *ClusterRoleBindingList) Reset() { *m = ClusterRoleBindingList{} }
+func (m *ClusterRoleBindingList) String() string { return proto.CompactTextString(m) }
+func (*ClusterRoleBindingList) ProtoMessage() {}
+
+func (m *ClusterRoleList) Reset() { *m = ClusterRoleList{} }
+func (m *ClusterRoleList) String() string { return proto.CompactTextString(m) }
+func (*ClusterRoleList) ProtoMessage() {}
+
+func (m *PolicyRule) Reset() { *m = PolicyRule{} }
+func (m *PolicyRule) String() string { return proto.CompactTextString(m) }
+func (*PolicyRule) ProtoMessage() {}
+
+func (m *Role) Reset() { *m = Role{} }
+func (m *Role) String() string { return proto.CompactTextString(m) }
+func (*Role) ProtoMessage() {}
+
+func (m *RoleBinding) Reset() { *m = RoleBinding{} }
+func (m *RoleBinding) String() string { return proto.CompactTextString(m) }
+func (*RoleBinding) ProtoMessage() {}
+
+func (m *RoleBindingList) Reset() { *m = RoleBindingList{} }
+func (m *RoleBindingList) String() string { return proto.CompactTextString(m) }
+func (*RoleBindingList) ProtoMessage() {}
+
+func (m *RoleList) Reset() { *m = RoleList{} }
+func (m *RoleList) String() string { return proto.CompactTextString(m) }
+func (*RoleList) ProtoMessage() {}
+
+func (m *Subject) Reset() { *m = Subject{} }
+func (m *Subject) String() string { return proto.CompactTextString(m) }
+func (*Subject) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*ClusterRole)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.ClusterRole")
+ proto.RegisterType((*ClusterRoleBinding)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.ClusterRoleBinding")
+ proto.RegisterType((*ClusterRoleBindingList)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.ClusterRoleBindingList")
+ proto.RegisterType((*ClusterRoleList)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.ClusterRoleList")
+ proto.RegisterType((*PolicyRule)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.PolicyRule")
+ proto.RegisterType((*Role)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.Role")
+ proto.RegisterType((*RoleBinding)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.RoleBinding")
+ proto.RegisterType((*RoleBindingList)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.RoleBindingList")
+ proto.RegisterType((*RoleList)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.RoleList")
+ proto.RegisterType((*Subject)(nil), "k8s.io.kubernetes.pkg.apis.rbac.v1alpha1.Subject")
+}
+func (m *ClusterRole) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterRole) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n1, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ if len(m.Rules) > 0 {
+ for _, msg := range m.Rules {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ClusterRoleBinding) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterRoleBinding) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n2, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n2
+ if len(m.Subjects) > 0 {
+ for _, msg := range m.Subjects {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RoleRef.Size()))
+ n3, err := m.RoleRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n3
+ return i, nil
+}
+
+func (m *ClusterRoleBindingList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterRoleBindingList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n4, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n4
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *ClusterRoleList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *ClusterRoleList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n5, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n5
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *PolicyRule) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *PolicyRule) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if len(m.Verbs) > 0 {
+ for _, s := range m.Verbs {
+ data[i] = 0xa
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.AttributeRestrictions.Size()))
+ n6, err := m.AttributeRestrictions.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n6
+ if len(m.APIGroups) > 0 {
+ for _, s := range m.APIGroups {
+ data[i] = 0x1a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.Resources) > 0 {
+ for _, s := range m.Resources {
+ data[i] = 0x22
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.ResourceNames) > 0 {
+ for _, s := range m.ResourceNames {
+ data[i] = 0x2a
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ if len(m.NonResourceURLs) > 0 {
+ for _, s := range m.NonResourceURLs {
+ data[i] = 0x32
+ i++
+ l = len(s)
+ for l >= 1<<7 {
+ data[i] = uint8(uint64(l)&0x7f | 0x80)
+ l >>= 7
+ i++
+ }
+ data[i] = uint8(l)
+ i++
+ i += copy(data[i:], s)
+ }
+ }
+ return i, nil
+}
+
+func (m *Role) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Role) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n7, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n7
+ if len(m.Rules) > 0 {
+ for _, msg := range m.Rules {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *RoleBinding) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RoleBinding) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
+ n8, err := m.ObjectMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n8
+ if len(m.Subjects) > 0 {
+ for _, msg := range m.Subjects {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.RoleRef.Size()))
+ n9, err := m.RoleRef.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n9
+ return i, nil
+}
+
+func (m *RoleBindingList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RoleBindingList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n10, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n10
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *RoleList) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RoleList) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
+ n11, err := m.ListMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n11
+ if len(m.Items) > 0 {
+ for _, msg := range m.Items {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(msg.Size()))
+ n, err := msg.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n
+ }
+ }
+ return i, nil
+}
+
+func (m *Subject) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Subject) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Name)))
+ i += copy(data[i:], m.Name)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Namespace)))
+ i += copy(data[i:], m.Namespace)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *ClusterRole) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Rules) > 0 {
+ for _, e := range m.Rules {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ClusterRoleBinding) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Subjects) > 0 {
+ for _, e := range m.Subjects {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.RoleRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *ClusterRoleBindingList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *ClusterRoleList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *PolicyRule) Size() (n int) {
+ var l int
+ _ = l
+ if len(m.Verbs) > 0 {
+ for _, s := range m.Verbs {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.AttributeRestrictions.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.APIGroups) > 0 {
+ for _, s := range m.APIGroups {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.Resources) > 0 {
+ for _, s := range m.Resources {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.ResourceNames) > 0 {
+ for _, s := range m.ResourceNames {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ if len(m.NonResourceURLs) > 0 {
+ for _, s := range m.NonResourceURLs {
+ l = len(s)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *Role) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Rules) > 0 {
+ for _, e := range m.Rules {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *RoleBinding) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ObjectMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Subjects) > 0 {
+ for _, e := range m.Subjects {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ l = m.RoleRef.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *RoleBindingList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *RoleList) Size() (n int) {
+ var l int
+ _ = l
+ l = m.ListMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if len(m.Items) > 0 {
+ for _, e := range m.Items {
+ l = e.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *Subject) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Name)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Namespace)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ClusterRole) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterRole: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterRole: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rules = append(m.Rules, PolicyRule{})
+ if err := m.Rules[len(m.Rules)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterRoleBinding) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterRoleBinding: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterRoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subjects = append(m.Subjects, Subject{})
+ if err := m.Subjects[len(m.Subjects)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.RoleRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterRoleBindingList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterRoleBindingList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterRoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ClusterRoleBinding{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *ClusterRoleList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ClusterRoleList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClusterRoleList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, ClusterRole{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *PolicyRule) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: PolicyRule: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PolicyRule: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Verbs = append(m.Verbs, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AttributeRestrictions", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.AttributeRestrictions.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIGroups = append(m.APIGroups, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Resources = append(m.Resources, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceNames", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ResourceNames = append(m.ResourceNames, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NonResourceURLs = append(m.NonResourceURLs, string(data[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Role) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Role: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Rules = append(m.Rules, PolicyRule{})
+ if err := m.Rules[len(m.Rules)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RoleBinding) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RoleBinding: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subjects = append(m.Subjects, Subject{})
+ if err := m.Subjects[len(m.Subjects)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.RoleRef.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RoleBindingList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RoleBindingList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, RoleBinding{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *RoleList) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RoleList: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RoleList: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Items = append(m.Items, Role{})
+ if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Subject) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Subject: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Subject: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Name = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Namespace = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.proto b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..15c63b2f5174d538e136b48874afffd6491cc52d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/generated.proto
@@ -0,0 +1,159 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.apis.rbac.v1alpha1;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/api/unversioned/generated.proto";
+import "k8s.io/kubernetes/pkg/api/v1/generated.proto";
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "v1alpha1";
+
+// ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.
+message ClusterRole {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Rules holds all the PolicyRules for this ClusterRole
+ repeated PolicyRule rules = 2;
+}
+
+// ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace,
+// and adds who information via Subject.
+message ClusterRoleBinding {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Subjects holds references to the objects the role applies to.
+ repeated Subject subjects = 2;
+
+ // RoleRef can only reference a ClusterRole in the global namespace.
+ // If the RoleRef cannot be resolved, the Authorizer must return an error.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectReference roleRef = 3;
+}
+
+// ClusterRoleBindingList is a collection of ClusterRoleBindings
+message ClusterRoleBindingList {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of ClusterRoleBindings
+ repeated ClusterRoleBinding items = 2;
+}
+
+// ClusterRoleList is a collection of ClusterRoles
+message ClusterRoleList {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of ClusterRoles
+ repeated ClusterRole items = 2;
+}
+
+// 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.
+message PolicyRule {
+ // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds.
+ repeated string verbs = 1;
+
+ // AttributeRestrictions will vary depending on what the Authorizer/AuthorizationAttributeBuilder pair supports.
+ // If the Authorizer does not recognize how to handle the AttributeRestrictions, the Authorizer should report an error.
+ optional k8s.io.kubernetes.pkg.runtime.RawExtension attributeRestrictions = 2;
+
+ // 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.
+ repeated string apiGroups = 3;
+
+ // Resources is a list of resources this rule applies to. ResourceAll represents all resources.
+ repeated string resources = 4;
+
+ // ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.
+ repeated string resourceNames = 5;
+
+ // NonResourceURLsSlice 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
+ // This name is intentionally different than the internal type so that the DefaultConvert works nicely and because the ordering may be different.
+ // Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding.
+ repeated string nonResourceURLs = 6;
+}
+
+// Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
+message Role {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Rules holds all the PolicyRules for this Role
+ repeated PolicyRule rules = 2;
+}
+
+// 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.
+message RoleBinding {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectMeta metadata = 1;
+
+ // Subjects holds references to the objects the role applies to.
+ repeated Subject subjects = 2;
+
+ // 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.
+ optional k8s.io.kubernetes.pkg.api.v1.ObjectReference roleRef = 3;
+}
+
+// RoleBindingList is a collection of RoleBindings
+message RoleBindingList {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of RoleBindings
+ repeated RoleBinding items = 2;
+}
+
+// RoleList is a collection of Roles
+message RoleList {
+ // Standard object's metadata.
+ optional k8s.io.kubernetes.pkg.api.unversioned.ListMeta metadata = 1;
+
+ // Items is a list of Roles
+ repeated Role items = 2;
+}
+
+// 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.
+message Subject {
+ // 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.
+ optional string kind = 1;
+
+ // APIVersion holds the API group and version of the referenced object.
+ optional string apiVersion = 2;
+
+ // Name of the object being referenced.
+ optional string name = 3;
+
+ // 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.
+ optional string namespace = 4;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/register.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..eadcb4fbdabb11ef84a845c11e93e3d62163ce0b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/register.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = unversioned.GroupVersion{Group: rbac.GroupName, Version: "v1alpha1"}
+
+func AddToScheme(scheme *runtime.Scheme) {
+ addKnownTypes(scheme)
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) {
+ scheme.AddKnownTypes(SchemeGroupVersion,
+ &Role{},
+ &RoleBinding{},
+ &RoleBindingList{},
+ &RoleList{},
+
+ &ClusterRole{},
+ &ClusterRoleBinding{},
+ &ClusterRoleBindingList{},
+ &ClusterRoleList{},
+
+ &v1.ListOptions{},
+ &v1.DeleteOptions{},
+ &v1.ExportOptions{},
+ )
+ versioned.AddToGroupVersion(scheme, SchemeGroupVersion)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.generated.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..58965dec0fcb4ba296a79391567f5f60e17b7e62
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.generated.go
@@ -0,0 +1,4327 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// ************************************************************
+// DO NOT EDIT.
+// THIS FILE IS AUTO-GENERATED BY codecgen.
+// ************************************************************
+
+package v1alpha1
+
+import (
+ "errors"
+ "fmt"
+ codec1978 "github.com/ugorji/go/codec"
+ pkg2_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
+ pkg3_v1 "k8s.io/kubernetes/pkg/api/v1"
+ pkg1_runtime "k8s.io/kubernetes/pkg/runtime"
+ pkg4_types "k8s.io/kubernetes/pkg/types"
+ "reflect"
+ "runtime"
+ time "time"
+)
+
+const (
+ // ----- content types ----
+ codecSelferC_UTF81234 = 1
+ codecSelferC_RAW1234 = 0
+ // ----- value types used ----
+ codecSelferValueTypeArray1234 = 10
+ codecSelferValueTypeMap1234 = 9
+ // ----- containerStateValues ----
+ codecSelfer_containerMapKey1234 = 2
+ codecSelfer_containerMapValue1234 = 3
+ codecSelfer_containerMapEnd1234 = 4
+ codecSelfer_containerArrayElem1234 = 6
+ codecSelfer_containerArrayEnd1234 = 7
+)
+
+var (
+ codecSelferBitsize1234 = uint8(reflect.TypeOf(uint(0)).Bits())
+ codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
+)
+
+type codecSelfer1234 struct{}
+
+func init() {
+ if codec1978.GenVersion != 5 {
+ _, file, _, _ := runtime.Caller(0)
+ err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
+ 5, codec1978.GenVersion, file)
+ panic(err)
+ }
+ if false { // reference the types, but skip this branch at build/run time
+ var v0 pkg2_unversioned.TypeMeta
+ var v1 pkg3_v1.ObjectMeta
+ var v2 pkg1_runtime.RawExtension
+ var v3 pkg4_types.UID
+ var v4 time.Time
+ _, _, _, _, _ = v0, v1, v2, v3, v4
+ }
+}
+
+func (x *PolicyRule) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [6]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = true
+ yyq2[4] = len(x.ResourceNames) != 0
+ yyq2[5] = len(x.NonResourceURLs) != 0
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(6)
+ } else {
+ yynn2 = 3
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Verbs == nil {
+ r.EncodeNil()
+ } else {
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Verbs, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("verbs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Verbs == nil {
+ r.EncodeNil()
+ } else {
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Verbs, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yy7 := &x.AttributeRestrictions
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy7) {
+ } else if !yym8 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy7)
+ } else {
+ z.EncFallback(yy7)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("attributeRestrictions"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy9 := &x.AttributeRestrictions
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy9) {
+ } else if !yym10 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy9)
+ } else {
+ z.EncFallback(yy9)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.APIGroups == nil {
+ r.EncodeNil()
+ } else {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.APIGroups, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiGroups"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.APIGroups == nil {
+ r.EncodeNil()
+ } else {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.APIGroups, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Resources == nil {
+ r.EncodeNil()
+ } else {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Resources, false, e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resources"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Resources == nil {
+ r.EncodeNil()
+ } else {
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.Resources, false, e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ if x.ResourceNames == nil {
+ r.EncodeNil()
+ } else {
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.ResourceNames, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceNames"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ResourceNames == nil {
+ r.EncodeNil()
+ } else {
+ yym19 := z.EncBinary()
+ _ = yym19
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.ResourceNames, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[5] {
+ if x.NonResourceURLs == nil {
+ r.EncodeNil()
+ } else {
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.NonResourceURLs, false, e)
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("nonResourceURLs"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.NonResourceURLs == nil {
+ r.EncodeNil()
+ } else {
+ yym22 := z.EncBinary()
+ _ = yym22
+ if false {
+ } else {
+ z.F.EncSliceStringV(x.NonResourceURLs, false, e)
+ }
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *PolicyRule) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *PolicyRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "verbs":
+ if r.TryDecodeAsNil() {
+ x.Verbs = nil
+ } else {
+ yyv4 := &x.Verbs
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv4, false, d)
+ }
+ }
+ case "attributeRestrictions":
+ if r.TryDecodeAsNil() {
+ x.AttributeRestrictions = pkg1_runtime.RawExtension{}
+ } else {
+ yyv6 := &x.AttributeRestrictions
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv6) {
+ } else if !yym7 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv6)
+ } else {
+ z.DecFallback(yyv6, false)
+ }
+ }
+ case "apiGroups":
+ if r.TryDecodeAsNil() {
+ x.APIGroups = nil
+ } else {
+ yyv8 := &x.APIGroups
+ yym9 := z.DecBinary()
+ _ = yym9
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv8, false, d)
+ }
+ }
+ case "resources":
+ if r.TryDecodeAsNil() {
+ x.Resources = nil
+ } else {
+ yyv10 := &x.Resources
+ yym11 := z.DecBinary()
+ _ = yym11
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv10, false, d)
+ }
+ }
+ case "resourceNames":
+ if r.TryDecodeAsNil() {
+ x.ResourceNames = nil
+ } else {
+ yyv12 := &x.ResourceNames
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv12, false, d)
+ }
+ }
+ case "nonResourceURLs":
+ if r.TryDecodeAsNil() {
+ x.NonResourceURLs = nil
+ } else {
+ yyv14 := &x.NonResourceURLs
+ yym15 := z.DecBinary()
+ _ = yym15
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv14, false, d)
+ }
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *PolicyRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj16 int
+ var yyb16 bool
+ var yyhl16 bool = l >= 0
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Verbs = nil
+ } else {
+ yyv17 := &x.Verbs
+ yym18 := z.DecBinary()
+ _ = yym18
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv17, false, d)
+ }
+ }
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.AttributeRestrictions = pkg1_runtime.RawExtension{}
+ } else {
+ yyv19 := &x.AttributeRestrictions
+ yym20 := z.DecBinary()
+ _ = yym20
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv19) {
+ } else if !yym20 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv19)
+ } else {
+ z.DecFallback(yyv19, false)
+ }
+ }
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIGroups = nil
+ } else {
+ yyv21 := &x.APIGroups
+ yym22 := z.DecBinary()
+ _ = yym22
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv21, false, d)
+ }
+ }
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Resources = nil
+ } else {
+ yyv23 := &x.Resources
+ yym24 := z.DecBinary()
+ _ = yym24
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv23, false, d)
+ }
+ }
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ResourceNames = nil
+ } else {
+ yyv25 := &x.ResourceNames
+ yym26 := z.DecBinary()
+ _ = yym26
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv25, false, d)
+ }
+ }
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.NonResourceURLs = nil
+ } else {
+ yyv27 := &x.NonResourceURLs
+ yym28 := z.DecBinary()
+ _ = yym28
+ if false {
+ } else {
+ z.F.DecSliceStringX(yyv27, false, d)
+ }
+ }
+ for {
+ yyj16++
+ if yyhl16 {
+ yyb16 = yyj16 > l
+ } else {
+ yyb16 = r.CheckBreak()
+ }
+ if yyb16 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj16-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Subject) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[1] = x.APIVersion != ""
+ yyq2[3] = x.Namespace != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym4 := z.EncBinary()
+ _ = yym4
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[1] {
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym8 := z.EncBinary()
+ _ = yym8
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym11 := z.EncBinary()
+ _ = yym11
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("namespace"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym14 := z.EncBinary()
+ _ = yym14
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Subject) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Subject) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ case "name":
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ case "namespace":
+ if r.TryDecodeAsNil() {
+ x.Namespace = ""
+ } else {
+ x.Namespace = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Subject) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj8 int
+ var yyb8 bool
+ var yyhl8 bool = l >= 0
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Name = ""
+ } else {
+ x.Name = string(r.DecodeString())
+ }
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Namespace = ""
+ } else {
+ x.Namespace = string(r.DecodeString())
+ }
+ for {
+ yyj8++
+ if yyhl8 {
+ yyb8 = yyj8 > l
+ } else {
+ yyb8 = r.CheckBreak()
+ }
+ if yyb8 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj8-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *Role) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePolicyRule(([]PolicyRule)(x.Rules), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rules"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePolicyRule(([]PolicyRule)(x.Rules), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *Role) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *Role) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "rules":
+ if r.TryDecodeAsNil() {
+ x.Rules = nil
+ } else {
+ yyv5 := &x.Rules
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSlicePolicyRule((*[]PolicyRule)(yyv5), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *Role) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Rules = nil
+ } else {
+ yyv11 := &x.Rules
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSlicePolicyRule((*[]PolicyRule)(yyv11), d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *RoleBinding) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Subjects == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceSubject(([]Subject)(x.Subjects), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subjects"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Subjects == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceSubject(([]Subject)(x.Subjects), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy12 := &x.RoleRef
+ yy12.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("roleRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy14 := &x.RoleRef
+ yy14.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *RoleBinding) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *RoleBinding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "subjects":
+ if r.TryDecodeAsNil() {
+ x.Subjects = nil
+ } else {
+ yyv5 := &x.Subjects
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceSubject((*[]Subject)(yyv5), d)
+ }
+ }
+ case "roleRef":
+ if r.TryDecodeAsNil() {
+ x.RoleRef = pkg3_v1.ObjectReference{}
+ } else {
+ yyv7 := &x.RoleRef
+ yyv7.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *RoleBinding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv11 := &x.ObjectMeta
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Subjects = nil
+ } else {
+ yyv12 := &x.Subjects
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.decSliceSubject((*[]Subject)(yyv12), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RoleRef = pkg3_v1.ObjectReference{}
+ } else {
+ yyv14 := &x.RoleRef
+ yyv14.CodecDecodeSelf(d)
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *RoleBindingList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceRoleBinding(([]RoleBinding)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceRoleBinding(([]RoleBinding)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *RoleBindingList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *RoleBindingList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceRoleBinding((*[]RoleBinding)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *RoleBindingList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceRoleBinding((*[]RoleBinding)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *RoleList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceRole(([]Role)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceRole(([]Role)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *RoleList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *RoleList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceRole((*[]Role)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *RoleList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceRole((*[]Role)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterRole) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSlicePolicyRule(([]PolicyRule)(x.Rules), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("rules"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Rules == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSlicePolicyRule(([]PolicyRule)(x.Rules), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterRole) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterRole) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "rules":
+ if r.TryDecodeAsNil() {
+ x.Rules = nil
+ } else {
+ yyv5 := &x.Rules
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSlicePolicyRule((*[]PolicyRule)(yyv5), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterRole) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj9 int
+ var yyb9 bool
+ var yyhl9 bool = l >= 0
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv10 := &x.ObjectMeta
+ yyv10.CodecDecodeSelf(d)
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Rules = nil
+ } else {
+ yyv11 := &x.Rules
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else {
+ h.decSlicePolicyRule((*[]PolicyRule)(yyv11), d)
+ }
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj9++
+ if yyhl9 {
+ yyb9 = yyj9 > l
+ } else {
+ yyb9 = r.CheckBreak()
+ }
+ if yyb9 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj9-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterRoleBinding) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [5]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[3] = x.Kind != ""
+ yyq2[4] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(5)
+ } else {
+ yynn2 = 2
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ObjectMeta
+ yy4.CodecEncodeSelf(e)
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ObjectMeta
+ yy6.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Subjects == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceSubject(([]Subject)(x.Subjects), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("subjects"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Subjects == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceSubject(([]Subject)(x.Subjects), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy12 := &x.RoleRef
+ yy12.CodecEncodeSelf(e)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("roleRef"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy14 := &x.RoleRef
+ yy14.CodecEncodeSelf(e)
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym17 := z.EncBinary()
+ _ = yym17
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym18 := z.EncBinary()
+ _ = yym18
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[4] {
+ yym20 := z.EncBinary()
+ _ = yym20
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym21 := z.EncBinary()
+ _ = yym21
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterRoleBinding) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterRoleBinding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv4 := &x.ObjectMeta
+ yyv4.CodecDecodeSelf(d)
+ }
+ case "subjects":
+ if r.TryDecodeAsNil() {
+ x.Subjects = nil
+ } else {
+ yyv5 := &x.Subjects
+ yym6 := z.DecBinary()
+ _ = yym6
+ if false {
+ } else {
+ h.decSliceSubject((*[]Subject)(yyv5), d)
+ }
+ }
+ case "roleRef":
+ if r.TryDecodeAsNil() {
+ x.RoleRef = pkg3_v1.ObjectReference{}
+ } else {
+ yyv7 := &x.RoleRef
+ yyv7.CodecDecodeSelf(d)
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterRoleBinding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ObjectMeta = pkg3_v1.ObjectMeta{}
+ } else {
+ yyv11 := &x.ObjectMeta
+ yyv11.CodecDecodeSelf(d)
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Subjects = nil
+ } else {
+ yyv12 := &x.Subjects
+ yym13 := z.DecBinary()
+ _ = yym13
+ if false {
+ } else {
+ h.decSliceSubject((*[]Subject)(yyv12), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.RoleRef = pkg3_v1.ObjectReference{}
+ } else {
+ yyv14 := &x.RoleRef
+ yyv14.CodecDecodeSelf(d)
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterRoleBindingList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceClusterRoleBinding(([]ClusterRoleBinding)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceClusterRoleBinding(([]ClusterRoleBinding)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterRoleBindingList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterRoleBindingList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceClusterRoleBinding((*[]ClusterRoleBinding)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterRoleBindingList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceClusterRoleBinding((*[]ClusterRoleBinding)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x *ClusterRoleList) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ if x == nil {
+ r.EncodeNil()
+ } else {
+ yym1 := z.EncBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ yysep2 := !z.EncBinary()
+ yy2arr2 := z.EncBasicHandle().StructToArray
+ var yyq2 [4]bool
+ _, _, _ = yysep2, yyq2, yy2arr2
+ const yyr2 bool = false
+ yyq2[0] = true
+ yyq2[2] = x.Kind != ""
+ yyq2[3] = x.APIVersion != ""
+ var yynn2 int
+ if yyr2 || yy2arr2 {
+ r.EncodeArrayStart(4)
+ } else {
+ yynn2 = 1
+ for _, b := range yyq2 {
+ if b {
+ yynn2++
+ }
+ }
+ r.EncodeMapStart(yynn2)
+ yynn2 = 0
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[0] {
+ yy4 := &x.ListMeta
+ yym5 := z.EncBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy4) {
+ } else {
+ z.EncFallback(yy4)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq2[0] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("metadata"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy6 := &x.ListMeta
+ yym7 := z.EncBinary()
+ _ = yym7
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy6) {
+ } else {
+ z.EncFallback(yy6)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym9 := z.EncBinary()
+ _ = yym9
+ if false {
+ } else {
+ h.encSliceClusterRole(([]ClusterRole)(x.Items), e)
+ }
+ }
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("items"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.Items == nil {
+ r.EncodeNil()
+ } else {
+ yym10 := z.EncBinary()
+ _ = yym10
+ if false {
+ } else {
+ h.encSliceClusterRole(([]ClusterRole)(x.Items), e)
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[2] {
+ yym12 := z.EncBinary()
+ _ = yym12
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("kind"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym13 := z.EncBinary()
+ _ = yym13
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2[3] {
+ yym15 := z.EncBinary()
+ _ = yym15
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym16 := z.EncBinary()
+ _ = yym16
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr2 || yy2arr2 {
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ z.EncSendContainerState(codecSelfer_containerMapEnd1234)
+ }
+ }
+ }
+}
+
+func (x *ClusterRoleList) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym1 := z.DecBinary()
+ _ = yym1
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ yyct2 := r.ContainerType()
+ if yyct2 == codecSelferValueTypeMap1234 {
+ yyl2 := r.ReadMapStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+ } else {
+ x.codecDecodeSelfFromMap(yyl2, d)
+ }
+ } else if yyct2 == codecSelferValueTypeArray1234 {
+ yyl2 := r.ReadArrayStart()
+ if yyl2 == 0 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ } else {
+ x.codecDecodeSelfFromArray(yyl2, d)
+ }
+ } else {
+ panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
+ }
+ }
+}
+
+func (x *ClusterRoleList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yys3Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3Slc
+ var yyhl3 bool = l >= 0
+ for yyj3 := 0; ; yyj3++ {
+ if yyhl3 {
+ if yyj3 >= l {
+ break
+ }
+ } else {
+ if r.CheckBreak() {
+ break
+ }
+ }
+ z.DecSendContainerState(codecSelfer_containerMapKey1234)
+ yys3Slc = r.DecodeBytes(yys3Slc, true, true)
+ yys3 := string(yys3Slc)
+ z.DecSendContainerState(codecSelfer_containerMapValue1234)
+ switch yys3 {
+ case "metadata":
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv4 := &x.ListMeta
+ yym5 := z.DecBinary()
+ _ = yym5
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv4) {
+ } else {
+ z.DecFallback(yyv4, false)
+ }
+ }
+ case "items":
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv6 := &x.Items
+ yym7 := z.DecBinary()
+ _ = yym7
+ if false {
+ } else {
+ h.decSliceClusterRole((*[]ClusterRole)(yyv6), d)
+ }
+ }
+ case "kind":
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ case "apiVersion":
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ default:
+ z.DecStructFieldNotFound(-1, yys3)
+ } // end switch yys3
+ } // end for yyj3
+ z.DecSendContainerState(codecSelfer_containerMapEnd1234)
+}
+
+func (x *ClusterRoleList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ var yyj10 int
+ var yyb10 bool
+ var yyhl10 bool = l >= 0
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.ListMeta = pkg2_unversioned.ListMeta{}
+ } else {
+ yyv11 := &x.ListMeta
+ yym12 := z.DecBinary()
+ _ = yym12
+ if false {
+ } else if z.HasExtensions() && z.DecExt(yyv11) {
+ } else {
+ z.DecFallback(yyv11, false)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Items = nil
+ } else {
+ yyv13 := &x.Items
+ yym14 := z.DecBinary()
+ _ = yym14
+ if false {
+ } else {
+ h.decSliceClusterRole((*[]ClusterRole)(yyv13), d)
+ }
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.Kind = ""
+ } else {
+ x.Kind = string(r.DecodeString())
+ }
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.APIVersion = ""
+ } else {
+ x.APIVersion = string(r.DecodeString())
+ }
+ for {
+ yyj10++
+ if yyhl10 {
+ yyb10 = yyj10 > l
+ } else {
+ yyb10 = r.CheckBreak()
+ }
+ if yyb10 {
+ break
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ z.DecStructFieldNotFound(yyj10-1, "")
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) encSlicePolicyRule(v []PolicyRule, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSlicePolicyRule(v *[]PolicyRule, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []PolicyRule{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 160)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]PolicyRule, yyrl1)
+ }
+ } else {
+ yyv1 = make([]PolicyRule, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PolicyRule{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, PolicyRule{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PolicyRule{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, PolicyRule{}) // var yyz1 PolicyRule
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = PolicyRule{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []PolicyRule{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceSubject(v []Subject, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceSubject(v *[]Subject, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Subject{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 64)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Subject, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Subject, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Subject{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Subject{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Subject{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Subject{}) // var yyz1 Subject
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Subject{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Subject{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceRoleBinding(v []RoleBinding, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceRoleBinding(v *[]RoleBinding, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []RoleBinding{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 376)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]RoleBinding, yyrl1)
+ }
+ } else {
+ yyv1 = make([]RoleBinding, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = RoleBinding{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, RoleBinding{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = RoleBinding{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, RoleBinding{}) // var yyz1 RoleBinding
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = RoleBinding{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []RoleBinding{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceRole(v []Role, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceRole(v *[]Role, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []Role{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]Role, yyrl1)
+ }
+ } else {
+ yyv1 = make([]Role, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Role{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, Role{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Role{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, Role{}) // var yyz1 Role
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = Role{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []Role{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceClusterRoleBinding(v []ClusterRoleBinding, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceClusterRoleBinding(v *[]ClusterRoleBinding, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ClusterRoleBinding{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 376)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ClusterRoleBinding, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ClusterRoleBinding, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRoleBinding{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ClusterRoleBinding{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRoleBinding{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ClusterRoleBinding{}) // var yyz1 ClusterRoleBinding
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRoleBinding{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ClusterRoleBinding{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
+
+func (x codecSelfer1234) encSliceClusterRole(v []ClusterRole, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv1 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy2 := &yyv1
+ yy2.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceClusterRole(v *[]ClusterRole, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv1 := *v
+ yyh1, yyl1 := z.DecSliceHelperStart()
+ var yyc1 bool
+ _ = yyc1
+ if yyl1 == 0 {
+ if yyv1 == nil {
+ yyv1 = []ClusterRole{}
+ yyc1 = true
+ } else if len(yyv1) != 0 {
+ yyv1 = yyv1[:0]
+ yyc1 = true
+ }
+ } else if yyl1 > 0 {
+ var yyrr1, yyrl1 int
+ var yyrt1 bool
+ _, _ = yyrl1, yyrt1
+ yyrr1 = yyl1 // len(yyv1)
+ if yyl1 > cap(yyv1) {
+
+ yyrg1 := len(yyv1) > 0
+ yyv21 := yyv1
+ yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 264)
+ if yyrt1 {
+ if yyrl1 <= cap(yyv1) {
+ yyv1 = yyv1[:yyrl1]
+ } else {
+ yyv1 = make([]ClusterRole, yyrl1)
+ }
+ } else {
+ yyv1 = make([]ClusterRole, yyrl1)
+ }
+ yyc1 = true
+ yyrr1 = len(yyv1)
+ if yyrg1 {
+ copy(yyv1, yyv21)
+ }
+ } else if yyl1 != len(yyv1) {
+ yyv1 = yyv1[:yyl1]
+ yyc1 = true
+ }
+ yyj1 := 0
+ for ; yyj1 < yyrr1; yyj1++ {
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRole{}
+ } else {
+ yyv2 := &yyv1[yyj1]
+ yyv2.CodecDecodeSelf(d)
+ }
+
+ }
+ if yyrt1 {
+ for ; yyj1 < yyl1; yyj1++ {
+ yyv1 = append(yyv1, ClusterRole{})
+ yyh1.ElemContainerState(yyj1)
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRole{}
+ } else {
+ yyv3 := &yyv1[yyj1]
+ yyv3.CodecDecodeSelf(d)
+ }
+
+ }
+ }
+
+ } else {
+ yyj1 := 0
+ for ; !r.CheckBreak(); yyj1++ {
+
+ if yyj1 >= len(yyv1) {
+ yyv1 = append(yyv1, ClusterRole{}) // var yyz1 ClusterRole
+ yyc1 = true
+ }
+ yyh1.ElemContainerState(yyj1)
+ if yyj1 < len(yyv1) {
+ if r.TryDecodeAsNil() {
+ yyv1[yyj1] = ClusterRole{}
+ } else {
+ yyv4 := &yyv1[yyj1]
+ yyv4.CodecDecodeSelf(d)
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj1 < len(yyv1) {
+ yyv1 = yyv1[:yyj1]
+ yyc1 = true
+ } else if yyj1 == 0 && yyv1 == nil {
+ yyv1 = []ClusterRole{}
+ yyc1 = true
+ }
+ }
+ yyh1.End()
+ if yyc1 {
+ *v = yyv1
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..52eacfe3fcfe4e7492e3a6dce1bbf29f7683a26f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types.go
@@ -0,0 +1,163 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Authorization is calculated against
+// 1. evaluation of ClusterRoleBindings - short circuit on match
+// 2. evaluation of RoleBindings in the namespace requested - short circuit on match
+// 3. deny by default
+
+// 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.
+type PolicyRule struct {
+ // Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds.
+ Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"`
+ // AttributeRestrictions will vary depending on what the Authorizer/AuthorizationAttributeBuilder pair supports.
+ // If the Authorizer does not recognize how to handle the AttributeRestrictions, the Authorizer should report an error.
+ AttributeRestrictions runtime.RawExtension `json:"attributeRestrictions,omitempty" protobuf:"bytes,2,opt,name=attributeRestrictions"`
+ // 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.
+ APIGroups []string `json:"apiGroups" protobuf:"bytes,3,rep,name=apiGroups"`
+ // Resources is a list of resources this rule applies to. ResourceAll represents all resources.
+ Resources []string `json:"resources" protobuf:"bytes,4,rep,name=resources"`
+ // ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.
+ ResourceNames []string `json:"resourceNames,omitempty" protobuf:"bytes,5,rep,name=resourceNames"`
+ // NonResourceURLsSlice 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
+ // This name is intentionally different than the internal type so that the DefaultConvert works nicely and because the ordering may be different.
+ // Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding.
+ NonResourceURLs []string `json:"nonResourceURLs,omitempty" protobuf:"bytes,6,rep,name=nonResourceURLs"`
+}
+
+// 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.
+type Subject struct {
+ // 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.
+ Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`
+ // APIVersion holds the API group and version of the referenced object.
+ APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,2,opt.name=apiVersion"`
+ // Name of the object being referenced.
+ Name string `json:"name" protobuf:"bytes,3,opt,name=name"`
+ // 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.
+ Namespace string `json:"namespace,omitempty" protobuf:"bytes,4,opt,name=namespace"`
+}
+
+// +genclient=true
+
+// Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
+type Role struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Rules holds all the PolicyRules for this Role
+ Rules []PolicyRule `json:"rules" protobuf:"bytes,2,rep,name=rules"`
+}
+
+// +genclient=true
+
+// 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.
+type RoleBinding struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Subjects holds references to the objects the role applies to.
+ Subjects []Subject `json:"subjects" protobuf:"bytes,2,rep,name=subjects"`
+
+ // 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.
+ RoleRef v1.ObjectReference `json:"roleRef" protobuf:"bytes,3,opt,name=roleRef"`
+}
+
+// RoleBindingList is a collection of RoleBindings
+type RoleBindingList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is a list of RoleBindings
+ Items []RoleBinding `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// RoleList is a collection of Roles
+type RoleList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is a list of Roles
+ Items []Role `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// +genclient=true,nonNamespaced=true
+
+// ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.
+type ClusterRole struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Rules holds all the PolicyRules for this ClusterRole
+ Rules []PolicyRule `json:"rules" protobuf:"bytes,2,rep,name=rules"`
+}
+
+// +genclient=true,nonNamespaced=true
+
+// ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace,
+// and adds who information via Subject.
+type ClusterRoleBinding struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Subjects holds references to the objects the role applies to.
+ Subjects []Subject `json:"subjects" protobuf:"bytes,2,rep,name=subjects"`
+
+ // RoleRef can only reference a ClusterRole in the global namespace.
+ // If the RoleRef cannot be resolved, the Authorizer must return an error.
+ RoleRef v1.ObjectReference `json:"roleRef" protobuf:"bytes,3,opt,name=roleRef"`
+}
+
+// ClusterRoleBindingList is a collection of ClusterRoleBindings
+type ClusterRoleBindingList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is a list of ClusterRoleBindings
+ Items []ClusterRoleBinding `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// ClusterRoleList is a collection of ClusterRoles
+type ClusterRoleList struct {
+ unversioned.TypeMeta `json:",inline"`
+ // Standard object's metadata.
+ unversioned.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // Items is a list of ClusterRoles
+ Items []ClusterRole `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types_swagger_doc_generated.go b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types_swagger_doc_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..b88c93c0346a5d2aca7c97e48ca4a1f1e9b68587
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/apis/rbac/v1alpha1/types_swagger_doc_generated.go
@@ -0,0 +1,138 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 v1alpha1
+
+// This file contains a collection of methods that can be used from go-restful to
+// generate Swagger API documentation for its models. Please read this PR for more
+// information on the implementation: https://github.com/emicklei/go-restful/pull/215
+//
+// TODOs are ignored from the parser (e.g. TODO(andronat):... || TODO:...) if and only if
+// they are on one line! For multiple line or blocks that you want to ignore use ---.
+// Any context after a --- is ignored.
+//
+// Those methods can be generated by using hack/update-generated-swagger-docs.sh
+
+// AUTO-GENERATED FUNCTIONS START HERE
+var map_ClusterRole = map[string]string{
+ "": "ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.",
+ "metadata": "Standard object's metadata.",
+ "rules": "Rules holds all the PolicyRules for this ClusterRole",
+}
+
+func (ClusterRole) SwaggerDoc() map[string]string {
+ return map_ClusterRole
+}
+
+var map_ClusterRoleBinding = map[string]string{
+ "": "ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.",
+ "metadata": "Standard object's metadata.",
+ "subjects": "Subjects holds references to the objects the role applies to.",
+ "roleRef": "RoleRef can only reference a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error.",
+}
+
+func (ClusterRoleBinding) SwaggerDoc() map[string]string {
+ return map_ClusterRoleBinding
+}
+
+var map_ClusterRoleBindingList = map[string]string{
+ "": "ClusterRoleBindingList is a collection of ClusterRoleBindings",
+ "metadata": "Standard object's metadata.",
+ "items": "Items is a list of ClusterRoleBindings",
+}
+
+func (ClusterRoleBindingList) SwaggerDoc() map[string]string {
+ return map_ClusterRoleBindingList
+}
+
+var map_ClusterRoleList = map[string]string{
+ "": "ClusterRoleList is a collection of ClusterRoles",
+ "metadata": "Standard object's metadata.",
+ "items": "Items is a list of ClusterRoles",
+}
+
+func (ClusterRoleList) SwaggerDoc() map[string]string {
+ return map_ClusterRoleList
+}
+
+var map_PolicyRule = map[string]string{
+ "": "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": "Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds.",
+ "attributeRestrictions": "AttributeRestrictions will vary depending on what the Authorizer/AuthorizationAttributeBuilder pair supports. If the Authorizer does not recognize how to handle the AttributeRestrictions, the Authorizer should report an error.",
+ "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.",
+ "resources": "Resources is a list of resources this rule applies to. ResourceAll represents all resources.",
+ "resourceNames": "ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed.",
+ "nonResourceURLs": "NonResourceURLsSlice 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 This name is intentionally different than the internal type so that the DefaultConvert works nicely and because the ordering may be different. Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding.",
+}
+
+func (PolicyRule) SwaggerDoc() map[string]string {
+ return map_PolicyRule
+}
+
+var map_Role = map[string]string{
+ "": "Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.",
+ "metadata": "Standard object's metadata.",
+ "rules": "Rules holds all the PolicyRules for this Role",
+}
+
+func (Role) SwaggerDoc() map[string]string {
+ return map_Role
+}
+
+var map_RoleBinding = map[string]string{
+ "": "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.",
+ "metadata": "Standard object's metadata.",
+ "subjects": "Subjects holds references to the objects the role applies to.",
+ "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.",
+}
+
+func (RoleBinding) SwaggerDoc() map[string]string {
+ return map_RoleBinding
+}
+
+var map_RoleBindingList = map[string]string{
+ "": "RoleBindingList is a collection of RoleBindings",
+ "metadata": "Standard object's metadata.",
+ "items": "Items is a list of RoleBindings",
+}
+
+func (RoleBindingList) SwaggerDoc() map[string]string {
+ return map_RoleBindingList
+}
+
+var map_RoleList = map[string]string{
+ "": "RoleList is a collection of Roles",
+ "metadata": "Standard object's metadata.",
+ "items": "Items is a list of Roles",
+}
+
+func (RoleList) SwaggerDoc() map[string]string {
+ return map_RoleList
+}
+
+var map_Subject = map[string]string{
+ "": "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.",
+ "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.",
+ "apiVersion": "APIVersion holds the API group and version of the referenced object.",
+ "name": "Name of the object being referenced.",
+ "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.",
+}
+
+func (Subject) SwaggerDoc() map[string]string {
+ return map_Subject
+}
+
+// AUTO-GENERATED FUNCTIONS END HERE
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/auth/user/doc.go b/vendor/k8s.io/kubernetes/pkg/auth/user/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/auth/user/doc.go
rename to vendor/k8s.io/kubernetes/pkg/auth/user/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/auth/user/user.go b/vendor/k8s.io/kubernetes/pkg/auth/user/user.go
similarity index 70%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/auth/user/user.go
rename to vendor/k8s.io/kubernetes/pkg/auth/user/user.go
index ad7bccef9ff995cf4b5d32783ca8f22bf8c62348..c4a4c00d5bff3fd8d2f352e7ce7c6516a5b03f30 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/auth/user/user.go
+++ b/vendor/k8s.io/kubernetes/pkg/auth/user/user.go
@@ -27,6 +27,16 @@ type Info interface {
GetUID() string
// GetGroups returns the names of the groups the user is a member of
GetGroups() []string
+
+ // GetExtra can contain any additional information that the authenticator
+ // thought was interesting. One example would be scopes on a token.
+ // Keys in this map should be namespaced to the authenticator or
+ // authenticator/authorizer pair making use of them.
+ // For instance: "example.org/foo" instead of "foo"
+ // This is a map[string][]string because it needs to be serializeable into
+ // a SubjectAccessReviewSpec.authorization.k8s.io for proper authorization
+ // delegation flows
+ GetExtra() map[string][]string
}
// DefaultInfo provides a simple user information exchange object
@@ -35,6 +45,7 @@ type DefaultInfo struct {
Name string
UID string
Groups []string
+ Extra map[string][]string
}
func (i *DefaultInfo) GetName() string {
@@ -48,3 +59,7 @@ func (i *DefaultInfo) GetUID() string {
func (i *DefaultInfo) GetGroups() []string {
return i.Groups
}
+
+func (i *DefaultInfo) GetExtra() map[string][]string {
+ return i.Extra
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/capabilities/capabilities.go b/vendor/k8s.io/kubernetes/pkg/capabilities/capabilities.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/capabilities/capabilities.go
rename to vendor/k8s.io/kubernetes/pkg/capabilities/capabilities.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/capabilities/doc.go b/vendor/k8s.io/kubernetes/pkg/capabilities/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/capabilities/doc.go
rename to vendor/k8s.io/kubernetes/pkg/capabilities/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go b/vendor/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go
index e7cc1aad19e69f261f44cf3352dc8c5f9ee3fd91..3cb077faf7e6a404e6fb59cc3bd024e81624dec8 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/delta_fifo.go
@@ -82,9 +82,9 @@ func NewDeltaFIFO(keyFunc KeyFunc, compressor DeltaCompressor, knownObjects KeyL
// different versions of the same object.
//
// A note on the KeyLister used by the DeltaFIFO: It's main purpose is
-// to list keys that are "known", for the puspose of figuring out which
+// to list keys that are "known", for the purpose of figuring out which
// items have been deleted when Replace() or Delete() are called. The deleted
-// objet will be included in the DeleteFinalStateUnknown markers. These objects
+// object will be included in the DeleteFinalStateUnknown markers. These objects
// could be stale.
//
// You may provide a function to compress deltas (e.g., represent a
@@ -189,12 +189,20 @@ func (f *DeltaFIFO) Delete(obj interface{}) error {
// Don't provide a second report of the same deletion.
return nil
}
- } else if _, exists, err := f.knownObjects.GetByKey(id); err == nil && !exists {
- // Presumably, this was deleted when a relist happened.
- // Don't provide a second report of the same deletion.
- // TODO(lavalamp): This may be racy-- we aren't properly locked
- // with knownObjects.
- return nil
+ } else {
+ // We only want to skip the "deletion" action if the object doesn't
+ // exist in knownObjects and it doesn't have corresponding item in items.
+ // Note that even if there is a "deletion" action in items, we can ignore it,
+ // because it will be deduped automatically in "queueActionLocked"
+ _, exists, err := f.knownObjects.GetByKey(id)
+ _, itemsExist := f.items[id]
+ if err == nil && !exists && !itemsExist {
+ // Presumably, this was deleted when a relist happened.
+ // Don't provide a second report of the same deletion.
+ // TODO(lavalamp): This may be racy-- we aren't properly locked
+ // with knownObjects.
+ return nil
+ }
}
return f.queueActionLocked(Deleted, obj)
@@ -270,6 +278,13 @@ func isDeletionDup(a, b *Delta) *Delta {
return b
}
+// willObjectBeDeletedLocked returns true only if the last delta for the
+// given object is Delete. Caller must lock first.
+func (f *DeltaFIFO) willObjectBeDeletedLocked(id string) bool {
+ deltas := f.items[id]
+ return len(deltas) > 0 && deltas[len(deltas)-1].Type == Deleted
+}
+
// queueActionLocked appends to the delta list for the object, calling
// f.deltaCompressor if needed. Caller must lock first.
func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) error {
@@ -277,6 +292,14 @@ func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) err
if err != nil {
return KeyError{obj, err}
}
+
+ // If object is supposed to be deleted (last event is Deleted),
+ // then we should ignore Sync events, because it would result in
+ // recreation of this object.
+ if actionType == Sync && f.willObjectBeDeletedLocked(id) {
+ return nil
+ }
+
newDeltas := append(f.items[id], Delta{actionType, obj})
newDeltas = dedupDeltas(newDeltas)
if f.deltaCompressor != nil {
@@ -306,6 +329,10 @@ func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) err
func (f *DeltaFIFO) List() []interface{} {
f.lock.RLock()
defer f.lock.RUnlock()
+ return f.listLocked()
+}
+
+func (f *DeltaFIFO) listLocked() []interface{} {
list := make([]interface{}, 0, len(f.items))
for _, item := range f.items {
// Copy item's slice so operations on this slice (delta
@@ -359,10 +386,12 @@ func (f *DeltaFIFO) GetByKey(key string) (item interface{}, exists bool, err err
// added/updated. The item is removed from the queue (and the store) before it
// is returned, so if you don't successfully process it, you need to add it back
// with AddIfNotPresent().
+// process function is called under lock, so it is safe update data structures
+// in it that need to be in sync with the queue (e.g. knownKeys).
//
// Pop returns a 'Deltas', which has a complete list of all the things
// that happened to the object (deltas) while it was sitting in the queue.
-func (f *DeltaFIFO) Pop() interface{} {
+func (f *DeltaFIFO) Pop(process PopProcessFunc) (interface{}, error) {
f.lock.Lock()
defer f.lock.Unlock()
for {
@@ -382,7 +411,7 @@ func (f *DeltaFIFO) Pop() interface{} {
delete(f.items, id)
// Don't need to copyDeltas here, because we're transferring
// ownership to the caller.
- return item
+ return item, process(item)
}
}
@@ -452,6 +481,27 @@ func (f *DeltaFIFO) Replace(list []interface{}, resourceVersion string) error {
return nil
}
+// Resync will send a sync event for each item
+func (f *DeltaFIFO) Resync() error {
+ f.lock.RLock()
+ defer f.lock.RUnlock()
+ for _, k := range f.knownObjects.ListKeys() {
+ obj, exists, err := f.knownObjects.GetByKey(k)
+ if err != nil {
+ glog.Errorf("Unexpected error %v during lookup of key %v, unable to queue object for sync", err, k)
+ continue
+ } else if !exists {
+ glog.Infof("Key %v does not exist in known objects store, unable to queue object for sync", k)
+ continue
+ }
+
+ if err := f.queueActionLocked(Sync, obj); err != nil {
+ return fmt.Errorf("couldn't queue object: %v", err)
+ }
+ }
+ return nil
+}
+
// A KeyListerGetter is anything that knows how to list its keys and look up by key.
type KeyListerGetter interface {
KeyLister
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/doc.go b/vendor/k8s.io/kubernetes/pkg/client/cache/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/doc.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go b/vendor/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go
index 964deda079507447448e09ad0bb1b332989ece46..ad8684e8c377b23ad869054053509d402a39ba60 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/expiration_cache.go
@@ -146,6 +146,7 @@ func (c *ExpirationCache) ListKeys() []string {
func (c *ExpirationCache) Add(obj interface{}) error {
c.expirationLock.Lock()
defer c.expirationLock.Unlock()
+
key, err := c.keyFunc(obj)
if err != nil {
return KeyError{obj, err}
@@ -191,6 +192,11 @@ func (c *ExpirationCache) Replace(list []interface{}, resourceVersion string) er
return nil
}
+// Resync will touch all objects to put them into the processing queue
+func (c *ExpirationCache) Resync() error {
+ return c.cacheStorage.Resync()
+}
+
// NewTTLStore creates and returns a ExpirationCache with a TTLPolicy
func NewTTLStore(keyFunc KeyFunc, ttl time.Duration) Store {
return &ExpirationCache{
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/expiration_cache_fakes.go b/vendor/k8s.io/kubernetes/pkg/client/cache/expiration_cache_fakes.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/expiration_cache_fakes.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/expiration_cache_fakes.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/cache/fake_custom_store.go b/vendor/k8s.io/kubernetes/pkg/client/cache/fake_custom_store.go
new file mode 100644
index 0000000000000000000000000000000000000000..ccd69ef7bfdd3598af276df62048e7c56f620e59
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/fake_custom_store.go
@@ -0,0 +1,102 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 cache
+
+// FakeStore lets you define custom functions for store operations
+type FakeCustomStore struct {
+ AddFunc func(obj interface{}) error
+ UpdateFunc func(obj interface{}) error
+ DeleteFunc func(obj interface{}) error
+ ListFunc func() []interface{}
+ ListKeysFunc func() []string
+ GetFunc func(obj interface{}) (item interface{}, exists bool, err error)
+ GetByKeyFunc func(key string) (item interface{}, exists bool, err error)
+ ReplaceFunc func(list []interface{}, resourceVerion string) error
+ ResyncFunc func() error
+}
+
+// Add calls the custom Add function if defined
+func (f *FakeCustomStore) Add(obj interface{}) error {
+ if f.AddFunc != nil {
+ return f.AddFunc(obj)
+ }
+ return nil
+}
+
+// Update calls the custom Update function if defined
+func (f *FakeCustomStore) Update(obj interface{}) error {
+ if f.UpdateFunc != nil {
+ return f.Update(obj)
+ }
+ return nil
+}
+
+// Delete calls the custom Delete function if defined
+func (f *FakeCustomStore) Delete(obj interface{}) error {
+ if f.DeleteFunc != nil {
+ return f.DeleteFunc(obj)
+ }
+ return nil
+}
+
+// List calls the custom List function if defined
+func (f *FakeCustomStore) List() []interface{} {
+ if f.ListFunc != nil {
+ return f.ListFunc()
+ }
+ return nil
+}
+
+// ListKeys calls the custom ListKeys function if defined
+func (f *FakeCustomStore) ListKeys() []string {
+ if f.ListKeysFunc != nil {
+ return f.ListKeysFunc()
+ }
+ return nil
+}
+
+// Get calls the custom Get function if defined
+func (f *FakeCustomStore) Get(obj interface{}) (item interface{}, exists bool, err error) {
+ if f.GetFunc != nil {
+ return f.GetFunc(obj)
+ }
+ return nil, false, nil
+}
+
+// GetByKey calls the custom GetByKey function if defined
+func (f *FakeCustomStore) GetByKey(key string) (item interface{}, exists bool, err error) {
+ if f.GetByKeyFunc != nil {
+ return f.GetByKeyFunc(key)
+ }
+ return nil, false, nil
+}
+
+// Replace calls the custom Replace function if defined
+func (f *FakeCustomStore) Replace(list []interface{}, resourceVersion string) error {
+ if f.ReplaceFunc != nil {
+ return f.ReplaceFunc(list, resourceVersion)
+ }
+ return nil
+}
+
+// Resync calls the custom Resync function if defined
+func (f *FakeCustomStore) Resync() error {
+ if f.ResyncFunc != nil {
+ return f.ResyncFunc()
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/fifo.go b/vendor/k8s.io/kubernetes/pkg/client/cache/fifo.go
similarity index 82%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/fifo.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/fifo.go
index d4076a326d812436f8944346fec7bb85fd328bd7..eaa35e62cb67992a41fa0b38ad9454cde649fa83 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/fifo.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/fifo.go
@@ -18,14 +18,21 @@ package cache
import (
"sync"
+
+ "k8s.io/kubernetes/pkg/util/sets"
)
+// PopProcessFunc is passed to Pop() method of Queue interface.
+// It is supposed to process the element popped from the queue.
+type PopProcessFunc func(interface{}) error
+
// Queue is exactly like a Store, but has a Pop() method too.
type Queue interface {
Store
- // Pop blocks until it has something to return.
- Pop() interface{}
+ // Pop blocks until it has something to process.
+ // It returns the object that was process and the result of processing.
+ Pop(PopProcessFunc) (interface{}, error)
// AddIfNotPresent adds a value previously
// returned by Pop back into the queue as long
@@ -37,6 +44,18 @@ type Queue interface {
HasSynced() bool
}
+// Helper function for popping from Queue.
+// WARNING: Do NOT use this function in non-test code to avoid races
+// unless you really really really really know what you are doing.
+func Pop(queue Queue) interface{} {
+ var result interface{}
+ queue.Pop(func(obj interface{}) error {
+ result = obj
+ return nil
+ })
+ return result
+}
+
// FIFO receives adds and updates from a Reflector, and puts them in a queue for
// FIFO order processing. If multiple adds/updates of a single item happen while
// an item is in the queue before it has been processed, it will only be
@@ -181,12 +200,13 @@ func (f *FIFO) GetByKey(key string) (item interface{}, exists bool, err error) {
return item, exists, nil
}
-// Pop waits until an item is ready and returns it. If multiple items are
+// Pop waits until an item is ready and processes it. If multiple items are
// ready, they are returned in the order in which they were added/updated.
-// The item is removed from the queue (and the store) before it is returned,
-// so if you don't successfully process it, you need to add it back with
-// AddIfNotPresent().
-func (f *FIFO) Pop() interface{} {
+// The item is removed from the queue (and the store) before it is processed,
+// so if you don't successfully process it, it should be added back with
+// AddIfNotPresent(). process function is called under lock, so it is safe
+// update data structures in it that need to be in sync with the queue.
+func (f *FIFO) Pop(process PopProcessFunc) (interface{}, error) {
f.lock.Lock()
defer f.lock.Unlock()
for {
@@ -204,7 +224,7 @@ func (f *FIFO) Pop() interface{} {
continue
}
delete(f.items, id)
- return item
+ return item, process(item)
}
}
@@ -241,6 +261,26 @@ func (f *FIFO) Replace(list []interface{}, resourceVersion string) error {
return nil
}
+// Resync will touch all objects to put them into the processing queue
+func (f *FIFO) Resync() error {
+ f.lock.Lock()
+ defer f.lock.Unlock()
+
+ inQueue := sets.NewString()
+ for _, id := range f.queue {
+ inQueue.Insert(id)
+ }
+ for id := range f.items {
+ if !inQueue.Has(id) {
+ f.queue = append(f.queue, id)
+ }
+ }
+ if len(f.queue) > 0 {
+ f.cond.Broadcast()
+ }
+ return nil
+}
+
// NewFIFO returns a Store which can be used to queue up items to
// process.
func NewFIFO(keyFunc KeyFunc) *FIFO {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/index.go b/vendor/k8s.io/kubernetes/pkg/client/cache/index.go
similarity index 89%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/index.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/index.go
index a0c0c288c79cc01a11367599499350c6f64cbd95..572f2c06b69eb2e9d747344e09f742d511d7c2a1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/index.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/index.go
@@ -32,6 +32,12 @@ type Indexer interface {
ListIndexFuncValues(indexName string) []string
// ByIndex lists object that match on the named indexing function with the exact key
ByIndex(indexName, indexKey string) ([]interface{}, error)
+ // GetIndexer return the indexers
+ GetIndexers() Indexers
+
+ // AddIndexers adds more indexers to this store. If you call this after you already have data
+ // in the store, the results are undefined.
+ AddIndexers(newIndexers Indexers) error
}
// IndexFunc knows how to provide an indexed value for an object.
@@ -53,6 +59,10 @@ func IndexFuncToKeyFuncAdapter(indexFunc IndexFunc) KeyFunc {
}
}
+const (
+ NamespaceIndex string = "namespace"
+)
+
// MetaNamespaceIndexFunc is a default index function that indexes based on an object's namespace
func MetaNamespaceIndexFunc(obj interface{}) ([]string, error) {
meta, err := meta.Accessor(obj)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/listers.go b/vendor/k8s.io/kubernetes/pkg/client/cache/listers.go
similarity index 78%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/listers.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/listers.go
index 3963a6941afef6d442a6f860d8236c2729c61fd5..90c9c62f9b72685209bf88e91399915a48154450 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/listers.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/listers.go
@@ -22,6 +22,8 @@ import (
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/labels"
)
@@ -39,7 +41,7 @@ import (
// l := StoreToPodLister{s}
// l.List()
type StoreToPodLister struct {
- Store
+ Indexer
}
// Please note that selector is filtering among the pods that have gotten into
@@ -52,7 +54,7 @@ func (s *StoreToPodLister) List(selector labels.Selector) (pods []*api.Pod, err
// s.Pods(api.NamespaceAll).List(selector), however then we'd have to
// remake the list.Items as a []*api.Pod. So leave this separate for
// now.
- for _, m := range s.Store.List() {
+ for _, m := range s.Indexer.List() {
pod := m.(*api.Pod)
if selector.Matches(labels.Set(pod.Labels)) {
pods = append(pods, pod)
@@ -63,33 +65,55 @@ func (s *StoreToPodLister) List(selector labels.Selector) (pods []*api.Pod, err
// Pods is taking baby steps to be more like the api in pkg/client
func (s *StoreToPodLister) Pods(namespace string) storePodsNamespacer {
- return storePodsNamespacer{s.Store, namespace}
+ return storePodsNamespacer{s.Indexer, namespace}
}
type storePodsNamespacer struct {
- store Store
+ indexer Indexer
namespace string
}
// Please note that selector is filtering among the pods that have gotten into
// the store; there may have been some filtering that already happened before
// that.
-func (s storePodsNamespacer) List(selector labels.Selector) (pods api.PodList, err error) {
- list := api.PodList{}
- for _, m := range s.store.List() {
- pod := m.(*api.Pod)
- if s.namespace == api.NamespaceAll || s.namespace == pod.Namespace {
+func (s storePodsNamespacer) List(selector labels.Selector) (api.PodList, error) {
+ pods := api.PodList{}
+
+ if s.namespace == api.NamespaceAll {
+ for _, m := range s.indexer.List() {
+ pod := m.(*api.Pod)
if selector.Matches(labels.Set(pod.Labels)) {
- list.Items = append(list.Items, *pod)
+ pods.Items = append(pods.Items, *pod)
+ }
+ }
+ return pods, nil
+ }
+
+ key := &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: s.namespace}}
+ items, err := s.indexer.Index(NamespaceIndex, key)
+ if err != nil {
+ // Ignore error; do slow search without index.
+ glog.Warningf("can not retrieve list of objects using index : %v", err)
+ for _, m := range s.indexer.List() {
+ pod := m.(*api.Pod)
+ if s.namespace == pod.Namespace && selector.Matches(labels.Set(pod.Labels)) {
+ pods.Items = append(pods.Items, *pod)
}
}
+ return pods, nil
+ }
+ for _, m := range items {
+ pod := m.(*api.Pod)
+ if selector.Matches(labels.Set(pod.Labels)) {
+ pods.Items = append(pods.Items, *pod)
+ }
}
- return list, nil
+ return pods, nil
}
// Exists returns true if a pod matching the namespace/name of the given pod exists in the store.
func (s *StoreToPodLister) Exists(pod *api.Pod) (bool, error) {
- _, exists, err := s.Store.Get(pod)
+ _, exists, err := s.Indexer.Get(pod)
if err != nil {
return false, err
}
@@ -141,12 +165,12 @@ func (s storeToNodeConditionLister) List() (nodes api.NodeList, err error) {
// StoreToReplicationControllerLister gives a store List and Exists methods. The store must contain only ReplicationControllers.
type StoreToReplicationControllerLister struct {
- Store
+ Indexer
}
// Exists checks if the given rc exists in the store.
func (s *StoreToReplicationControllerLister) Exists(controller *api.ReplicationController) (bool, error) {
- _, exists, err := s.Store.Get(controller)
+ _, exists, err := s.Indexer.Get(controller)
if err != nil {
return false, err
}
@@ -156,31 +180,54 @@ func (s *StoreToReplicationControllerLister) Exists(controller *api.ReplicationC
// StoreToReplicationControllerLister lists all controllers in the store.
// TODO: converge on the interface in pkg/client
func (s *StoreToReplicationControllerLister) List() (controllers []api.ReplicationController, err error) {
- for _, c := range s.Store.List() {
+ for _, c := range s.Indexer.List() {
controllers = append(controllers, *(c.(*api.ReplicationController)))
}
return controllers, nil
}
func (s *StoreToReplicationControllerLister) ReplicationControllers(namespace string) storeReplicationControllersNamespacer {
- return storeReplicationControllersNamespacer{s.Store, namespace}
+ return storeReplicationControllersNamespacer{s.Indexer, namespace}
}
type storeReplicationControllersNamespacer struct {
- store Store
+ indexer Indexer
namespace string
}
-func (s storeReplicationControllersNamespacer) List(selector labels.Selector) (controllers []api.ReplicationController, err error) {
- for _, c := range s.store.List() {
- rc := *(c.(*api.ReplicationController))
- if s.namespace == api.NamespaceAll || s.namespace == rc.Namespace {
+func (s storeReplicationControllersNamespacer) List(selector labels.Selector) ([]api.ReplicationController, error) {
+ controllers := []api.ReplicationController{}
+
+ if s.namespace == api.NamespaceAll {
+ for _, m := range s.indexer.List() {
+ rc := *(m.(*api.ReplicationController))
if selector.Matches(labels.Set(rc.Labels)) {
controllers = append(controllers, rc)
}
}
+ return controllers, nil
}
- return
+
+ key := &api.ReplicationController{ObjectMeta: api.ObjectMeta{Namespace: s.namespace}}
+ items, err := s.indexer.Index(NamespaceIndex, key)
+ if err != nil {
+ // Ignore error; do slow search without index.
+ glog.Warningf("can not retrieve list of objects using index : %v", err)
+ for _, m := range s.indexer.List() {
+ rc := *(m.(*api.ReplicationController))
+ if s.namespace == rc.Namespace && selector.Matches(labels.Set(rc.Labels)) {
+ controllers = append(controllers, rc)
+ }
+ }
+ return controllers, nil
+ }
+ for _, m := range items {
+ rc := *(m.(*api.ReplicationController))
+ if selector.Matches(labels.Set(rc.Labels)) {
+ controllers = append(controllers, rc)
+ }
+ }
+ return controllers, nil
}
// GetPodControllers returns a list of replication controllers managing a pod. Returns an error only if no matching controllers are found.
@@ -193,11 +240,14 @@ func (s *StoreToReplicationControllerLister) GetPodControllers(pod *api.Pod) (co
return
}
- for _, m := range s.Store.List() {
+ key := &api.ReplicationController{ObjectMeta: api.ObjectMeta{Namespace: pod.Namespace}}
+ items, err := s.Indexer.Index(NamespaceIndex, key)
+ if err != nil {
+ return
+ }
+
+ for _, m := range items {
rc = *m.(*api.ReplicationController)
- if rc.Namespace != pod.Namespace {
- continue
- }
labelSet := labels.Set(rc.Spec.Selector)
selector = labels.Set(rc.Spec.Selector).AsSelector()
@@ -474,7 +524,7 @@ type StoreToJobLister struct {
}
// Exists checks if the given job exists in the store.
-func (s *StoreToJobLister) Exists(job *extensions.Job) (bool, error) {
+func (s *StoreToJobLister) Exists(job *batch.Job) (bool, error) {
_, exists, err := s.Store.Get(job)
if err != nil {
return false, err
@@ -483,17 +533,17 @@ func (s *StoreToJobLister) Exists(job *extensions.Job) (bool, error) {
}
// StoreToJobLister lists all jobs in the store.
-func (s *StoreToJobLister) List() (jobs extensions.JobList, err error) {
+func (s *StoreToJobLister) List() (jobs batch.JobList, err error) {
for _, c := range s.Store.List() {
- jobs.Items = append(jobs.Items, *(c.(*extensions.Job)))
+ jobs.Items = append(jobs.Items, *(c.(*batch.Job)))
}
return jobs, nil
}
// GetPodJobs returns a list of jobs managing a pod. Returns an error only if no matching jobs are found.
-func (s *StoreToJobLister) GetPodJobs(pod *api.Pod) (jobs []extensions.Job, err error) {
+func (s *StoreToJobLister) GetPodJobs(pod *api.Pod) (jobs []batch.Job, err error) {
var selector labels.Selector
- var job extensions.Job
+ var job batch.Job
if len(pod.Labels) == 0 {
err = fmt.Errorf("no jobs found for pod %v because it has no labels", pod.Name)
@@ -501,7 +551,7 @@ func (s *StoreToJobLister) GetPodJobs(pod *api.Pod) (jobs []extensions.Job, err
}
for _, m := range s.Store.List() {
- job = *m.(*extensions.Job)
+ job = *m.(*batch.Job)
if job.Namespace != pod.Namespace {
continue
}
@@ -532,7 +582,7 @@ func (s *StoreToPVFetcher) GetPersistentVolumeInfo(id string) (*api.PersistentVo
}
if !exists {
- return nil, fmt.Errorf("PersistentVolume '%v' is not in cache", id)
+ return nil, fmt.Errorf("PersistentVolume '%v' not found", id)
}
return o.(*api.PersistentVolume), nil
@@ -551,8 +601,72 @@ func (s *StoreToPVCFetcher) GetPersistentVolumeClaimInfo(namespace string, id st
}
if !exists {
- return nil, fmt.Errorf("PersistentVolumeClaim '%s/%s' is not in cache", namespace, id)
+ return nil, fmt.Errorf("PersistentVolumeClaim '%s/%s' not found", namespace, id)
}
return o.(*api.PersistentVolumeClaim), nil
}
+
+// StoreToPetSetLister gives a store List and Exists methods. The store must contain only PetSets.
+type StoreToPetSetLister struct {
+ Store
+}
+
+// Exists checks if the given PetSet exists in the store.
+func (s *StoreToPetSetLister) Exists(ps *apps.PetSet) (bool, error) {
+ _, exists, err := s.Store.Get(ps)
+ if err != nil {
+ return false, err
+ }
+ return exists, nil
+}
+
+// List lists all PetSets in the store.
+func (s *StoreToPetSetLister) List() (psList []apps.PetSet, err error) {
+ for _, ps := range s.Store.List() {
+ psList = append(psList, *(ps.(*apps.PetSet)))
+ }
+ return psList, nil
+}
+
+type storePetSetsNamespacer struct {
+ store Store
+ namespace string
+}
+
+func (s *StoreToPetSetLister) PetSets(namespace string) storePetSetsNamespacer {
+ return storePetSetsNamespacer{s.Store, namespace}
+}
+
+// GetPodPetSets returns a list of PetSets managing a pod. Returns an error only if no matching PetSets are found.
+func (s *StoreToPetSetLister) GetPodPetSets(pod *api.Pod) (psList []apps.PetSet, err error) {
+ var selector labels.Selector
+ var ps apps.PetSet
+
+ if len(pod.Labels) == 0 {
+ err = fmt.Errorf("no PetSets found for pod %v because it has no labels", pod.Name)
+ return
+ }
+
+ for _, m := range s.Store.List() {
+ ps = *m.(*apps.PetSet)
+ if ps.Namespace != pod.Namespace {
+ continue
+ }
+ selector, err = unversioned.LabelSelectorAsSelector(ps.Spec.Selector)
+ if err != nil {
+ err = fmt.Errorf("invalid selector: %v", err)
+ return
+ }
+
+ // If a PetSet with a nil or empty selector creeps in, it should match nothing, not everything.
+ if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
+ continue
+ }
+ psList = append(psList, ps)
+ }
+ if len(psList) == 0 {
+ err = fmt.Errorf("could not find PetSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/listwatch.go b/vendor/k8s.io/kubernetes/pkg/client/cache/listwatch.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/listwatch.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/listwatch.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/reflector.go b/vendor/k8s.io/kubernetes/pkg/client/cache/reflector.go
similarity index 79%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/reflector.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/reflector.go
index 31b076b43e7fec4c20ea128ab6ed37b3f1e3829a..3a5025a28a7e2eeacea349cc61f601f55ae0182c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/reflector.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/reflector.go
@@ -24,7 +24,10 @@ import (
"net"
"net/url"
"reflect"
+ "regexp"
goruntime "runtime"
+ "runtime/debug"
+ "strconv"
"strings"
"sync"
"syscall"
@@ -124,46 +127,95 @@ func NewNamedReflector(name string, lw ListerWatcher, expectedType interface{},
// internalPackages are packages that ignored when creating a default reflector name. These packages are in the common
// call chains to NewReflector, so they'd be low entropy names for reflectors
-var internalPackages = []string{"kubernetes/pkg/client/cache/", "kubernetes/pkg/controller/framework/"}
+var internalPackages = []string{"kubernetes/pkg/client/cache/", "kubernetes/pkg/controller/framework/", "/runtime/asm_"}
// getDefaultReflectorName walks back through the call stack until we find a caller from outside of the ignoredPackages
// it returns back a shortpath/filename:line to aid in identification of this reflector when it starts logging
func getDefaultReflectorName(ignoredPackages ...string) string {
name := "????"
-outer:
- for i := 1; i < 10; i++ {
+ const maxStack = 10
+ for i := 1; i < maxStack; i++ {
_, file, line, ok := goruntime.Caller(i)
if !ok {
- break
- }
- for _, ignoredPackage := range ignoredPackages {
- if strings.Contains(file, ignoredPackage) {
- continue outer
+ file, line, ok = extractStackCreator()
+ if !ok {
+ break
}
-
+ i += maxStack
}
-
- pkgLocation := strings.LastIndex(file, "/pkg/")
- if pkgLocation >= 0 {
- file = file[pkgLocation+1:]
+ if hasPackage(file, ignoredPackages) {
+ continue
}
+
+ file = trimPackagePrefix(file)
name = fmt.Sprintf("%s:%d", file, line)
break
}
-
return name
}
+// hasPackage returns true if the file is in one of the ignored packages.
+func hasPackage(file string, ignoredPackages []string) bool {
+ for _, ignoredPackage := range ignoredPackages {
+ if strings.Contains(file, ignoredPackage) {
+ return true
+ }
+ }
+ return false
+}
+
+// trimPackagePrefix reduces dulpicate values off the front of a package name.
+func trimPackagePrefix(file string) string {
+ if l := strings.LastIndex(file, "k8s.io/kubernetes/pkg/"); l >= 0 {
+ return file[l+len("k8s.io/kubernetes/"):]
+ }
+ if l := strings.LastIndex(file, "/src/"); l >= 0 {
+ return file[l+5:]
+ }
+ if l := strings.LastIndex(file, "/pkg/"); l >= 0 {
+ return file[l+1:]
+ }
+ return file
+}
+
+var stackCreator = regexp.MustCompile(`(?m)^created by (.*)\n\s+(.*):(\d+) \+0x[[:xdigit:]]+$`)
+
+// extractStackCreator retrieves the goroutine file and line that launched this stack. Returns false
+// if the creator cannot be located.
+// TODO: Go does not expose this via runtime https://github.com/golang/go/issues/11440
+func extractStackCreator() (string, int, bool) {
+ stack := debug.Stack()
+ matches := stackCreator.FindStringSubmatch(string(stack))
+ if matches == nil || len(matches) != 4 {
+ return "", 0, false
+ }
+ line, err := strconv.Atoi(matches[3])
+ if err != nil {
+ return "", 0, false
+ }
+ return matches[2], line, true
+}
+
// Run starts a watch and handles watch events. Will restart the watch if it is closed.
// Run starts a goroutine and returns immediately.
func (r *Reflector) Run() {
- go wait.Until(func() { r.ListAndWatch(wait.NeverStop) }, r.period, wait.NeverStop)
+ glog.V(3).Infof("Starting reflector %v (%s) from %s", r.expectedType, r.resyncPeriod, r.name)
+ go wait.Until(func() {
+ if err := r.ListAndWatch(wait.NeverStop); err != nil {
+ utilruntime.HandleError(err)
+ }
+ }, r.period, wait.NeverStop)
}
// RunUntil starts a watch and handles watch events. Will restart the watch if it is closed.
// RunUntil starts a goroutine and returns immediately. It will exit when stopCh is closed.
func (r *Reflector) RunUntil(stopCh <-chan struct{}) {
- go wait.Until(func() { r.ListAndWatch(stopCh) }, r.period, stopCh)
+ glog.V(3).Infof("Starting reflector %v (%s) from %s", r.expectedType, r.resyncPeriod, r.name)
+ go wait.Until(func() {
+ if err := r.ListAndWatch(stopCh); err != nil {
+ utilruntime.HandleError(err)
+ }
+ }, r.period, stopCh)
}
var (
@@ -194,39 +246,11 @@ func (r *Reflector) resyncChan() (<-chan time.Time, func() bool) {
return t.C, t.Stop
}
-// We want to avoid situations when periodic resyncing is breaking the TCP
-// connection.
-// If response`s body is not read to completion before calling body.Close(),
-// that TCP connection will not be reused in the future - see #15664 issue
-// for more details.
-// Thus, we set timeout for watch requests to be smaller than the remaining
-// time until next periodic resync and force resyncing ourself to avoid
-// breaking TCP connection.
-//
-// TODO: This should be parametrizable based on server load.
-func (r *Reflector) timeoutForWatch() *int64 {
- randTimeout := time.Duration(float64(minWatchTimeout) * (rand.Float64() + 1.0))
- timeout := r.nextResync.Sub(r.now()) - timeoutThreshold
- if timeout < 0 || randTimeout < timeout {
- timeout = randTimeout
- }
- timeoutSeconds := int64(timeout.Seconds())
- return &timeoutSeconds
-}
-
-// Returns true if we are close enough to next planned periodic resync
-// and we can force resyncing ourself now.
-func (r *Reflector) canForceResyncNow() bool {
- if r.nextResync.IsZero() {
- return false
- }
- return r.now().Add(forceResyncThreshold).After(r.nextResync)
-}
-
// ListAndWatch first lists all items and get the resource version at the moment of call,
// and then use the resource version to watch.
// It returns error if ListAndWatch didn't even try to initialize watch.
func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
+ glog.V(3).Infof("Listing and watching %v from %s", r.expectedType, r.name)
var resourceVersion string
resyncCh, cleanup := r.resyncChan()
defer cleanup()
@@ -239,11 +263,11 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
if err != nil {
return fmt.Errorf("%s: Failed to list %v: %v", r.name, r.expectedType, err)
}
- metaInterface, err := meta.Accessor(list)
+ listMetaInterface, err := meta.ListAccessor(list)
if err != nil {
- return fmt.Errorf("%s: Unable to understand list result %#v", r.name, list)
+ return fmt.Errorf("%s: Unable to understand list result %#v: %v", r.name, list, err)
}
- resourceVersion = metaInterface.GetResourceVersion()
+ resourceVersion = listMetaInterface.GetResourceVersion()
items, err := meta.ExtractList(list)
if err != nil {
return fmt.Errorf("%s: Unable to understand list result %#v (%v)", r.name, list, err)
@@ -253,13 +277,33 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
}
r.setLastSyncResourceVersion(resourceVersion)
+ resyncerrc := make(chan error, 1)
+ go func() {
+ for {
+ select {
+ case <-resyncCh:
+ case <-stopCh:
+ return
+ }
+ glog.V(4).Infof("%s: next resync planned for %#v, forcing now", r.name, r.nextResync)
+ if err := r.store.Resync(); err != nil {
+ resyncerrc <- err
+ return
+ }
+ cleanup()
+ resyncCh, cleanup = r.resyncChan()
+ }
+ }()
+
for {
- options := api.ListOptions{
+ timemoutseconds := int64(minWatchTimeout.Seconds() * (rand.Float64() + 1.0))
+ options = api.ListOptions{
ResourceVersion: resourceVersion,
- // We want to avoid situations when resyncing is breaking the TCP connection
- // - see comment for 'timeoutForWatch()' for more details.
- TimeoutSeconds: r.timeoutForWatch(),
+ // We want to avoid situations of hanging watchers. Stop any wachers that do not
+ // receive any events within the timeout window.
+ TimeoutSeconds: &timemoutseconds,
}
+
w, err := r.listerWatcher.Watch(options)
if err != nil {
switch err {
@@ -284,16 +328,13 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
}
return nil
}
- if err := r.watchHandler(w, &resourceVersion, resyncCh, stopCh); err != nil {
- if err != errorResyncRequested && err != errorStopRequested {
+
+ if err := r.watchHandler(w, &resourceVersion, resyncerrc, stopCh); err != nil {
+ if err != errorStopRequested {
glog.Warningf("%s: watch of %v ended with: %v", r.name, r.expectedType, err)
}
return nil
}
- if r.canForceResyncNow() {
- glog.V(4).Infof("%s: next resync planned for %#v, forcing now", r.name, r.nextResync)
- return nil
- }
}
}
@@ -307,7 +348,7 @@ func (r *Reflector) syncWith(items []runtime.Object, resourceVersion string) err
}
// watchHandler watches w and keeps *resourceVersion up to date.
-func (r *Reflector) watchHandler(w watch.Interface, resourceVersion *string, resyncCh <-chan time.Time, stopCh <-chan struct{}) error {
+func (r *Reflector) watchHandler(w watch.Interface, resourceVersion *string, errc chan error, stopCh <-chan struct{}) error {
start := time.Now()
eventCount := 0
@@ -320,8 +361,8 @@ loop:
select {
case <-stopCh:
return errorStopRequested
- case <-resyncCh:
- return errorResyncRequested
+ case err := <-errc:
+ return err
case event, ok := <-w.ResultChan():
if !ok {
break loop
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/store.go b/vendor/k8s.io/kubernetes/pkg/client/cache/store.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/store.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/store.go
index 17a360f8e424c5c8e0322d0b593a69e349a99838..71115f2ce5dd780dc243b8ab154d0c3e7f3d7c8c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/store.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/store.go
@@ -44,6 +44,7 @@ type Store interface {
// given list. Store takes ownership of the list, you should not reference
// it after calling this function.
Replace([]interface{}, string) error
+ Resync() error
}
// KeyFunc knows how to make a key from an object. Implementations should be deterministic.
@@ -160,6 +161,11 @@ func (c *cache) ListKeys() []string {
return c.cacheStorage.ListKeys()
}
+// GetIndexers returns the indexers of cache
+func (c *cache) GetIndexers() Indexers {
+ return c.cacheStorage.GetIndexers()
+}
+
// Index returns a list of items that match on the index function
// Index is thread-safe so long as you treat all items as immutable
func (c *cache) Index(indexName string, obj interface{}) ([]interface{}, error) {
@@ -175,6 +181,10 @@ func (c *cache) ByIndex(indexName, indexKey string) ([]interface{}, error) {
return c.cacheStorage.ByIndex(indexName, indexKey)
}
+func (c *cache) AddIndexers(newIndexers Indexers) error {
+ return c.cacheStorage.AddIndexers(newIndexers)
+}
+
// Get returns the requested item, or sets exists=false.
// Get is completely threadsafe as long as you treat all items as immutable.
func (c *cache) Get(obj interface{}) (item interface{}, exists bool, err error) {
@@ -208,6 +218,11 @@ func (c *cache) Replace(list []interface{}, resourceVersion string) error {
return nil
}
+// Resync touches all items in the store to force processing
+func (c *cache) Resync() error {
+ return c.cacheStorage.Resync()
+}
+
// NewStore returns a Store implemented simply with a map and a lock.
func NewStore(keyFunc KeyFunc) Store {
return &cache{
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go b/vendor/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go
index ae4b802c8159a69b0dcad8b1805d06e06340d17b..11077e25b2eecbd9f8561d469d40b08433d7fe3e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/cache/thread_safe_store.go
@@ -45,6 +45,12 @@ type ThreadSafeStore interface {
Index(indexName string, obj interface{}) ([]interface{}, error)
ListIndexFuncValues(name string) []string
ByIndex(indexName, indexKey string) ([]interface{}, error)
+ GetIndexers() Indexers
+
+ // AddIndexers adds more indexers to this store. If you call this after you already have data
+ // in the store, the results are undefined.
+ AddIndexers(newIndexers Indexers) error
+ Resync() error
}
// threadSafeMap implements ThreadSafeStore
@@ -179,6 +185,9 @@ func (c *threadSafeMap) ByIndex(indexName, indexKey string) ([]interface{}, erro
}
func (c *threadSafeMap) ListIndexFuncValues(indexName string) []string {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+
index := c.indices[indexName]
names := make([]string, 0, len(index))
for key := range index {
@@ -187,6 +196,31 @@ func (c *threadSafeMap) ListIndexFuncValues(indexName string) []string {
return names
}
+func (c *threadSafeMap) GetIndexers() Indexers {
+ return c.indexers
+}
+
+func (c *threadSafeMap) AddIndexers(newIndexers Indexers) error {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ if len(c.items) > 0 {
+ return fmt.Errorf("cannot add indexers to running index")
+ }
+
+ oldKeys := sets.StringKeySet(c.indexers)
+ newKeys := sets.StringKeySet(newIndexers)
+
+ if oldKeys.HasAny(newKeys.List()...) {
+ return fmt.Errorf("indexer conflict: %v", oldKeys.Intersection(newKeys))
+ }
+
+ for k, v := range newIndexers {
+ c.indexers[k] = v
+ }
+ return nil
+}
+
// updateIndices modifies the objects location in the managed indexes, if this is an update, you must provide an oldObj
// updateIndices must be called from a function that already has a lock on the cache
func (c *threadSafeMap) updateIndices(oldObj interface{}, newObj interface{}, key string) error {
@@ -239,6 +273,11 @@ func (c *threadSafeMap) deleteFromIndices(obj interface{}, key string) error {
return nil
}
+func (c *threadSafeMap) Resync() error {
+ // Nothing to do
+ return nil
+}
+
func NewThreadSafeStore(indexers Indexers, indices Indices) ThreadSafeStore {
return &threadSafeMap{
items: map[string]interface{}{},
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/undelta_store.go b/vendor/k8s.io/kubernetes/pkg/client/cache/undelta_store.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/cache/undelta_store.go
rename to vendor/k8s.io/kubernetes/pkg/client/cache/undelta_store.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b958a581ce98e217d711fccff869e1bef9fd262
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset.go
@@ -0,0 +1,158 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 internalclientset
+
+import (
+ "github.com/golang/glog"
+ unversionedautoscaling "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned"
+ unversionedbatch "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned"
+ unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
+ unversionedextensions "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"
+ unversionedrbac "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+ discovery "k8s.io/kubernetes/pkg/client/typed/discovery"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
+)
+
+type Interface interface {
+ Discovery() discovery.DiscoveryInterface
+ Core() unversionedcore.CoreInterface
+ Extensions() unversionedextensions.ExtensionsInterface
+ Autoscaling() unversionedautoscaling.AutoscalingInterface
+ Batch() unversionedbatch.BatchInterface
+ Rbac() unversionedrbac.RbacInterface
+}
+
+// Clientset contains the clients for groups. Each group has exactly one
+// version included in a Clientset.
+type Clientset struct {
+ *discovery.DiscoveryClient
+ *unversionedcore.CoreClient
+ *unversionedextensions.ExtensionsClient
+ *unversionedautoscaling.AutoscalingClient
+ *unversionedbatch.BatchClient
+ *unversionedrbac.RbacClient
+}
+
+// Core retrieves the CoreClient
+func (c *Clientset) Core() unversionedcore.CoreInterface {
+ if c == nil {
+ return nil
+ }
+ return c.CoreClient
+}
+
+// Extensions retrieves the ExtensionsClient
+func (c *Clientset) Extensions() unversionedextensions.ExtensionsInterface {
+ if c == nil {
+ return nil
+ }
+ return c.ExtensionsClient
+}
+
+// Autoscaling retrieves the AutoscalingClient
+func (c *Clientset) Autoscaling() unversionedautoscaling.AutoscalingInterface {
+ if c == nil {
+ return nil
+ }
+ return c.AutoscalingClient
+}
+
+// Batch retrieves the BatchClient
+func (c *Clientset) Batch() unversionedbatch.BatchInterface {
+ if c == nil {
+ return nil
+ }
+ return c.BatchClient
+}
+
+// Rbac retrieves the RbacClient
+func (c *Clientset) Rbac() unversionedrbac.RbacInterface {
+ if c == nil {
+ return nil
+ }
+ return c.RbacClient
+}
+
+// Discovery retrieves the DiscoveryClient
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+ return c.DiscoveryClient
+}
+
+// NewForConfig creates a new Clientset for the given config.
+func NewForConfig(c *restclient.Config) (*Clientset, error) {
+ configShallowCopy := *c
+ if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+ configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+ }
+ var clientset Clientset
+ var err error
+ clientset.CoreClient, err = unversionedcore.NewForConfig(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+ clientset.ExtensionsClient, err = unversionedextensions.NewForConfig(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+ clientset.AutoscalingClient, err = unversionedautoscaling.NewForConfig(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+ clientset.BatchClient, err = unversionedbatch.NewForConfig(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+ clientset.RbacClient, err = unversionedrbac.NewForConfig(&configShallowCopy)
+ if err != nil {
+ return nil, err
+ }
+
+ clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
+ if err != nil {
+ glog.Errorf("failed to create the DiscoveryClient: %v", err)
+ return nil, err
+ }
+ return &clientset, nil
+}
+
+// NewForConfigOrDie creates a new Clientset for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *Clientset {
+ var clientset Clientset
+ clientset.CoreClient = unversionedcore.NewForConfigOrDie(c)
+ clientset.ExtensionsClient = unversionedextensions.NewForConfigOrDie(c)
+ clientset.AutoscalingClient = unversionedautoscaling.NewForConfigOrDie(c)
+ clientset.BatchClient = unversionedbatch.NewForConfigOrDie(c)
+ clientset.RbacClient = unversionedrbac.NewForConfigOrDie(c)
+
+ clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
+ return &clientset
+}
+
+// New creates a new Clientset for the given RESTClient.
+func New(c *restclient.RESTClient) *Clientset {
+ var clientset Clientset
+ clientset.CoreClient = unversionedcore.New(c)
+ clientset.ExtensionsClient = unversionedextensions.New(c)
+ clientset.AutoscalingClient = unversionedautoscaling.New(c)
+ clientset.BatchClient = unversionedbatch.New(c)
+ clientset.RbacClient = unversionedrbac.New(c)
+
+ clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
+ return &clientset
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..3934caa42ca9d3826fd1feedc4b1e2e1b493da14
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated clientset.
+package internalclientset
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/import_known_versions.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/import_known_versions.go
index c2d7fde2fb788b2cb2f60c04ed90005e4d9f0ad0..8bdbe2e6c9891293ce3948efa50f74a6701200d3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/import_known_versions.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package unversioned
+package internalclientset
// These imports are the API groups the client will support.
import (
@@ -22,12 +22,14 @@ import (
_ "k8s.io/kubernetes/pkg/api/install"
"k8s.io/kubernetes/pkg/apimachinery/registered"
+ _ "k8s.io/kubernetes/pkg/apis/apps/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/componentconfig/install"
_ "k8s.io/kubernetes/pkg/apis/extensions/install"
- _ "k8s.io/kubernetes/pkg/apis/metrics/install"
+ _ "k8s.io/kubernetes/pkg/apis/policy/install"
+ _ "k8s.io/kubernetes/pkg/apis/rbac/install"
)
func init() {
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/autoscaling_client.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/autoscaling_client.go
new file mode 100644
index 0000000000000000000000000000000000000000..752b5d554e2560c97915955202963895f2e1541e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/autoscaling_client.go
@@ -0,0 +1,101 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type AutoscalingInterface interface {
+ GetRESTClient() *restclient.RESTClient
+ HorizontalPodAutoscalersGetter
+}
+
+// AutoscalingClient is used to interact with features provided by the Autoscaling group.
+type AutoscalingClient struct {
+ *restclient.RESTClient
+}
+
+func (c *AutoscalingClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
+ return newHorizontalPodAutoscalers(c, namespace)
+}
+
+// NewForConfig creates a new AutoscalingClient for the given config.
+func NewForConfig(c *restclient.Config) (*AutoscalingClient, error) {
+ config := *c
+ if err := setConfigDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &AutoscalingClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new AutoscalingClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *AutoscalingClient {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new AutoscalingClient for the given RESTClient.
+func New(c *restclient.RESTClient) *AutoscalingClient {
+ return &AutoscalingClient{c}
+}
+
+func setConfigDefaults(config *restclient.Config) error {
+ // if autoscaling group is not registered, return an error
+ g, err := registered.Group("autoscaling")
+ if err != nil {
+ return err
+ }
+ config.APIPath = "/apis"
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.NegotiatedSerializer = api.Codecs
+
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *AutoscalingClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..47517b6422dd8acb00b14c944afd0e1fcc686ddc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/generated_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/generated_expansion.go
new file mode 100644
index 0000000000000000000000000000000000000000..39324902aaaf018237d937c1665e0b2d8bca6631
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/generated_expansion.go
@@ -0,0 +1,19 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+type HorizontalPodAutoscalerExpansion interface{}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/horizontalpodautoscaler.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/horizontalpodautoscaler.go
similarity index 76%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/horizontalpodautoscaler.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/horizontalpodautoscaler.go
index 2cffcee465650115a79b5b669a57ced7533ef7fb..ae185ad7fb9b2e3d1b34d415a2cc81789a569af9 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/horizontalpodautoscaler.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned/horizontalpodautoscaler.go
@@ -18,7 +18,7 @@ package unversioned
import (
api "k8s.io/kubernetes/pkg/api"
- extensions "k8s.io/kubernetes/pkg/apis/extensions"
+ autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
watch "k8s.io/kubernetes/pkg/watch"
)
@@ -30,25 +30,25 @@ type HorizontalPodAutoscalersGetter interface {
// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources.
type HorizontalPodAutoscalerInterface interface {
- Create(*extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
- Update(*extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
- UpdateStatus(*extensions.HorizontalPodAutoscaler) (*extensions.HorizontalPodAutoscaler, error)
+ Create(*autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
+ Update(*autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
+ UpdateStatus(*autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
Delete(name string, options *api.DeleteOptions) error
DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
- Get(name string) (*extensions.HorizontalPodAutoscaler, error)
- List(opts api.ListOptions) (*extensions.HorizontalPodAutoscalerList, error)
+ Get(name string) (*autoscaling.HorizontalPodAutoscaler, error)
+ List(opts api.ListOptions) (*autoscaling.HorizontalPodAutoscalerList, error)
Watch(opts api.ListOptions) (watch.Interface, error)
HorizontalPodAutoscalerExpansion
}
// horizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
type horizontalPodAutoscalers struct {
- client *ExtensionsClient
+ client *AutoscalingClient
ns string
}
// newHorizontalPodAutoscalers returns a HorizontalPodAutoscalers
-func newHorizontalPodAutoscalers(c *ExtensionsClient, namespace string) *horizontalPodAutoscalers {
+func newHorizontalPodAutoscalers(c *AutoscalingClient, namespace string) *horizontalPodAutoscalers {
return &horizontalPodAutoscalers{
client: c,
ns: namespace,
@@ -56,8 +56,8 @@ func newHorizontalPodAutoscalers(c *ExtensionsClient, namespace string) *horizon
}
// Create takes the representation of a horizontalPodAutoscaler and creates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
-func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
+func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
err = c.client.Post().
Namespace(c.ns).
Resource("horizontalpodautoscalers").
@@ -68,8 +68,8 @@ func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *extensions.Ho
}
// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
-func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
+func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
err = c.client.Put().
Namespace(c.ns).
Resource("horizontalpodautoscalers").
@@ -80,8 +80,8 @@ func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *extensions.Ho
return
}
-func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
+func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
err = c.client.Put().
Namespace(c.ns).
Resource("horizontalpodautoscalers").
@@ -116,8 +116,8 @@ func (c *horizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions,
}
// Get takes name of the horizontalPodAutoscaler, and returns the corresponding horizontalPodAutoscaler object, and an error if there is any.
-func (c *horizontalPodAutoscalers) Get(name string) (result *extensions.HorizontalPodAutoscaler, err error) {
- result = &extensions.HorizontalPodAutoscaler{}
+func (c *horizontalPodAutoscalers) Get(name string) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
err = c.client.Get().
Namespace(c.ns).
Resource("horizontalpodautoscalers").
@@ -128,8 +128,8 @@ func (c *horizontalPodAutoscalers) Get(name string) (result *extensions.Horizont
}
// List takes label and field selectors, and returns the list of HorizontalPodAutoscalers that match those selectors.
-func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *extensions.HorizontalPodAutoscalerList, err error) {
- result = &extensions.HorizontalPodAutoscalerList{}
+func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *autoscaling.HorizontalPodAutoscalerList, err error) {
+ result = &autoscaling.HorizontalPodAutoscalerList{}
err = c.client.Get().
Namespace(c.ns).
Resource("horizontalpodautoscalers").
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/batch_client.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/batch_client.go
new file mode 100644
index 0000000000000000000000000000000000000000..83d9d749c458930f09ca7e2bc00068a2bca87a9a
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/batch_client.go
@@ -0,0 +1,106 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type BatchInterface interface {
+ GetRESTClient() *restclient.RESTClient
+ JobsGetter
+ ScheduledJobsGetter
+}
+
+// BatchClient is used to interact with features provided by the Batch group.
+type BatchClient struct {
+ *restclient.RESTClient
+}
+
+func (c *BatchClient) Jobs(namespace string) JobInterface {
+ return newJobs(c, namespace)
+}
+
+func (c *BatchClient) ScheduledJobs(namespace string) ScheduledJobInterface {
+ return newScheduledJobs(c, namespace)
+}
+
+// NewForConfig creates a new BatchClient for the given config.
+func NewForConfig(c *restclient.Config) (*BatchClient, error) {
+ config := *c
+ if err := setConfigDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &BatchClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new BatchClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *BatchClient {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new BatchClient for the given RESTClient.
+func New(c *restclient.RESTClient) *BatchClient {
+ return &BatchClient{c}
+}
+
+func setConfigDefaults(config *restclient.Config) error {
+ // if batch group is not registered, return an error
+ g, err := registered.Group("batch")
+ if err != nil {
+ return err
+ }
+ config.APIPath = "/apis"
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.NegotiatedSerializer = api.Codecs
+
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *BatchClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..47517b6422dd8acb00b14c944afd0e1fcc686ddc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/generated_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/generated_expansion.go
new file mode 100644
index 0000000000000000000000000000000000000000..f876ef63fc2ab6c23e2e5394553c34641797d678
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/generated_expansion.go
@@ -0,0 +1,21 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+type JobExpansion interface{}
+
+type ScheduledJobExpansion interface{}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/job.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/job.go
new file mode 100644
index 0000000000000000000000000000000000000000..680c50654c6995dec8912fa6d1919674b39f4e66
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/job.go
@@ -0,0 +1,150 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// JobsGetter has a method to return a JobInterface.
+// A group's client should implement this interface.
+type JobsGetter interface {
+ Jobs(namespace string) JobInterface
+}
+
+// JobInterface has methods to work with Job resources.
+type JobInterface interface {
+ Create(*batch.Job) (*batch.Job, error)
+ Update(*batch.Job) (*batch.Job, error)
+ UpdateStatus(*batch.Job) (*batch.Job, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*batch.Job, error)
+ List(opts api.ListOptions) (*batch.JobList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ JobExpansion
+}
+
+// jobs implements JobInterface
+type jobs struct {
+ client *BatchClient
+ ns string
+}
+
+// newJobs returns a Jobs
+func newJobs(c *BatchClient, namespace string) *jobs {
+ return &jobs{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// Create takes the representation of a job and creates it. Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Create(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
+ err = c.client.Post().
+ Namespace(c.ns).
+ Resource("jobs").
+ Body(job).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a job and updates it. Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Update(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("jobs").
+ Name(job.Name).
+ Body(job).
+ Do().
+ Into(result)
+ return
+}
+
+func (c *jobs) UpdateStatus(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("jobs").
+ Name(job.Name).
+ SubResource("status").
+ Body(job).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the job and deletes it. Returns an error if one occurs.
+func (c *jobs) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("jobs").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("jobs").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the job, and returns the corresponding job object, and an error if there is any.
+func (c *jobs) Get(name string) (result *batch.Job, err error) {
+ result = &batch.Job{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("jobs").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of Jobs that match those selectors.
+func (c *jobs) List(opts api.ListOptions) (result *batch.JobList, err error) {
+ result = &batch.JobList{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("jobs").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested jobs.
+func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("jobs").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/scheduledjob.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/scheduledjob.go
new file mode 100644
index 0000000000000000000000000000000000000000..2675d11c48f2aef553d76473d5f04cc338de3857
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned/scheduledjob.go
@@ -0,0 +1,150 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ScheduledJobsGetter has a method to return a ScheduledJobInterface.
+// A group's client should implement this interface.
+type ScheduledJobsGetter interface {
+ ScheduledJobs(namespace string) ScheduledJobInterface
+}
+
+// ScheduledJobInterface has methods to work with ScheduledJob resources.
+type ScheduledJobInterface interface {
+ Create(*batch.ScheduledJob) (*batch.ScheduledJob, error)
+ Update(*batch.ScheduledJob) (*batch.ScheduledJob, error)
+ UpdateStatus(*batch.ScheduledJob) (*batch.ScheduledJob, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*batch.ScheduledJob, error)
+ List(opts api.ListOptions) (*batch.ScheduledJobList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ ScheduledJobExpansion
+}
+
+// scheduledJobs implements ScheduledJobInterface
+type scheduledJobs struct {
+ client *BatchClient
+ ns string
+}
+
+// newScheduledJobs returns a ScheduledJobs
+func newScheduledJobs(c *BatchClient, namespace string) *scheduledJobs {
+ return &scheduledJobs{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// Create takes the representation of a scheduledJob and creates it. Returns the server's representation of the scheduledJob, and an error, if there is any.
+func (c *scheduledJobs) Create(scheduledJob *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.client.Post().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ Body(scheduledJob).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a scheduledJob and updates it. Returns the server's representation of the scheduledJob, and an error, if there is any.
+func (c *scheduledJobs) Update(scheduledJob *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ Name(scheduledJob.Name).
+ Body(scheduledJob).
+ Do().
+ Into(result)
+ return
+}
+
+func (c *scheduledJobs) UpdateStatus(scheduledJob *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ Name(scheduledJob.Name).
+ SubResource("status").
+ Body(scheduledJob).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the scheduledJob and deletes it. Returns an error if one occurs.
+func (c *scheduledJobs) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *scheduledJobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the scheduledJob, and returns the corresponding scheduledJob object, and an error if there is any.
+func (c *scheduledJobs) Get(name string) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of ScheduledJobs that match those selectors.
+func (c *scheduledJobs) List(opts api.ListOptions) (result *batch.ScheduledJobList, err error) {
+ result = &batch.ScheduledJobList{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested scheduledJobs.
+func (c *scheduledJobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("scheduledjobs").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/componentstatus.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/componentstatus.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/componentstatus.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/componentstatus.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/configmap.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/configmap.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/configmap.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/configmap.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/core_client.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/core_client.go
index dc3561c0b49862adffda76f228eab03dc032d1d3..41aee4cf6543416ea6b8d255fbb11577284642ad 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/core_client.go
@@ -23,6 +23,7 @@ import (
)
type CoreInterface interface {
+ GetRESTClient() *restclient.RESTClient
ComponentStatusesGetter
ConfigMapsGetter
EndpointsGetter
@@ -154,7 +155,8 @@ func setConfigDefaults(config *restclient.Config) error {
config.GroupVersion = ©GroupVersion
//}
- config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
+
if config.QPS == 0 {
config.QPS = 5
}
@@ -163,3 +165,12 @@ func setConfigDefaults(config *restclient.Config) error {
}
return nil
}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *CoreClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..47517b6422dd8acb00b14c944afd0e1fcc686ddc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/endpoints.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/endpoints.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/endpoints.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/endpoints.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/event.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/event.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/event.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/event.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/event_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/event_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/event_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/event_expansion.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/generated_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/generated_expansion.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/generated_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/generated_expansion.go
index eeb51962e8bab52c839b98b9140d8e88105d4415..546f8e7a1d1c73835d59f9c35fb3558c7a9891f6 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/generated_expansion.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/generated_expansion.go
@@ -22,8 +22,6 @@ type EndpointsExpansion interface{}
type LimitRangeExpansion interface{}
-type NodeExpansion interface{}
-
type PersistentVolumeExpansion interface{}
type PersistentVolumeClaimExpansion interface{}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/limitrange.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/limitrange.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/limitrange.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/limitrange.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/namespace.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/namespace.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/namespace.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/namespace.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/namespace_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/namespace_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/namespace_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/namespace_expansion.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/node.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/node.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/node.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/node.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/node_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/node_expansion.go
new file mode 100644
index 0000000000000000000000000000000000000000..3146cdb357e0f445d0341917c361592561175ba9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/node_expansion.go
@@ -0,0 +1,40 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import "k8s.io/kubernetes/pkg/api"
+
+// The NodeExpansion interface allows manually adding extra methods to the NodeInterface.
+type NodeExpansion interface {
+ // PatchStatus modifies the status of an existing node. It returns the copy
+ // of the node that the server returns, or an error.
+ PatchStatus(nodeName string, data []byte) (*api.Node, error)
+}
+
+// PatchStatus modifies the status of an existing node. It returns the copy of
+// the node that the server returns, or an error.
+func (c *nodes) PatchStatus(nodeName string, data []byte) (*api.Node, error) {
+ result := &api.Node{}
+ err := c.client.Patch(api.StrategicMergePatchType).
+ Resource("nodes").
+ Name(nodeName).
+ SubResource("status").
+ Body(data).
+ Do().
+ Into(result)
+ return result, err
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/persistentvolume.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/persistentvolume.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/persistentvolume.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/persistentvolume.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/persistentvolumeclaim.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/persistentvolumeclaim.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/persistentvolumeclaim.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/persistentvolumeclaim.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/pod.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/pod.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/pod.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/pod.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/pod_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/pod_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/pod_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/pod_expansion.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/podtemplate.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/podtemplate.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/podtemplate.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/podtemplate.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/replicationcontroller.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/replicationcontroller.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/replicationcontroller.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/replicationcontroller.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/resourcequota.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/resourcequota.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/resourcequota.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/resourcequota.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/secret.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/secret.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/secret.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/secret.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/service.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/service.go
new file mode 100644
index 0000000000000000000000000000000000000000..006f601c271f7b8d5f693c67fe6f3299f3a8a688
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/service.go
@@ -0,0 +1,149 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ServicesGetter has a method to return a ServiceInterface.
+// A group's client should implement this interface.
+type ServicesGetter interface {
+ Services(namespace string) ServiceInterface
+}
+
+// ServiceInterface has methods to work with Service resources.
+type ServiceInterface interface {
+ Create(*api.Service) (*api.Service, error)
+ Update(*api.Service) (*api.Service, error)
+ UpdateStatus(*api.Service) (*api.Service, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*api.Service, error)
+ List(opts api.ListOptions) (*api.ServiceList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ ServiceExpansion
+}
+
+// services implements ServiceInterface
+type services struct {
+ client *CoreClient
+ ns string
+}
+
+// newServices returns a Services
+func newServices(c *CoreClient, namespace string) *services {
+ return &services{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// Create takes the representation of a service and creates it. Returns the server's representation of the service, and an error, if there is any.
+func (c *services) Create(service *api.Service) (result *api.Service, err error) {
+ result = &api.Service{}
+ err = c.client.Post().
+ Namespace(c.ns).
+ Resource("services").
+ Body(service).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a service and updates it. Returns the server's representation of the service, and an error, if there is any.
+func (c *services) Update(service *api.Service) (result *api.Service, err error) {
+ result = &api.Service{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("services").
+ Name(service.Name).
+ Body(service).
+ Do().
+ Into(result)
+ return
+}
+
+func (c *services) UpdateStatus(service *api.Service) (result *api.Service, err error) {
+ result = &api.Service{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("services").
+ Name(service.Name).
+ SubResource("status").
+ Body(service).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the service and deletes it. Returns an error if one occurs.
+func (c *services) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("services").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *services) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("services").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the service, and returns the corresponding service object, and an error if there is any.
+func (c *services) Get(name string) (result *api.Service, err error) {
+ result = &api.Service{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("services").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of Services that match those selectors.
+func (c *services) List(opts api.ListOptions) (result *api.ServiceList, err error) {
+ result = &api.ServiceList{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("services").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested services.
+func (c *services) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("services").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/service_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/service_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/service_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/service_expansion.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/serviceaccount.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/serviceaccount.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/serviceaccount.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned/serviceaccount.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/daemonset.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/daemonset.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/daemonset.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/daemonset.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/deployment.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/deployment.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/deployment.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/deployment.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/deployment_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/deployment_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/deployment_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/deployment_expansion.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..47517b6422dd8acb00b14c944afd0e1fcc686ddc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/extensions_client.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go
similarity index 84%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/extensions_client.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go
index 220dd69b5cd67276164fcd71c98ababa22070ae8..9b9f4749a64dcc099fa73b86cd72726c16cff251 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/extensions_client.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go
@@ -23,11 +23,11 @@ import (
)
type ExtensionsInterface interface {
+ GetRESTClient() *restclient.RESTClient
DaemonSetsGetter
DeploymentsGetter
- HorizontalPodAutoscalersGetter
IngressesGetter
- JobsGetter
+ PodSecurityPoliciesGetter
ReplicaSetsGetter
ScalesGetter
ThirdPartyResourcesGetter
@@ -46,16 +46,12 @@ func (c *ExtensionsClient) Deployments(namespace string) DeploymentInterface {
return newDeployments(c, namespace)
}
-func (c *ExtensionsClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
- return newHorizontalPodAutoscalers(c, namespace)
-}
-
func (c *ExtensionsClient) Ingresses(namespace string) IngressInterface {
return newIngresses(c, namespace)
}
-func (c *ExtensionsClient) Jobs(namespace string) JobInterface {
- return newJobs(c, namespace)
+func (c *ExtensionsClient) PodSecurityPolicies() PodSecurityPolicyInterface {
+ return newPodSecurityPolicies(c)
}
func (c *ExtensionsClient) ReplicaSets(namespace string) ReplicaSetInterface {
@@ -66,8 +62,8 @@ func (c *ExtensionsClient) Scales(namespace string) ScaleInterface {
return newScales(c, namespace)
}
-func (c *ExtensionsClient) ThirdPartyResources(namespace string) ThirdPartyResourceInterface {
- return newThirdPartyResources(c, namespace)
+func (c *ExtensionsClient) ThirdPartyResources() ThirdPartyResourceInterface {
+ return newThirdPartyResources(c)
}
// NewForConfig creates a new ExtensionsClient for the given config.
@@ -114,7 +110,8 @@ func setConfigDefaults(config *restclient.Config) error {
config.GroupVersion = ©GroupVersion
//}
- config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
+
if config.QPS == 0 {
config.QPS = 5
}
@@ -123,3 +120,12 @@ func setConfigDefaults(config *restclient.Config) error {
}
return nil
}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *ExtensionsClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/generated_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/generated_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go
index 0690e0c8c339c0b909d6f5b9c1a72dd8458978ed..7a1999454e6e056f271c0c6311a458ed48790a0a 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/generated_expansion.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go
@@ -24,6 +24,8 @@ type IngressExpansion interface{}
type JobExpansion interface{}
+type PodSecurityPolicyExpansion interface{}
+
type ThirdPartyResourceExpansion interface{}
type ReplicaSetExpansion interface{}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/ingress.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/ingress.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/ingress.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/ingress.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/job.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/job.go
similarity index 79%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/job.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/job.go
index 04d0d1282355678d3aa3dd3deb4c6cb2183956d7..4ae3f6cac55760ef6d9c3ddb020239d4d886f6de 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/job.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/job.go
@@ -18,7 +18,7 @@ package unversioned
import (
api "k8s.io/kubernetes/pkg/api"
- extensions "k8s.io/kubernetes/pkg/apis/extensions"
+ batch "k8s.io/kubernetes/pkg/apis/batch"
watch "k8s.io/kubernetes/pkg/watch"
)
@@ -30,13 +30,13 @@ type JobsGetter interface {
// JobInterface has methods to work with Job resources.
type JobInterface interface {
- Create(*extensions.Job) (*extensions.Job, error)
- Update(*extensions.Job) (*extensions.Job, error)
- UpdateStatus(*extensions.Job) (*extensions.Job, error)
+ Create(*batch.Job) (*batch.Job, error)
+ Update(*batch.Job) (*batch.Job, error)
+ UpdateStatus(*batch.Job) (*batch.Job, error)
Delete(name string, options *api.DeleteOptions) error
DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
- Get(name string) (*extensions.Job, error)
- List(opts api.ListOptions) (*extensions.JobList, error)
+ Get(name string) (*batch.Job, error)
+ List(opts api.ListOptions) (*batch.JobList, error)
Watch(opts api.ListOptions) (watch.Interface, error)
JobExpansion
}
@@ -56,8 +56,8 @@ func newJobs(c *ExtensionsClient, namespace string) *jobs {
}
// Create takes the representation of a job and creates it. Returns the server's representation of the job, and an error, if there is any.
-func (c *jobs) Create(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Create(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.client.Post().
Namespace(c.ns).
Resource("jobs").
@@ -68,8 +68,8 @@ func (c *jobs) Create(job *extensions.Job) (result *extensions.Job, err error) {
}
// Update takes the representation of a job and updates it. Returns the server's representation of the job, and an error, if there is any.
-func (c *jobs) Update(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Update(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.client.Put().
Namespace(c.ns).
Resource("jobs").
@@ -80,8 +80,8 @@ func (c *jobs) Update(job *extensions.Job) (result *extensions.Job, err error) {
return
}
-func (c *jobs) UpdateStatus(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) UpdateStatus(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.client.Put().
Namespace(c.ns).
Resource("jobs").
@@ -116,8 +116,8 @@ func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.List
}
// Get takes name of the job, and returns the corresponding job object, and an error if there is any.
-func (c *jobs) Get(name string) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Get(name string) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.client.Get().
Namespace(c.ns).
Resource("jobs").
@@ -128,8 +128,8 @@ func (c *jobs) Get(name string) (result *extensions.Job, err error) {
}
// List takes label and field selectors, and returns the list of Jobs that match those selectors.
-func (c *jobs) List(opts api.ListOptions) (result *extensions.JobList, err error) {
- result = &extensions.JobList{}
+func (c *jobs) List(opts api.ListOptions) (result *batch.JobList, err error) {
+ result = &batch.JobList{}
err = c.client.Get().
Namespace(c.ns).
Resource("jobs").
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/podsecuritypolicy.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/podsecuritypolicy.go
new file mode 100644
index 0000000000000000000000000000000000000000..06a7908f4675382bf8176a45cf61449d6e65e63d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/podsecuritypolicy.go
@@ -0,0 +1,127 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ extensions "k8s.io/kubernetes/pkg/apis/extensions"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// PodSecurityPoliciesGetter has a method to return a PodSecurityPolicyInterface.
+// A group's client should implement this interface.
+type PodSecurityPoliciesGetter interface {
+ PodSecurityPolicies() PodSecurityPolicyInterface
+}
+
+// PodSecurityPolicyInterface has methods to work with PodSecurityPolicy resources.
+type PodSecurityPolicyInterface interface {
+ Create(*extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error)
+ Update(*extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*extensions.PodSecurityPolicy, error)
+ List(opts api.ListOptions) (*extensions.PodSecurityPolicyList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ PodSecurityPolicyExpansion
+}
+
+// podSecurityPolicies implements PodSecurityPolicyInterface
+type podSecurityPolicies struct {
+ client *ExtensionsClient
+}
+
+// newPodSecurityPolicies returns a PodSecurityPolicies
+func newPodSecurityPolicies(c *ExtensionsClient) *podSecurityPolicies {
+ return &podSecurityPolicies{
+ client: c,
+ }
+}
+
+// Create takes the representation of a podSecurityPolicy and creates it. Returns the server's representation of the podSecurityPolicy, and an error, if there is any.
+func (c *podSecurityPolicies) Create(podSecurityPolicy *extensions.PodSecurityPolicy) (result *extensions.PodSecurityPolicy, err error) {
+ result = &extensions.PodSecurityPolicy{}
+ err = c.client.Post().
+ Resource("podsecuritypolicies").
+ Body(podSecurityPolicy).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a podSecurityPolicy and updates it. Returns the server's representation of the podSecurityPolicy, and an error, if there is any.
+func (c *podSecurityPolicies) Update(podSecurityPolicy *extensions.PodSecurityPolicy) (result *extensions.PodSecurityPolicy, err error) {
+ result = &extensions.PodSecurityPolicy{}
+ err = c.client.Put().
+ Resource("podsecuritypolicies").
+ Name(podSecurityPolicy.Name).
+ Body(podSecurityPolicy).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the podSecurityPolicy and deletes it. Returns an error if one occurs.
+func (c *podSecurityPolicies) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Resource("podsecuritypolicies").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *podSecurityPolicies) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Resource("podsecuritypolicies").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the podSecurityPolicy, and returns the corresponding podSecurityPolicy object, and an error if there is any.
+func (c *podSecurityPolicies) Get(name string) (result *extensions.PodSecurityPolicy, err error) {
+ result = &extensions.PodSecurityPolicy{}
+ err = c.client.Get().
+ Resource("podsecuritypolicies").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of PodSecurityPolicies that match those selectors.
+func (c *podSecurityPolicies) List(opts api.ListOptions) (result *extensions.PodSecurityPolicyList, err error) {
+ result = &extensions.PodSecurityPolicyList{}
+ err = c.client.Get().
+ Resource("podsecuritypolicies").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested podSecurityPolicies.
+func (c *podSecurityPolicies) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("podsecuritypolicies").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/replicaset.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/replicaset.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/replicaset.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/replicaset.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/scale.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/scale.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/scale.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/scale.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/scale_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/scale_expansion.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/scale_expansion.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/scale_expansion.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/thirdpartyresource.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/thirdpartyresource.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/thirdpartyresource.go
rename to vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/thirdpartyresource.go
index 0f1026fab524b8404fb4074b34b521a0a6408a20..a64ffb62c426908ba0eef7fc62ac4d201153ff68 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/thirdpartyresource.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/thirdpartyresource.go
@@ -25,7 +25,7 @@ import (
// ThirdPartyResourcesGetter has a method to return a ThirdPartyResourceInterface.
// A group's client should implement this interface.
type ThirdPartyResourcesGetter interface {
- ThirdPartyResources(namespace string) ThirdPartyResourceInterface
+ ThirdPartyResources() ThirdPartyResourceInterface
}
// ThirdPartyResourceInterface has methods to work with ThirdPartyResource resources.
@@ -43,14 +43,12 @@ type ThirdPartyResourceInterface interface {
// thirdPartyResources implements ThirdPartyResourceInterface
type thirdPartyResources struct {
client *ExtensionsClient
- ns string
}
// newThirdPartyResources returns a ThirdPartyResources
-func newThirdPartyResources(c *ExtensionsClient, namespace string) *thirdPartyResources {
+func newThirdPartyResources(c *ExtensionsClient) *thirdPartyResources {
return &thirdPartyResources{
client: c,
- ns: namespace,
}
}
@@ -58,7 +56,6 @@ func newThirdPartyResources(c *ExtensionsClient, namespace string) *thirdPartyRe
func (c *thirdPartyResources) Create(thirdPartyResource *extensions.ThirdPartyResource) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
err = c.client.Post().
- Namespace(c.ns).
Resource("thirdpartyresources").
Body(thirdPartyResource).
Do().
@@ -70,7 +67,6 @@ func (c *thirdPartyResources) Create(thirdPartyResource *extensions.ThirdPartyRe
func (c *thirdPartyResources) Update(thirdPartyResource *extensions.ThirdPartyResource) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
err = c.client.Put().
- Namespace(c.ns).
Resource("thirdpartyresources").
Name(thirdPartyResource.Name).
Body(thirdPartyResource).
@@ -82,7 +78,6 @@ func (c *thirdPartyResources) Update(thirdPartyResource *extensions.ThirdPartyRe
// Delete takes name of the thirdPartyResource and deletes it. Returns an error if one occurs.
func (c *thirdPartyResources) Delete(name string, options *api.DeleteOptions) error {
return c.client.Delete().
- Namespace(c.ns).
Resource("thirdpartyresources").
Name(name).
Body(options).
@@ -93,7 +88,6 @@ func (c *thirdPartyResources) Delete(name string, options *api.DeleteOptions) er
// DeleteCollection deletes a collection of objects.
func (c *thirdPartyResources) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
return c.client.Delete().
- Namespace(c.ns).
Resource("thirdpartyresources").
VersionedParams(&listOptions, api.ParameterCodec).
Body(options).
@@ -105,7 +99,6 @@ func (c *thirdPartyResources) DeleteCollection(options *api.DeleteOptions, listO
func (c *thirdPartyResources) Get(name string) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
err = c.client.Get().
- Namespace(c.ns).
Resource("thirdpartyresources").
Name(name).
Do().
@@ -117,7 +110,6 @@ func (c *thirdPartyResources) Get(name string) (result *extensions.ThirdPartyRes
func (c *thirdPartyResources) List(opts api.ListOptions) (result *extensions.ThirdPartyResourceList, err error) {
result = &extensions.ThirdPartyResourceList{}
err = c.client.Get().
- Namespace(c.ns).
Resource("thirdpartyresources").
VersionedParams(&opts, api.ParameterCodec).
Do().
@@ -129,7 +121,6 @@ func (c *thirdPartyResources) List(opts api.ListOptions) (result *extensions.Thi
func (c *thirdPartyResources) Watch(opts api.ListOptions) (watch.Interface, error) {
return c.client.Get().
Prefix("watch").
- Namespace(c.ns).
Resource("thirdpartyresources").
VersionedParams(&opts, api.ParameterCodec).
Watch()
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrole.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrole.go
new file mode 100644
index 0000000000000000000000000000000000000000..5d0b3912a53f333f8f599d85587946a2735f1788
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrole.go
@@ -0,0 +1,127 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ rbac "k8s.io/kubernetes/pkg/apis/rbac"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ClusterRolesGetter has a method to return a ClusterRoleInterface.
+// A group's client should implement this interface.
+type ClusterRolesGetter interface {
+ ClusterRoles() ClusterRoleInterface
+}
+
+// ClusterRoleInterface has methods to work with ClusterRole resources.
+type ClusterRoleInterface interface {
+ Create(*rbac.ClusterRole) (*rbac.ClusterRole, error)
+ Update(*rbac.ClusterRole) (*rbac.ClusterRole, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*rbac.ClusterRole, error)
+ List(opts api.ListOptions) (*rbac.ClusterRoleList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ ClusterRoleExpansion
+}
+
+// clusterRoles implements ClusterRoleInterface
+type clusterRoles struct {
+ client *RbacClient
+}
+
+// newClusterRoles returns a ClusterRoles
+func newClusterRoles(c *RbacClient) *clusterRoles {
+ return &clusterRoles{
+ client: c,
+ }
+}
+
+// Create takes the representation of a clusterRole and creates it. Returns the server's representation of the clusterRole, and an error, if there is any.
+func (c *clusterRoles) Create(clusterRole *rbac.ClusterRole) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Post().
+ Resource("clusterroles").
+ Body(clusterRole).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a clusterRole and updates it. Returns the server's representation of the clusterRole, and an error, if there is any.
+func (c *clusterRoles) Update(clusterRole *rbac.ClusterRole) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Put().
+ Resource("clusterroles").
+ Name(clusterRole.Name).
+ Body(clusterRole).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the clusterRole and deletes it. Returns an error if one occurs.
+func (c *clusterRoles) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Resource("clusterroles").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *clusterRoles) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Resource("clusterroles").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the clusterRole, and returns the corresponding clusterRole object, and an error if there is any.
+func (c *clusterRoles) Get(name string) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Get().
+ Resource("clusterroles").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of ClusterRoles that match those selectors.
+func (c *clusterRoles) List(opts api.ListOptions) (result *rbac.ClusterRoleList, err error) {
+ result = &rbac.ClusterRoleList{}
+ err = c.client.Get().
+ Resource("clusterroles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested clusterRoles.
+func (c *clusterRoles) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("clusterroles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrolebinding.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrolebinding.go
new file mode 100644
index 0000000000000000000000000000000000000000..f2102592afcd39f8a66c67593e07aaaf9c35d19c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/clusterrolebinding.go
@@ -0,0 +1,127 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ rbac "k8s.io/kubernetes/pkg/apis/rbac"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ClusterRoleBindingsGetter has a method to return a ClusterRoleBindingInterface.
+// A group's client should implement this interface.
+type ClusterRoleBindingsGetter interface {
+ ClusterRoleBindings() ClusterRoleBindingInterface
+}
+
+// ClusterRoleBindingInterface has methods to work with ClusterRoleBinding resources.
+type ClusterRoleBindingInterface interface {
+ Create(*rbac.ClusterRoleBinding) (*rbac.ClusterRoleBinding, error)
+ Update(*rbac.ClusterRoleBinding) (*rbac.ClusterRoleBinding, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*rbac.ClusterRoleBinding, error)
+ List(opts api.ListOptions) (*rbac.ClusterRoleBindingList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ ClusterRoleBindingExpansion
+}
+
+// clusterRoleBindings implements ClusterRoleBindingInterface
+type clusterRoleBindings struct {
+ client *RbacClient
+}
+
+// newClusterRoleBindings returns a ClusterRoleBindings
+func newClusterRoleBindings(c *RbacClient) *clusterRoleBindings {
+ return &clusterRoleBindings{
+ client: c,
+ }
+}
+
+// Create takes the representation of a clusterRoleBinding and creates it. Returns the server's representation of the clusterRoleBinding, and an error, if there is any.
+func (c *clusterRoleBindings) Create(clusterRoleBinding *rbac.ClusterRoleBinding) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Post().
+ Resource("clusterrolebindings").
+ Body(clusterRoleBinding).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a clusterRoleBinding and updates it. Returns the server's representation of the clusterRoleBinding, and an error, if there is any.
+func (c *clusterRoleBindings) Update(clusterRoleBinding *rbac.ClusterRoleBinding) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Put().
+ Resource("clusterrolebindings").
+ Name(clusterRoleBinding.Name).
+ Body(clusterRoleBinding).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the clusterRoleBinding and deletes it. Returns an error if one occurs.
+func (c *clusterRoleBindings) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Resource("clusterrolebindings").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *clusterRoleBindings) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Resource("clusterrolebindings").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the clusterRoleBinding, and returns the corresponding clusterRoleBinding object, and an error if there is any.
+func (c *clusterRoleBindings) Get(name string) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Get().
+ Resource("clusterrolebindings").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of ClusterRoleBindings that match those selectors.
+func (c *clusterRoleBindings) List(opts api.ListOptions) (result *rbac.ClusterRoleBindingList, err error) {
+ result = &rbac.ClusterRoleBindingList{}
+ err = c.client.Get().
+ Resource("clusterrolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested clusterRoleBindings.
+func (c *clusterRoleBindings) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("clusterrolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..47517b6422dd8acb00b14c944afd0e1fcc686ddc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This package is generated by client-gen with the default arguments.
+
+// This package has the automatically generated typed clients.
+package unversioned
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/generated_expansion.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/generated_expansion.go
new file mode 100644
index 0000000000000000000000000000000000000000..a3b9c689d35920b7b69386ca4028c56c0c9787dc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/generated_expansion.go
@@ -0,0 +1,25 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+type ClusterRoleExpansion interface{}
+
+type ClusterRoleBindingExpansion interface{}
+
+type RoleExpansion interface{}
+
+type RoleBindingExpansion interface{}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rbac_client.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rbac_client.go
new file mode 100644
index 0000000000000000000000000000000000000000..4d67337cde2cd65c1635fa5231518205dbcb70e0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rbac_client.go
@@ -0,0 +1,116 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ registered "k8s.io/kubernetes/pkg/apimachinery/registered"
+ restclient "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type RbacInterface interface {
+ GetRESTClient() *restclient.RESTClient
+ ClusterRolesGetter
+ ClusterRoleBindingsGetter
+ RolesGetter
+ RoleBindingsGetter
+}
+
+// RbacClient is used to interact with features provided by the Rbac group.
+type RbacClient struct {
+ *restclient.RESTClient
+}
+
+func (c *RbacClient) ClusterRoles() ClusterRoleInterface {
+ return newClusterRoles(c)
+}
+
+func (c *RbacClient) ClusterRoleBindings() ClusterRoleBindingInterface {
+ return newClusterRoleBindings(c)
+}
+
+func (c *RbacClient) Roles(namespace string) RoleInterface {
+ return newRoles(c, namespace)
+}
+
+func (c *RbacClient) RoleBindings(namespace string) RoleBindingInterface {
+ return newRoleBindings(c, namespace)
+}
+
+// NewForConfig creates a new RbacClient for the given config.
+func NewForConfig(c *restclient.Config) (*RbacClient, error) {
+ config := *c
+ if err := setConfigDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &RbacClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new RbacClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *restclient.Config) *RbacClient {
+ client, err := NewForConfig(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+// New creates a new RbacClient for the given RESTClient.
+func New(c *restclient.RESTClient) *RbacClient {
+ return &RbacClient{c}
+}
+
+func setConfigDefaults(config *restclient.Config) error {
+ // if rbac group is not registered, return an error
+ g, err := registered.Group("rbac.authorization.k8s.io")
+ if err != nil {
+ return err
+ }
+ config.APIPath = "/apis"
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.NegotiatedSerializer = api.Codecs
+
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *RbacClient) GetRESTClient() *restclient.RESTClient {
+ if c == nil {
+ return nil
+ }
+ return c.RESTClient
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/role.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/role.go
new file mode 100644
index 0000000000000000000000000000000000000000..68e7ebe93b8c1d9b929b4498070cb114c9c852bb
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/role.go
@@ -0,0 +1,136 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ rbac "k8s.io/kubernetes/pkg/apis/rbac"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// RolesGetter has a method to return a RoleInterface.
+// A group's client should implement this interface.
+type RolesGetter interface {
+ Roles(namespace string) RoleInterface
+}
+
+// RoleInterface has methods to work with Role resources.
+type RoleInterface interface {
+ Create(*rbac.Role) (*rbac.Role, error)
+ Update(*rbac.Role) (*rbac.Role, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*rbac.Role, error)
+ List(opts api.ListOptions) (*rbac.RoleList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ RoleExpansion
+}
+
+// roles implements RoleInterface
+type roles struct {
+ client *RbacClient
+ ns string
+}
+
+// newRoles returns a Roles
+func newRoles(c *RbacClient, namespace string) *roles {
+ return &roles{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// Create takes the representation of a role and creates it. Returns the server's representation of the role, and an error, if there is any.
+func (c *roles) Create(role *rbac.Role) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Post().
+ Namespace(c.ns).
+ Resource("roles").
+ Body(role).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a role and updates it. Returns the server's representation of the role, and an error, if there is any.
+func (c *roles) Update(role *rbac.Role) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("roles").
+ Name(role.Name).
+ Body(role).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the role and deletes it. Returns an error if one occurs.
+func (c *roles) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("roles").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *roles) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("roles").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the role, and returns the corresponding role object, and an error if there is any.
+func (c *roles) Get(name string) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("roles").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of Roles that match those selectors.
+func (c *roles) List(opts api.ListOptions) (result *rbac.RoleList, err error) {
+ result = &rbac.RoleList{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("roles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested roles.
+func (c *roles) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("roles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rolebinding.go b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rolebinding.go
new file mode 100644
index 0000000000000000000000000000000000000000..c73318c9794c71b06908cf34e6c519552696e838
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/unversioned/rolebinding.go
@@ -0,0 +1,136 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ api "k8s.io/kubernetes/pkg/api"
+ rbac "k8s.io/kubernetes/pkg/apis/rbac"
+ watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// RoleBindingsGetter has a method to return a RoleBindingInterface.
+// A group's client should implement this interface.
+type RoleBindingsGetter interface {
+ RoleBindings(namespace string) RoleBindingInterface
+}
+
+// RoleBindingInterface has methods to work with RoleBinding resources.
+type RoleBindingInterface interface {
+ Create(*rbac.RoleBinding) (*rbac.RoleBinding, error)
+ Update(*rbac.RoleBinding) (*rbac.RoleBinding, error)
+ Delete(name string, options *api.DeleteOptions) error
+ DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+ Get(name string) (*rbac.RoleBinding, error)
+ List(opts api.ListOptions) (*rbac.RoleBindingList, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ RoleBindingExpansion
+}
+
+// roleBindings implements RoleBindingInterface
+type roleBindings struct {
+ client *RbacClient
+ ns string
+}
+
+// newRoleBindings returns a RoleBindings
+func newRoleBindings(c *RbacClient, namespace string) *roleBindings {
+ return &roleBindings{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// Create takes the representation of a roleBinding and creates it. Returns the server's representation of the roleBinding, and an error, if there is any.
+func (c *roleBindings) Create(roleBinding *rbac.RoleBinding) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Post().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ Body(roleBinding).
+ Do().
+ Into(result)
+ return
+}
+
+// Update takes the representation of a roleBinding and updates it. Returns the server's representation of the roleBinding, and an error, if there is any.
+func (c *roleBindings) Update(roleBinding *rbac.RoleBinding) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Put().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ Name(roleBinding.Name).
+ Body(roleBinding).
+ Do().
+ Into(result)
+ return
+}
+
+// Delete takes name of the roleBinding and deletes it. Returns an error if one occurs.
+func (c *roleBindings) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ Name(name).
+ Body(options).
+ Do().
+ Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *roleBindings) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+ return c.client.Delete().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ VersionedParams(&listOptions, api.ParameterCodec).
+ Body(options).
+ Do().
+ Error()
+}
+
+// Get takes name of the roleBinding, and returns the corresponding roleBinding object, and an error if there is any.
+func (c *roleBindings) Get(name string) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ Name(name).
+ Do().
+ Into(result)
+ return
+}
+
+// List takes label and field selectors, and returns the list of RoleBindings that match those selectors.
+func (c *roleBindings) List(opts api.ListOptions) (result *rbac.RoleBindingList, err error) {
+ result = &rbac.RoleBindingList{}
+ err = c.client.Get().
+ Namespace(c.ns).
+ Resource("rolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Do().
+ Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested roleBindings.
+func (c *roleBindings) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("rolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/metrics/metrics.go b/vendor/k8s.io/kubernetes/pkg/client/metrics/metrics.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/metrics/metrics.go
rename to vendor/k8s.io/kubernetes/pkg/client/metrics/metrics.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/doc.go b/vendor/k8s.io/kubernetes/pkg/client/record/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/doc.go
rename to vendor/k8s.io/kubernetes/pkg/client/record/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/event.go b/vendor/k8s.io/kubernetes/pkg/client/record/event.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/event.go
rename to vendor/k8s.io/kubernetes/pkg/client/record/event.go
index a4786824755ae8ec8f8545354c8476c97524ffd3..47cbe3eca69f87fca34ecec7fe8f55e7b5ec8f1f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/event.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/record/event.go
@@ -31,11 +31,12 @@ import (
"k8s.io/kubernetes/pkg/watch"
"github.com/golang/glog"
+ "net/http"
)
const maxTriesPerEvent = 12
-var sleepDuration = 10 * time.Second
+var defaultSleepDuration = 10 * time.Second
const maxQueuedEvents = 1000
@@ -93,11 +94,16 @@ type EventBroadcaster interface {
// Creates a new event broadcaster.
func NewBroadcaster() EventBroadcaster {
- return &eventBroadcasterImpl{watch.NewBroadcaster(maxQueuedEvents, watch.DropIfChannelFull)}
+ return &eventBroadcasterImpl{watch.NewBroadcaster(maxQueuedEvents, watch.DropIfChannelFull), defaultSleepDuration}
+}
+
+func NewBroadcasterForTests(sleepDuration time.Duration) EventBroadcaster {
+ return &eventBroadcasterImpl{watch.NewBroadcaster(maxQueuedEvents, watch.DropIfChannelFull), sleepDuration}
}
type eventBroadcasterImpl struct {
*watch.Broadcaster
+ sleepDuration time.Duration
}
// StartRecordingToSink starts sending events received from the specified eventBroadcaster to the given sink.
@@ -110,11 +116,11 @@ func (eventBroadcaster *eventBroadcasterImpl) StartRecordingToSink(sink EventSin
eventCorrelator := NewEventCorrelator(util.RealClock{})
return eventBroadcaster.StartEventWatcher(
func(event *api.Event) {
- recordToSink(sink, event, eventCorrelator, randGen)
+ recordToSink(sink, event, eventCorrelator, randGen, eventBroadcaster.sleepDuration)
})
}
-func recordToSink(sink EventSink, event *api.Event, eventCorrelator *EventCorrelator, randGen *rand.Rand) {
+func recordToSink(sink EventSink, event *api.Event, eventCorrelator *EventCorrelator, randGen *rand.Rand, sleepDuration time.Duration) {
// Make a copy before modification, because there could be multiple listeners.
// Events are safe to copy like this.
eventCopy := *event
@@ -148,12 +154,11 @@ func recordToSink(sink EventSink, event *api.Event, eventCorrelator *EventCorrel
func isKeyNotFoundError(err error) bool {
statusErr, _ := err.(*errors.StatusError)
- // At the moment the server is returning 500 instead of a more specific
- // error. When changing this remember that it should be backward compatible
- // with old api servers that may be still returning 500.
- if statusErr != nil && statusErr.Status().Code == 500 {
+
+ if statusErr != nil && statusErr.Status().Code == http.StatusNotFound {
return true
}
+
return false
}
@@ -289,7 +294,7 @@ func (recorder *recorderImpl) PastEventf(object runtime.Object, timestamp unvers
}
func (recorder *recorderImpl) makeEvent(ref *api.ObjectReference, eventtype, reason, message string) *api.Event {
- t := unversioned.Time{recorder.clock.Now()}
+ t := unversioned.Time{Time: recorder.clock.Now()}
namespace := ref.Namespace
if namespace == "" {
namespace = api.NamespaceDefault
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/events_cache.go b/vendor/k8s.io/kubernetes/pkg/client/record/events_cache.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/events_cache.go
rename to vendor/k8s.io/kubernetes/pkg/client/record/events_cache.go
index 5d93ba6a68a5e14d87f0b1e61d56c72a0f222b6e..fa76db795813002d8a3019093c66b7bbdfa252f2 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/events_cache.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/record/events_cache.go
@@ -236,7 +236,7 @@ func (e *eventLogger) eventObserve(newEvent *api.Event) (*api.Event, []byte, err
event.Name = lastObservation.name
event.ResourceVersion = lastObservation.resourceVersion
event.FirstTimestamp = lastObservation.firstTimestamp
- event.Count = lastObservation.count + 1
+ event.Count = int32(lastObservation.count) + 1
eventCopy2 := *event
eventCopy2.Count = 0
@@ -251,7 +251,7 @@ func (e *eventLogger) eventObserve(newEvent *api.Event) (*api.Event, []byte, err
e.cache.Add(
key,
eventLog{
- count: event.Count,
+ count: int(event.Count),
firstTimestamp: event.FirstTimestamp,
name: event.Name,
resourceVersion: event.ResourceVersion,
@@ -269,7 +269,7 @@ func (e *eventLogger) updateState(event *api.Event) {
e.cache.Add(
key,
eventLog{
- count: event.Count,
+ count: int(event.Count),
firstTimestamp: event.FirstTimestamp,
name: event.Name,
resourceVersion: event.ResourceVersion,
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/fake.go b/vendor/k8s.io/kubernetes/pkg/client/record/fake.go
similarity index 63%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/fake.go
rename to vendor/k8s.io/kubernetes/pkg/client/record/fake.go
index 7afe1bab205550a8157b674db319a3a2f63ce8eb..35204ef2df6d2c1d79e11388ce01c5d82bfc3840 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/record/fake.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/record/fake.go
@@ -23,18 +23,32 @@ import (
"k8s.io/kubernetes/pkg/runtime"
)
-// FakeRecorder is used as a fake during tests.
+// FakeRecorder is used as a fake during tests. It is thread safe. It is usable
+// when created manually and not by NewFakeRecorder, however all events may be
+// thrown away in this case.
type FakeRecorder struct {
- Events []string
+ Events chan string
}
func (f *FakeRecorder) Event(object runtime.Object, eventtype, reason, message string) {
- f.Events = append(f.Events, fmt.Sprintf("%s %s %s", eventtype, reason, message))
+ if f.Events != nil {
+ f.Events <- fmt.Sprintf("%s %s %s", eventtype, reason, message)
+ }
}
func (f *FakeRecorder) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {
- f.Events = append(f.Events, fmt.Sprintf(eventtype+" "+reason+" "+messageFmt, args...))
+ if f.Events != nil {
+ f.Events <- fmt.Sprintf(eventtype+" "+reason+" "+messageFmt, args...)
+ }
}
func (f *FakeRecorder) PastEventf(object runtime.Object, timestamp unversioned.Time, eventtype, reason, messageFmt string, args ...interface{}) {
}
+
+// NewFakeRecorder creates new fake event recorder with event channel with
+// buffer of given size.
+func NewFakeRecorder(bufferSize int) *FakeRecorder {
+ return &FakeRecorder{
+ Events: make(chan string, bufferSize),
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/client.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/client.go
similarity index 61%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/client.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/client.go
index 2e378a9225b0982e3833637acaed8ab28d2aecc0..230edd45c743608ae521c0f66ff582a2edeff6b3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/client.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/client.go
@@ -17,6 +17,7 @@ limitations under the License.
package restclient
import (
+ "fmt"
"net/http"
"net/url"
"os"
@@ -26,7 +27,8 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
- "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
)
const (
@@ -52,17 +54,31 @@ type RESTClient struct {
// contentConfig is the information used to communicate with the server.
contentConfig ContentConfig
+ // serializers contain all serializers for undelying content type.
+ serializers Serializers
+
+ // creates BackoffManager that is passed to requests.
+ createBackoffMgr func() BackoffManager
+
// TODO extract this into a wrapper interface via the RESTClient interface in kubectl.
- Throttle util.RateLimiter
+ Throttle flowcontrol.RateLimiter
// Set specific behavior of the client. If not set http.DefaultClient will be used.
Client *http.Client
}
+type Serializers struct {
+ Encoder runtime.Encoder
+ Decoder runtime.Decoder
+ StreamingSerializer runtime.Serializer
+ Framer runtime.Framer
+ RenegotiatedDecoder func(contentType string, params map[string]string) (runtime.Decoder, error)
+}
+
// NewRESTClient creates a new RESTClient. This client performs generic REST functions
// such as Get, Put, Post, and Delete on specified paths. Codec controls encoding and
// decoding of responses from the server.
-func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ContentConfig, maxQPS float32, maxBurst int, client *http.Client) *RESTClient {
+func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ContentConfig, maxQPS float32, maxBurst int, rateLimiter flowcontrol.RateLimiter, client *http.Client) (*RESTClient, error) {
base := *baseURL
if !strings.HasSuffix(base.Path, "/") {
base.Path += "/"
@@ -76,18 +92,34 @@ func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ContentConf
if len(config.ContentType) == 0 {
config.ContentType = "application/json"
}
+ serializers, err := createSerializers(config)
+ if err != nil {
+ return nil, err
+ }
- var throttle util.RateLimiter
- if maxQPS > 0 {
- throttle = util.NewTokenBucketRateLimiter(maxQPS, maxBurst)
+ var throttle flowcontrol.RateLimiter
+ if maxQPS > 0 && rateLimiter == nil {
+ throttle = flowcontrol.NewTokenBucketRateLimiter(maxQPS, maxBurst)
+ } else if rateLimiter != nil {
+ throttle = rateLimiter
}
return &RESTClient{
base: &base,
versionedAPIPath: versionedAPIPath,
contentConfig: config,
+ serializers: *serializers,
+ createBackoffMgr: readExpBackoffConfig,
Throttle: throttle,
Client: client,
+ }, nil
+}
+
+// GetRateLimiter returns rate limier for a given client, or nil if it's called on a nil client
+func (c *RESTClient) GetRateLimiter() flowcontrol.RateLimiter {
+ if c == nil {
+ return nil
}
+ return c.Throttle
}
// readExpBackoffConfig handles the internal logic of determining what the
@@ -103,15 +135,47 @@ func readExpBackoffConfig() BackoffManager {
return &NoBackoff{}
}
return &URLBackoff{
- Backoff: util.NewBackOff(
+ Backoff: flowcontrol.NewBackOff(
time.Duration(backoffBaseInt)*time.Second,
time.Duration(backoffDurationInt)*time.Second)}
}
+// createSerializers creates all necessary serializers for given contentType.
+func createSerializers(config ContentConfig) (*Serializers, error) {
+ negotiated := config.NegotiatedSerializer
+ contentType := config.ContentType
+ info, ok := negotiated.SerializerForMediaType(contentType, nil)
+ if !ok {
+ return nil, fmt.Errorf("serializer for %s not registered", contentType)
+ }
+ streamInfo, ok := negotiated.StreamingSerializerForMediaType(contentType, nil)
+ if !ok {
+ return nil, fmt.Errorf("streaming serializer for %s not registered", contentType)
+ }
+ internalGV := unversioned.GroupVersion{
+ Group: config.GroupVersion.Group,
+ Version: runtime.APIVersionInternal,
+ }
+ return &Serializers{
+ Encoder: negotiated.EncoderForVersion(info.Serializer, *config.GroupVersion),
+ Decoder: negotiated.DecoderToVersion(info.Serializer, internalGV),
+ StreamingSerializer: streamInfo.Serializer,
+ Framer: streamInfo.Framer,
+ RenegotiatedDecoder: func(contentType string, params map[string]string) (runtime.Decoder, error) {
+ renegotiated, ok := negotiated.SerializerForMediaType(contentType, params)
+ if !ok {
+ return nil, fmt.Errorf("serializer for %s not registered", contentType)
+ }
+ return negotiated.DecoderToVersion(renegotiated.Serializer, internalGV), nil
+ },
+ }, nil
+}
+
// Verb begins a request with a verb (GET, POST, PUT, DELETE).
//
// Example usage of RESTClient's request building interface:
-// c := NewRESTClient(url, codec)
+// c, err := NewRESTClient(...)
+// if err != nil { ... }
// resp, err := c.Verb("GET").
// Path("pods").
// SelectorParam("labels", "area=staging").
@@ -121,12 +185,12 @@ func readExpBackoffConfig() BackoffManager {
// list, ok := resp.(*api.PodList)
//
func (c *RESTClient) Verb(verb string) *Request {
- backoff := readExpBackoffConfig()
+ backoff := c.createBackoffMgr()
if c.Client == nil {
- return NewRequest(nil, verb, c.base, c.versionedAPIPath, c.contentConfig, backoff, c.Throttle)
+ return NewRequest(nil, verb, c.base, c.versionedAPIPath, c.contentConfig, c.serializers, backoff, c.Throttle)
}
- return NewRequest(c.Client, verb, c.base, c.versionedAPIPath, c.contentConfig, backoff, c.Throttle)
+ return NewRequest(c.Client, verb, c.base, c.versionedAPIPath, c.contentConfig, c.serializers, backoff, c.Throttle)
}
// Post begins a POST request. Short for c.Verb("POST").
@@ -158,3 +222,7 @@ func (c *RESTClient) Delete() *Request {
func (c *RESTClient) APIVersion() unversioned.GroupVersion {
return *c.contentConfig.GroupVersion
}
+
+func (c *RESTClient) Codec() runtime.Codec {
+ return c.contentConfig.Codec
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/config.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/config.go
similarity index 86%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/config.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/config.go
index b084a8eb2b8718588a30d09b9bf7c2a4efba7fdc..0741e3c2d8f4459183fa760d713081fea31cffc1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/config.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/config.go
@@ -30,8 +30,10 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
+ clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
"k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/util/crypto"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
"k8s.io/kubernetes/pkg/version"
)
@@ -62,6 +64,15 @@ type Config struct {
// TODO: demonstrate an OAuth2 compatible client.
BearerToken string
+ // Impersonate is the username that this RESTClient will impersonate
+ Impersonate string
+
+ // Server requires plugin-specified authentication.
+ AuthProvider *clientcmdapi.AuthProviderConfig
+
+ // Callback to persist config for AuthProvider.
+ AuthConfigPersister AuthProviderConfigPersister
+
// TLSClientConfig contains settings to enable transport layer security
TLSClientConfig
@@ -87,6 +98,9 @@ type Config struct {
// Maximum burst for throttle
Burst int
+
+ // Rate limiter for limiting connections to the master from this client. If present overwrites QPS/Burst
+ RateLimiter flowcontrol.RateLimiter
}
// TLSClientConfig contains settings to enable transport layer security
@@ -119,9 +133,17 @@ type ContentConfig struct {
// a RESTClient directly. When initializing a Client, will be set with the default
// code version.
GroupVersion *unversioned.GroupVersion
+ // NegotiatedSerializer is used for obtaining encoders and decoders for multiple
+ // supported media types.
+ NegotiatedSerializer runtime.NegotiatedSerializer
+
// Codec specifies the encoding and decoding behavior for runtime.Objects passed
// to a RESTClient or Client. Required when initializing a RESTClient, optional
// when initializing a Client.
+ //
+ // DEPRECATED: Please use NegotiatedSerializer instead.
+ // Codec is currently used only in some tests and will be removed soon.
+ // All production setups should use NegotiatedSerializer.
Codec runtime.Codec
}
@@ -133,8 +155,8 @@ func RESTClientFor(config *Config) (*RESTClient, error) {
if config.GroupVersion == nil {
return nil, fmt.Errorf("GroupVersion is required when initializing a RESTClient")
}
- if config.Codec == nil {
- return nil, fmt.Errorf("Codec is required when initializing a RESTClient")
+ if config.NegotiatedSerializer == nil {
+ return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient")
}
baseURL, versionedAPIPath, err := defaultServerUrlFor(config)
@@ -152,16 +174,14 @@ func RESTClientFor(config *Config) (*RESTClient, error) {
httpClient = &http.Client{Transport: transport}
}
- client := NewRESTClient(baseURL, versionedAPIPath, config.ContentConfig, config.QPS, config.Burst, httpClient)
-
- return client, nil
+ return NewRESTClient(baseURL, versionedAPIPath, config.ContentConfig, config.QPS, config.Burst, config.RateLimiter, httpClient)
}
// UnversionedRESTClientFor is the same as RESTClientFor, except that it allows
// the config.Version to be empty.
func UnversionedRESTClientFor(config *Config) (*RESTClient, error) {
- if config.Codec == nil {
- return nil, fmt.Errorf("Codec is required when initializing a RESTClient")
+ if config.NegotiatedSerializer == nil {
+ return nil, fmt.Errorf("NeogitatedSerializer is required when initializing a RESTClient")
}
baseURL, versionedAPIPath, err := defaultServerUrlFor(config)
@@ -185,8 +205,7 @@ func UnversionedRESTClientFor(config *Config) (*RESTClient, error) {
versionConfig.GroupVersion = &v
}
- client := NewRESTClient(baseURL, versionedAPIPath, versionConfig, config.QPS, config.Burst, httpClient)
- return client, nil
+ return NewRESTClient(baseURL, versionedAPIPath, versionConfig, config.QPS, config.Burst, config.RateLimiter, httpClient)
}
// SetKubernetesDefaults sets default values on the provided client config for accessing the
@@ -235,7 +254,7 @@ func InClusterConfig() (*Config, error) {
}
tlsClientConfig := TLSClientConfig{}
rootCAFile := "/var/run/secrets/kubernetes.io/serviceaccount/" + api.ServiceAccountRootCAKey
- if _, err := util.CertPoolFromFile(rootCAFile); err != nil {
+ if _, err := crypto.CertPoolFromFile(rootCAFile); err != nil {
glog.Errorf("Expected to load root CA config from %s, but got err: %v", rootCAFile, err)
} else {
tlsClientConfig.CAFile = rootCAFile
diff --git a/vendor/k8s.io/kubernetes/pkg/client/restclient/plugin.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/plugin.go
new file mode 100644
index 0000000000000000000000000000000000000000..4752e375bc7103e5c41c57d0295b0c7d9b1bf4ab
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/plugin.go
@@ -0,0 +1,73 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 restclient
+
+import (
+ "fmt"
+ "net/http"
+ "sync"
+
+ "github.com/golang/glog"
+
+ clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+type AuthProvider interface {
+ // WrapTransport allows the plugin to create a modified RoundTripper that
+ // attaches authorization headers (or other info) to requests.
+ WrapTransport(http.RoundTripper) http.RoundTripper
+ // Login allows the plugin to initialize its configuration. It must not
+ // require direct user interaction.
+ Login() error
+}
+
+// Factory generates an AuthProvider plugin.
+// clusterAddress is the address of the current cluster.
+// config is the initial configuration for this plugin.
+// persister allows the plugin to save updated configuration.
+type Factory func(clusterAddress string, config map[string]string, persister AuthProviderConfigPersister) (AuthProvider, error)
+
+// AuthProviderConfigPersister allows a plugin to persist configuration info
+// for just itself.
+type AuthProviderConfigPersister interface {
+ Persist(map[string]string) error
+}
+
+// All registered auth provider plugins.
+var pluginsLock sync.Mutex
+var plugins = make(map[string]Factory)
+
+func RegisterAuthProviderPlugin(name string, plugin Factory) error {
+ pluginsLock.Lock()
+ defer pluginsLock.Unlock()
+ if _, found := plugins[name]; found {
+ return fmt.Errorf("Auth Provider Plugin %q was registered twice", name)
+ }
+ glog.V(4).Infof("Registered Auth Provider Plugin %q", name)
+ plugins[name] = plugin
+ return nil
+}
+
+func GetAuthProvider(clusterAddress string, apc *clientcmdapi.AuthProviderConfig, persister AuthProviderConfigPersister) (AuthProvider, error) {
+ pluginsLock.Lock()
+ defer pluginsLock.Unlock()
+ p, ok := plugins[apc.Name]
+ if !ok {
+ return nil, fmt.Errorf("No Auth Provider found for name %q", apc.Name)
+ }
+ return p(clusterAddress, apc.Config, persister)
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/request.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/request.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/request.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/request.go
index 0c9a10b7de09eadfd4d9a8bd9f5eac35b70e8b6e..9fd3f0ddb0917826918b0151a8695a504617a499 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/request.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/request.go
@@ -39,11 +39,12 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/runtime"
- "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/runtime/serializer/streaming"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
"k8s.io/kubernetes/pkg/util/net"
"k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/pkg/watch"
- watchjson "k8s.io/kubernetes/pkg/watch/json"
+ "k8s.io/kubernetes/pkg/watch/versioned"
)
var (
@@ -90,8 +91,9 @@ type Request struct {
client HTTPClient
verb string
- baseURL *url.URL
- content ContentConfig
+ baseURL *url.URL
+ content ContentConfig
+ serializers Serializers
// generic components accessible via method setters
pathPrefix string
@@ -117,11 +119,11 @@ type Request struct {
resp *http.Response
backoffMgr BackoffManager
- throttle util.RateLimiter
+ throttle flowcontrol.RateLimiter
}
// NewRequest creates a new request helper object for accessing runtime.Objects on a server.
-func NewRequest(client HTTPClient, verb string, baseURL *url.URL, versionedAPIPath string, content ContentConfig, backoff BackoffManager, throttle util.RateLimiter) *Request {
+func NewRequest(client HTTPClient, verb string, baseURL *url.URL, versionedAPIPath string, content ContentConfig, serializers Serializers, backoff BackoffManager, throttle flowcontrol.RateLimiter) *Request {
if backoff == nil {
glog.V(2).Infof("Not implementing request backoff strategy.")
backoff = &NoBackoff{}
@@ -132,13 +134,14 @@ func NewRequest(client HTTPClient, verb string, baseURL *url.URL, versionedAPIPa
pathPrefix = path.Join(pathPrefix, baseURL.Path)
}
r := &Request{
- client: client,
- verb: verb,
- baseURL: baseURL,
- pathPrefix: path.Join(pathPrefix, versionedAPIPath),
- content: content,
- backoffMgr: backoff,
- throttle: throttle,
+ client: client,
+ verb: verb,
+ baseURL: baseURL,
+ pathPrefix: path.Join(pathPrefix, versionedAPIPath),
+ content: content,
+ serializers: serializers,
+ backoffMgr: backoff,
+ throttle: throttle,
}
if len(content.ContentType) > 0 {
r.SetHeader("Accept", content.ContentType+", */*")
@@ -176,8 +179,8 @@ func (r *Request) Resource(resource string) *Request {
r.err = fmt.Errorf("resource already set to %q, cannot change to %q", r.resource, resource)
return r
}
- if ok, msg := validation.IsValidPathSegmentName(resource); !ok {
- r.err = fmt.Errorf("invalid resource %q: %s", resource, msg)
+ if msgs := validation.IsValidPathSegmentName(resource); len(msgs) != 0 {
+ r.err = fmt.Errorf("invalid resource %q: %v", resource, msgs)
return r
}
r.resource = resource
@@ -196,8 +199,8 @@ func (r *Request) SubResource(subresources ...string) *Request {
return r
}
for _, s := range subresources {
- if ok, msg := validation.IsValidPathSegmentName(s); !ok {
- r.err = fmt.Errorf("invalid subresource %q: %s", s, msg)
+ if msgs := validation.IsValidPathSegmentName(s); len(msgs) != 0 {
+ r.err = fmt.Errorf("invalid subresource %q: %v", s, msgs)
return r
}
}
@@ -218,8 +221,8 @@ func (r *Request) Name(resourceName string) *Request {
r.err = fmt.Errorf("resource name already set to %q, cannot change to %q", r.resourceName, resourceName)
return r
}
- if ok, msg := validation.IsValidPathSegmentName(resourceName); !ok {
- r.err = fmt.Errorf("invalid resource name %q: %s", resourceName, msg)
+ if msgs := validation.IsValidPathSegmentName(resourceName); len(msgs) != 0 {
+ r.err = fmt.Errorf("invalid resource name %q: %v", resourceName, msgs)
return r
}
r.resourceName = resourceName
@@ -235,8 +238,8 @@ func (r *Request) Namespace(namespace string) *Request {
r.err = fmt.Errorf("namespace already set to %q, cannot change to %q", r.namespace, namespace)
return r
}
- if ok, msg := validation.IsValidPathSegmentName(namespace); !ok {
- r.err = fmt.Errorf("invalid namespace %q: %s", namespace, msg)
+ if msgs := validation.IsValidPathSegmentName(namespace); len(msgs) != 0 {
+ r.err = fmt.Errorf("invalid namespace %q: %v", namespace, msgs)
return r
}
r.namespaceSet = true
@@ -536,10 +539,10 @@ func (r *Request) Body(obj interface{}) *Request {
return r
}
glog.V(8).Infof("Request Body: %s", string(data))
- r.body = bytes.NewBuffer(data)
+ r.body = bytes.NewReader(data)
case []byte:
glog.V(8).Infof("Request Body: %s", string(t))
- r.body = bytes.NewBuffer(t)
+ r.body = bytes.NewReader(t)
case io.Reader:
r.body = t
case runtime.Object:
@@ -547,13 +550,13 @@ func (r *Request) Body(obj interface{}) *Request {
if reflect.ValueOf(t).IsNil() {
return r
}
- data, err := runtime.Encode(r.content.Codec, t)
+ data, err := runtime.Encode(r.serializers.Encoder, t)
if err != nil {
r.err = err
return r
}
glog.V(8).Infof("Request Body: %s", string(data))
- r.body = bytes.NewBuffer(data)
+ r.body = bytes.NewReader(data)
r.SetHeader("Content-Type", r.content.ContentType)
default:
r.err = fmt.Errorf("unknown type used for body: %+v", obj)
@@ -624,7 +627,7 @@ func (r *Request) tryThrottle() {
r.throttle.Accept()
}
if latency := time.Since(now); latency > longThrottleLatency {
- glog.Warningf("Throttling request took %v, request: %s:%s", latency, r.verb, r.URL().String())
+ glog.V(4).Infof("Throttling request took %v, request: %s:%s", latency, r.verb, r.URL().String())
}
}
@@ -636,11 +639,16 @@ func (r *Request) Watch() (watch.Interface, error) {
if r.err != nil {
return nil, r.err
}
+ if r.serializers.Framer == nil {
+ return nil, fmt.Errorf("watching resources is not possible with this client (content-type: %s)", r.content.ContentType)
+ }
+
url := r.URL().String()
req, err := http.NewRequest(r.verb, url, r.body)
if err != nil {
return nil, err
}
+ req.Header = r.headers
client := r.client
if client == nil {
client = http.DefaultClient
@@ -670,7 +678,9 @@ func (r *Request) Watch() (watch.Interface, error) {
}
return nil, fmt.Errorf("for request '%+v', got status: %v", url, resp.StatusCode)
}
- return watch.NewStreamWatcher(watchjson.NewDecoder(resp.Body, r.content.Codec)), nil
+ framer := r.serializers.Framer.NewFrameReader(resp.Body)
+ decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
+ return watch.NewStreamWatcher(versioned.NewDecoder(decoder, r.serializers.Decoder)), nil
}
// updateURLMetrics is a convenience function for pushing metrics.
@@ -706,6 +716,7 @@ func (r *Request) Stream() (io.ReadCloser, error) {
if err != nil {
return nil, err
}
+ req.Header = r.headers
client := r.client
if client == nil {
client = http.DefaultClient
@@ -738,7 +749,8 @@ func (r *Request) Stream() (io.ReadCloser, error) {
return nil, fmt.Errorf("%v while accessing %v", resp.Status, url)
}
- if runtimeObject, err := runtime.Decode(r.content.Codec, bodyBytes); err == nil {
+ // TODO: Check ContentType.
+ if runtimeObject, err := runtime.Decode(r.serializers.Decoder, bodyBytes); err == nil {
statusError := errors.FromObject(runtimeObject)
if _, ok := statusError.(errors.APIStatus); ok {
@@ -811,6 +823,15 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
retries++
if seconds, wait := checkWait(resp); wait && retries < maxRetries {
+ if seeker, ok := r.body.(io.Seeker); ok && r.body != nil {
+ _, err := seeker.Seek(0, 0)
+ if err != nil {
+ glog.V(4).Infof("Could not retry request, can't Seek() back to beginning of body for %T", r.body)
+ fn(req, resp)
+ return true
+ }
+ }
+
glog.V(4).Infof("Got a Retry-After %s response for attempt %d to %v", seconds, retries, url)
r.backoffMgr.Sleep(time.Duration(seconds) * time.Second)
return false
@@ -876,7 +897,7 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
// default groupVersion, otherwise a status response won't be correctly
// decoded.
status := &unversioned.Status{}
- err := runtime.DecodeInto(r.content.Codec, body, status)
+ err := runtime.DecodeInto(r.serializers.Decoder, body, status)
if err == nil && len(status.Status) > 0 {
isStatusResponse = true
}
@@ -898,11 +919,30 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
return Result{err: errors.FromObject(status)}
}
+ contentType := resp.Header.Get("Content-Type")
+ var decoder runtime.Decoder
+ if contentType == r.content.ContentType {
+ decoder = r.serializers.Decoder
+ } else {
+ mediaType, params, err := mime.ParseMediaType(contentType)
+ if err != nil {
+ return Result{err: errors.NewInternalError(err)}
+ }
+ decoder, err = r.serializers.RenegotiatedDecoder(mediaType, params)
+ if err != nil {
+ return Result{
+ body: body,
+ contentType: contentType,
+ statusCode: resp.StatusCode,
+ }
+ }
+ }
+
return Result{
body: body,
- contentType: resp.Header.Get("Content-Type"),
+ contentType: contentType,
statusCode: resp.StatusCode,
- decoder: r.content.Codec,
+ decoder: decoder,
}
}
@@ -1008,6 +1048,9 @@ func (r Result) Get() (runtime.Object, error) {
if r.err != nil {
return nil, r.err
}
+ if r.decoder == nil {
+ return nil, fmt.Errorf("serializer for %s doesn't exist", r.contentType)
+ }
return runtime.Decode(r.decoder, r.body)
}
@@ -1023,6 +1066,9 @@ func (r Result) Into(obj runtime.Object) error {
if r.err != nil {
return r.err
}
+ if r.decoder == nil {
+ return fmt.Errorf("serializer for %s doesn't exist", r.contentType)
+ }
return runtime.DecodeInto(r.decoder, r.body, obj)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/transport.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/transport.go
similarity index 71%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/transport.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/transport.go
index 7d4b497c3073461ec032f4ec3a8000ac9486f690..0bfa2ea2720a7479df7623706cb32ae8629580f0 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/transport.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/transport.go
@@ -26,14 +26,22 @@ import (
// TLSConfigFor returns a tls.Config that will provide the transport level security defined
// by the provided Config. Will return nil if no transport level security is requested.
func TLSConfigFor(config *Config) (*tls.Config, error) {
- return transport.TLSConfigFor(config.transportConfig())
+ cfg, err := config.transportConfig()
+ if err != nil {
+ return nil, err
+ }
+ return transport.TLSConfigFor(cfg)
}
// TransportFor returns an http.RoundTripper that will provide the authentication
// or transport level security defined by the provided Config. Will return the
// default http.DefaultTransport if no special case behavior is needed.
func TransportFor(config *Config) (http.RoundTripper, error) {
- return transport.New(config.transportConfig())
+ cfg, err := config.transportConfig()
+ if err != nil {
+ return nil, err
+ }
+ return transport.New(cfg)
}
// HTTPWrappersForConfig wraps a round tripper with any relevant layered behavior from the
@@ -41,15 +49,34 @@ func TransportFor(config *Config) (http.RoundTripper, error) {
// the underlying connection (like WebSocket or HTTP2 clients). Pure HTTP clients should use
// the higher level TransportFor or RESTClientFor methods.
func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTripper, error) {
- return transport.HTTPWrappersForConfig(config.transportConfig(), rt)
+ cfg, err := config.transportConfig()
+ if err != nil {
+ return nil, err
+ }
+ return transport.HTTPWrappersForConfig(cfg, rt)
}
// transportConfig converts a client config to an appropriate transport config.
-func (c *Config) transportConfig() *transport.Config {
+func (c *Config) transportConfig() (*transport.Config, error) {
+ wt := c.WrapTransport
+ if c.AuthProvider != nil {
+ provider, err := GetAuthProvider(c.Host, c.AuthProvider, c.AuthConfigPersister)
+ if err != nil {
+ return nil, err
+ }
+ if wt != nil {
+ previousWT := wt
+ wt = func(rt http.RoundTripper) http.RoundTripper {
+ return provider.WrapTransport(previousWT(rt))
+ }
+ } else {
+ wt = provider.WrapTransport
+ }
+ }
return &transport.Config{
UserAgent: c.UserAgent,
Transport: c.Transport,
- WrapTransport: c.WrapTransport,
+ WrapTransport: wt,
TLS: transport.TLSConfig{
CAFile: c.CAFile,
CAData: c.CAData,
@@ -62,5 +89,6 @@ func (c *Config) transportConfig() *transport.Config {
Username: c.Username,
Password: c.Password,
BearerToken: c.BearerToken,
- }
+ Impersonate: c.Impersonate,
+ }, nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/url_utils.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/url_utils.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/url_utils.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/url_utils.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go
index 7baba5c1f7e55155a72963fd76c4a93ab9b1c472..6c672f08af6a7d30b53bb33eddb21ba1ab6e614f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/restclient/urlbackoff.go
@@ -21,7 +21,7 @@ import (
"time"
"github.com/golang/glog"
- "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/util/flowcontrol"
"k8s.io/kubernetes/pkg/util/sets"
)
@@ -42,7 +42,7 @@ type BackoffManager interface {
// we need for URL specific exponential backoff.
type URLBackoff struct {
// Uses backoff as underlying implementation.
- Backoff *util.Backoff
+ Backoff *flowcontrol.Backoff
}
// NoBackoff is a stub implementation, can be used for mocking or else as a default.
@@ -52,18 +52,20 @@ type NoBackoff struct {
func (n *NoBackoff) UpdateBackoff(actualUrl *url.URL, err error, responseCode int) {
// do nothing.
}
+
func (n *NoBackoff) CalculateBackoff(actualUrl *url.URL) time.Duration {
return 0 * time.Second
}
+
func (n *NoBackoff) Sleep(d time.Duration) {
- return
+ time.Sleep(d)
}
// Disable makes the backoff trivial, i.e., sets it to zero. This might be used
// by tests which want to run 1000s of mock requests without slowing down.
func (b *URLBackoff) Disable() {
glog.V(4).Infof("Disabling backoff strategy")
- b.Backoff = util.NewBackOff(0*time.Second, 0*time.Second)
+ b.Backoff = flowcontrol.NewBackOff(0*time.Second, 0*time.Second)
}
// baseUrlKey returns the key which urls will be mapped to.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/versions.go b/vendor/k8s.io/kubernetes/pkg/client/restclient/versions.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/restclient/versions.go
rename to vendor/k8s.io/kubernetes/pkg/client/restclient/versions.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/cache.go b/vendor/k8s.io/kubernetes/pkg/client/transport/cache.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/cache.go
rename to vendor/k8s.io/kubernetes/pkg/client/transport/cache.go
index f1068930d8ad8a85fe6bc2b4e291168d40dfb76a..8c07f5391a3e7df574ab55dac51646fce4d4b288 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/cache.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/transport/cache.go
@@ -22,6 +22,8 @@ import (
"net/http"
"sync"
"time"
+
+ utilnet "k8s.io/kubernetes/pkg/util/net"
)
// TlsTransportCache caches TLS http.RoundTrippers different configurations. The
@@ -32,6 +34,8 @@ type tlsTransportCache struct {
transports map[string]*http.Transport
}
+const idleConnsPerHost = 25
+
var tlsCache = &tlsTransportCache{transports: make(map[string]*http.Transport)}
func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
@@ -60,15 +64,16 @@ func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
}
// Cache a single transport for these options
- c.transports[key] = &http.Transport{
+ c.transports[key] = utilnet.SetTransportDefaults(&http.Transport{
Proxy: http.ProxyFromEnvironment,
TLSHandshakeTimeout: 10 * time.Second,
TLSClientConfig: tlsConfig,
+ MaxIdleConnsPerHost: idleConnsPerHost,
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
- }
+ })
return c.transports[key], nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/config.go b/vendor/k8s.io/kubernetes/pkg/client/transport/config.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/config.go
rename to vendor/k8s.io/kubernetes/pkg/client/transport/config.go
index 801977f877af7b2ac3e67354f7c3f79dc7866995..63a63fbb47955f9f601d0efa71d4f43f3c1e18ab 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/config.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/transport/config.go
@@ -34,6 +34,9 @@ type Config struct {
// Bearer token for authentication
BearerToken string
+ // Impersonate is the username that this Config will impersonate
+ Impersonate string
+
// Transport may be used for custom HTTP behavior. This attribute may
// not be specified with the TLS client certificate options. Use
// WrapTransport for most client level operations.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/round_trippers.go b/vendor/k8s.io/kubernetes/pkg/client/transport/round_trippers.go
similarity index 89%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/round_trippers.go
rename to vendor/k8s.io/kubernetes/pkg/client/transport/round_trippers.go
index 6136e080ead0b5cbaf07950d32e995fdff723655..55284ebc65f7515618305ed31254bcf2a9e515b3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/round_trippers.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/transport/round_trippers.go
@@ -48,6 +48,9 @@ func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTrip
if len(config.UserAgent) > 0 {
rt = NewUserAgentRoundTripper(config.UserAgent, rt)
}
+ if len(config.Impersonate) > 0 {
+ rt = NewImpersonatingRoundTripper(config.Impersonate, rt)
+ }
return rt, nil
}
@@ -130,6 +133,35 @@ func (rt *basicAuthRoundTripper) CancelRequest(req *http.Request) {
func (rt *basicAuthRoundTripper) WrappedRoundTripper() http.RoundTripper { return rt.rt }
+type impersonatingRoundTripper struct {
+ impersonate string
+ delegate http.RoundTripper
+}
+
+// NewImpersonatingRoundTripper will add an Act-As header to a request unless it has already been set.
+func NewImpersonatingRoundTripper(impersonate string, delegate http.RoundTripper) http.RoundTripper {
+ return &impersonatingRoundTripper{impersonate, delegate}
+}
+
+func (rt *impersonatingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+ if len(req.Header.Get("Impersonate-User")) != 0 {
+ return rt.delegate.RoundTrip(req)
+ }
+ req = cloneRequest(req)
+ req.Header.Set("Impersonate-User", rt.impersonate)
+ return rt.delegate.RoundTrip(req)
+}
+
+func (rt *impersonatingRoundTripper) CancelRequest(req *http.Request) {
+ if canceler, ok := rt.delegate.(requestCanceler); ok {
+ canceler.CancelRequest(req)
+ } else {
+ glog.Errorf("CancelRequest not implemented")
+ }
+}
+
+func (rt *impersonatingRoundTripper) WrappedRoundTripper() http.RoundTripper { return rt.delegate }
+
type bearerAuthRoundTripper struct {
bearer string
rt http.RoundTripper
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/transport.go b/vendor/k8s.io/kubernetes/pkg/client/transport/transport.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/transport.go
rename to vendor/k8s.io/kubernetes/pkg/client/transport/transport.go
index 94d9c0fbed086d8355fe9b7defa9bf406049c3a9..2d20e1b878a6366bfc5a82da17a94f50baf6f2ff 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/transport/transport.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/transport/transport.go
@@ -63,8 +63,10 @@ func TLSConfigFor(c *Config) (*tls.Config, error) {
}
tlsConfig := &tls.Config{
- // Change default from SSLv3 to TLSv1.0 (because of POODLE vulnerability)
- MinVersion: tls.VersionTLS10,
+ // Can't use SSLv3 because of POODLE and BEAST
+ // Can't use TLSv1.0 because of POODLE and BEAST using CBC cipher
+ // Can't use TLSv1.1 because of RC4 cipher usage
+ MinVersion: tls.VersionTLS12,
InsecureSkipVerify: c.TLS.Insecure,
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go b/vendor/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go
rename to vendor/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go
index 5c2e9f0c72439ddec074571d3270849b2532b3f0..283dd5a63e8bf7d5cbb8ac1bcd8a510d723e2ecb 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/typed/discovery/discovery_client.go
@@ -20,6 +20,7 @@ import (
"encoding/json"
"fmt"
"net/url"
+ "strings"
"github.com/emicklei/go-restful/swagger"
@@ -29,6 +30,8 @@ import (
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/client/restclient"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer"
+ utilerrors "k8s.io/kubernetes/pkg/util/errors"
"k8s.io/kubernetes/pkg/version"
)
@@ -54,6 +57,12 @@ type ServerResourcesInterface interface {
ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error)
// ServerResources returns the supported resources for all groups and versions.
ServerResources() (map[string]*unversioned.APIResourceList, error)
+ // ServerPreferredResources returns the supported resources with the version preferred by the
+ // server.
+ ServerPreferredResources() ([]unversioned.GroupVersionResource, error)
+ // ServerPreferredNamespacedResources returns the supported namespaced resources with the
+ // version preferred by the server.
+ ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error)
}
// ServerVersionInterface has a method for retrieving the server's version.
@@ -162,6 +171,50 @@ func (d *DiscoveryClient) ServerResources() (map[string]*unversioned.APIResource
return result, nil
}
+// serverPreferredResources returns the supported resources with the version preferred by the
+// server. If namespaced is true, only namespaced resources will be returned.
+func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversioned.GroupVersionResource, error) {
+ results := []unversioned.GroupVersionResource{}
+ serverGroupList, err := d.ServerGroups()
+ if err != nil {
+ return results, err
+ }
+
+ allErrs := []error{}
+ for _, apiGroup := range serverGroupList.Groups {
+ preferredVersion := apiGroup.PreferredVersion
+ apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
+ if err != nil {
+ allErrs = append(allErrs, err)
+ continue
+ }
+ groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
+ for _, apiResource := range apiResourceList.APIResources {
+ // ignore the root scoped resources if "namespaced" is true.
+ if namespaced && !apiResource.Namespaced {
+ continue
+ }
+ if strings.Contains(apiResource.Name, "/") {
+ continue
+ }
+ results = append(results, groupVersion.WithResource(apiResource.Name))
+ }
+ }
+ return results, utilerrors.NewAggregate(allErrs)
+}
+
+// ServerPreferredResources returns the supported resources with the version preferred by the
+// server.
+func (d *DiscoveryClient) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+ return d.serverPreferredResources(false)
+}
+
+// ServerPreferredNamespacedResources returns the supported namespaced resources with the
+// version preferred by the server.
+func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+ return d.serverPreferredResources(true)
+}
+
// ServerVersion retrieves and parses the server's version (git version).
func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
body, err := d.Get().AbsPath("/version").Do().Raw()
@@ -213,7 +266,11 @@ func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swag
func setDiscoveryDefaults(config *restclient.Config) error {
config.APIPath = ""
config.GroupVersion = nil
- config.Codec = runtime.NoopEncoder{api.Codecs.UniversalDecoder()}
+ codec := runtime.NoopEncoder{Decoder: api.Codecs.UniversalDecoder()}
+ config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(
+ runtime.SerializerInfo{Serializer: codec},
+ runtime.StreamSerializerInfo{},
+ )
if len(config.UserAgent) == 0 {
config.UserAgent = restclient.DefaultKubernetesUserAgent()
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset_adaption.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset/clientset_adaption.go
similarity index 64%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset_adaption.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset/clientset_adaption.go
index 2e1214ac1c5daa0e5ad3d03ebf60bc1fd99d1763..680cadc922c31c5b80c77db565d081d2b8971154 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/clientset_adaption.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset/clientset_adaption.go
@@ -17,17 +17,19 @@ limitations under the License.
package internalclientset
import (
+ "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+ unversionedbatch "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned"
+ unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
+ unversionedextensions "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"
"k8s.io/kubernetes/pkg/client/typed/discovery"
- unversionedcore "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
- unversionedextensions "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
"k8s.io/kubernetes/pkg/client/unversioned"
)
-// FromUnversionedClient adapts a pkg/client/unversioned#Client to a Clientset.
+// FromUnversionedClient adapts a unversioned.Client to a internalclientset.Clientset.
// This function is temporary. We will remove it when everyone has moved to using
// Clientset. New code should NOT use this function.
-func FromUnversionedClient(c *unversioned.Client) *Clientset {
- var clientset Clientset
+func FromUnversionedClient(c *unversioned.Client) *internalclientset.Clientset {
+ var clientset internalclientset.Clientset
if c != nil {
clientset.CoreClient = unversionedcore.New(c.RESTClient)
} else {
@@ -38,7 +40,11 @@ func FromUnversionedClient(c *unversioned.Client) *Clientset {
} else {
clientset.ExtensionsClient = unversionedextensions.New(nil)
}
-
+ if c != nil && c.BatchClient != nil {
+ clientset.BatchClient = unversionedbatch.New(c.BatchClient.RESTClient)
+ } else {
+ clientset.BatchClient = unversionedbatch.New(nil)
+ }
if c != nil && c.DiscoveryClient != nil {
clientset.DiscoveryClient = discovery.NewDiscoveryClient(c.DiscoveryClient.RESTClient)
} else {
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/apps.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/apps.go
new file mode 100644
index 0000000000000000000000000000000000000000..1905c29c2467f515379791c4171a0e5b4a69f9e9
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/apps.go
@@ -0,0 +1,83 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type AppsInterface interface {
+ PetSetNamespacer
+}
+
+// AppsClient is used to interact with Kubernetes batch features.
+type AppsClient struct {
+ *restclient.RESTClient
+}
+
+func (c *AppsClient) PetSets(namespace string) PetSetInterface {
+ return newPetSet(c, namespace)
+}
+
+func NewApps(c *restclient.Config) (*AppsClient, error) {
+ config := *c
+ if err := setAppsDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &AppsClient{client}, nil
+}
+
+func NewAppsOrDie(c *restclient.Config) *AppsClient {
+ client, err := NewApps(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+func setAppsDefaults(config *restclient.Config) error {
+ g, err := registered.Group(apps.GroupName)
+ if err != nil {
+ return err
+ }
+ config.APIPath = defaultAPIPath
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go
index c3ec19810301383ad75c334da6282bb0392ebf48..9e543c9d3aebab65ff3b5b7c9fee07234a984e6d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/autoscaling.go
@@ -33,7 +33,7 @@ type AutoscalingClient struct {
}
func (c *AutoscalingClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
- return newHorizontalPodAutoscalersV1(c, namespace)
+ return newHorizontalPodAutoscalers(c, namespace)
}
func NewAutoscaling(c *restclient.Config) (*AutoscalingClient, error) {
@@ -73,6 +73,7 @@ func setAutoscalingDefaults(config *restclient.Config) error {
//}
config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
if config.QPS == 0 {
config.QPS = 5
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/batch.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/batch.go
similarity index 66%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/batch.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/batch.go
index a432e4c789c73c0b928f059dcbe2a7d9bbe5379c..40fc49dc121f0f145b2028f948b3ba759298b361 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/batch.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/batch.go
@@ -18,13 +18,16 @@ package unversioned
import (
"k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/apis/batch"
+ "k8s.io/kubernetes/pkg/apis/batch/v2alpha1"
"k8s.io/kubernetes/pkg/client/restclient"
)
type BatchInterface interface {
JobsNamespacer
+ ScheduledJobsNamespacer
}
// BatchClient is used to interact with Kubernetes batch features.
@@ -36,9 +39,25 @@ func (c *BatchClient) Jobs(namespace string) JobInterface {
return newJobsV1(c, namespace)
}
+func (c *BatchClient) ScheduledJobs(namespace string) ScheduledJobInterface {
+ return newScheduledJobs(c, namespace)
+}
+
func NewBatch(c *restclient.Config) (*BatchClient, error) {
config := *c
- if err := setBatchDefaults(&config); err != nil {
+ if err := setBatchDefaults(&config, nil); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &BatchClient{client}, nil
+}
+
+func NewBatchV2Alpha1(c *restclient.Config) (*BatchClient, error) {
+ config := *c
+ if err := setBatchDefaults(&config, &v2alpha1.SchemeGroupVersion); err != nil {
return nil, err
}
client, err := restclient.RESTClientFor(&config)
@@ -49,14 +68,22 @@ func NewBatch(c *restclient.Config) (*BatchClient, error) {
}
func NewBatchOrDie(c *restclient.Config) *BatchClient {
- client, err := NewBatch(c)
+ var (
+ client *BatchClient
+ err error
+ )
+ if c.ContentConfig.GroupVersion != nil && *c.ContentConfig.GroupVersion == v2alpha1.SchemeGroupVersion {
+ client, err = NewBatchV2Alpha1(c)
+ } else {
+ client, err = NewBatch(c)
+ }
if err != nil {
panic(err)
}
return client
}
-func setBatchDefaults(config *restclient.Config) error {
+func setBatchDefaults(config *restclient.Config, gv *unversioned.GroupVersion) error {
// if batch group is not registered, return an error
g, err := registered.Group(batch.GroupName)
if err != nil {
@@ -69,10 +96,14 @@ func setBatchDefaults(config *restclient.Config) error {
// TODO: Unconditionally set the config.Version, until we fix the config.
//if config.Version == "" {
copyGroupVersion := g.GroupVersion
+ if gv != nil {
+ copyGroupVersion = *gv
+ }
config.GroupVersion = ©GroupVersion
//}
config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
if config.QPS == 0 {
config.QPS = 5
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/client.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/client.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/client.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/client.go
index b897bc230c7ae5c772f205d58c734c749b0c9cde..df68040042f413cc7ef404cae7184b1356c8b1e5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/client.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/client.go
@@ -47,6 +47,7 @@ type Interface interface {
Autoscaling() AutoscalingInterface
Batch() BatchInterface
Extensions() ExtensionsInterface
+ Rbac() RbacInterface
Discovery() discovery.DiscoveryInterface
}
@@ -119,6 +120,9 @@ type Client struct {
*AutoscalingClient
*BatchClient
*ExtensionsClient
+ *AppsClient
+ *PolicyClient
+ *RbacClient
*discovery.DiscoveryClient
}
@@ -156,6 +160,14 @@ func (c *Client) Extensions() ExtensionsInterface {
return c.ExtensionsClient
}
+func (c *Client) Apps() AppsInterface {
+ return c.AppsClient
+}
+
+func (c *Client) Rbac() RbacInterface {
+ return c.RbacClient
+}
+
func (c *Client) Discovery() discovery.DiscoveryInterface {
return c.DiscoveryClient
}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/helpers.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/helpers.go
new file mode 100644
index 0000000000000000000000000000000000000000..87330c5009f10cd03e5ad13b0100e88956e8c7e6
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/helpers.go
@@ -0,0 +1,183 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 api
+
+import (
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "path/filepath"
+)
+
+func init() {
+ sDec, _ := base64.StdEncoding.DecodeString("REDACTED+")
+ redactedBytes = []byte(string(sDec))
+}
+
+// IsConfigEmpty returns true if the config is empty.
+func IsConfigEmpty(config *Config) bool {
+ return len(config.AuthInfos) == 0 && len(config.Clusters) == 0 && len(config.Contexts) == 0 &&
+ len(config.CurrentContext) == 0 &&
+ len(config.Preferences.Extensions) == 0 && !config.Preferences.Colors &&
+ len(config.Extensions) == 0
+}
+
+// MinifyConfig read the current context and uses that to keep only the relevant pieces of config
+// This is useful for making secrets based on kubeconfig files
+func MinifyConfig(config *Config) error {
+ if len(config.CurrentContext) == 0 {
+ return errors.New("current-context must exist in order to minify")
+ }
+
+ currContext, exists := config.Contexts[config.CurrentContext]
+ if !exists {
+ return fmt.Errorf("cannot locate context %v", config.CurrentContext)
+ }
+
+ newContexts := map[string]*Context{}
+ newContexts[config.CurrentContext] = currContext
+
+ newClusters := map[string]*Cluster{}
+ if len(currContext.Cluster) > 0 {
+ if _, exists := config.Clusters[currContext.Cluster]; !exists {
+ return fmt.Errorf("cannot locate cluster %v", currContext.Cluster)
+ }
+
+ newClusters[currContext.Cluster] = config.Clusters[currContext.Cluster]
+ }
+
+ newAuthInfos := map[string]*AuthInfo{}
+ if len(currContext.AuthInfo) > 0 {
+ if _, exists := config.AuthInfos[currContext.AuthInfo]; !exists {
+ return fmt.Errorf("cannot locate user %v", currContext.AuthInfo)
+ }
+
+ newAuthInfos[currContext.AuthInfo] = config.AuthInfos[currContext.AuthInfo]
+ }
+
+ config.AuthInfos = newAuthInfos
+ config.Clusters = newClusters
+ config.Contexts = newContexts
+
+ return nil
+}
+
+var redactedBytes []byte
+
+// Flatten redacts raw data entries from the config object for a human-readable view.
+func ShortenConfig(config *Config) {
+ // trick json encoder into printing a human readable string in the raw data
+ // by base64 decoding what we want to print. Relies on implementation of
+ // http://golang.org/pkg/encoding/json/#Marshal using base64 to encode []byte
+ for key, authInfo := range config.AuthInfos {
+ if len(authInfo.ClientKeyData) > 0 {
+ authInfo.ClientKeyData = redactedBytes
+ }
+ if len(authInfo.ClientCertificateData) > 0 {
+ authInfo.ClientCertificateData = redactedBytes
+ }
+ config.AuthInfos[key] = authInfo
+ }
+ for key, cluster := range config.Clusters {
+ if len(cluster.CertificateAuthorityData) > 0 {
+ cluster.CertificateAuthorityData = redactedBytes
+ }
+ config.Clusters[key] = cluster
+ }
+}
+
+// Flatten changes the config object into a self contained config (useful for making secrets)
+func FlattenConfig(config *Config) error {
+ for key, authInfo := range config.AuthInfos {
+ baseDir, err := MakeAbs(path.Dir(authInfo.LocationOfOrigin), "")
+ if err != nil {
+ return err
+ }
+
+ if err := FlattenContent(&authInfo.ClientCertificate, &authInfo.ClientCertificateData, baseDir); err != nil {
+ return err
+ }
+ if err := FlattenContent(&authInfo.ClientKey, &authInfo.ClientKeyData, baseDir); err != nil {
+ return err
+ }
+
+ config.AuthInfos[key] = authInfo
+ }
+ for key, cluster := range config.Clusters {
+ baseDir, err := MakeAbs(path.Dir(cluster.LocationOfOrigin), "")
+ if err != nil {
+ return err
+ }
+
+ if err := FlattenContent(&cluster.CertificateAuthority, &cluster.CertificateAuthorityData, baseDir); err != nil {
+ return err
+ }
+
+ config.Clusters[key] = cluster
+ }
+
+ return nil
+}
+
+func FlattenContent(path *string, contents *[]byte, baseDir string) error {
+ if len(*path) != 0 {
+ if len(*contents) > 0 {
+ return errors.New("cannot have values for both path and contents")
+ }
+
+ var err error
+ absPath := ResolvePath(*path, baseDir)
+ *contents, err = ioutil.ReadFile(absPath)
+ if err != nil {
+ return err
+ }
+
+ *path = ""
+ }
+
+ return nil
+}
+
+// ResolvePath returns the path as an absolute paths, relative to the given base directory
+func ResolvePath(path string, base string) string {
+ // Don't resolve empty paths
+ if len(path) > 0 {
+ // Don't resolve absolute paths
+ if !filepath.IsAbs(path) {
+ return filepath.Join(base, path)
+ }
+ }
+
+ return path
+}
+
+func MakeAbs(path, base string) (string, error) {
+ if filepath.IsAbs(path) {
+ return path, nil
+ }
+ if len(base) == 0 {
+ cwd, err := os.Getwd()
+ if err != nil {
+ return "", err
+ }
+ base = cwd
+ }
+ return filepath.Join(base, path), nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/register.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..f26a6cd1b11ba904e99f42b5a1c1001502a440f0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/register.go
@@ -0,0 +1,43 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 api
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
+var Scheme = runtime.NewScheme()
+
+// SchemeGroupVersion is group version used to register these objects
+// TODO this should be in the "kubeconfig" group
+var SchemeGroupVersion = unversioned.GroupVersion{Group: "", Version: runtime.APIVersionInternal}
+
+func init() {
+ Scheme.AddKnownTypes(SchemeGroupVersion,
+ &Config{},
+ )
+}
+
+func (obj *Config) GetObjectKind() unversioned.ObjectKind { return obj }
+func (obj *Config) SetGroupVersionKind(gvk unversioned.GroupVersionKind) {
+ obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
+}
+func (obj *Config) GroupVersionKind() unversioned.GroupVersionKind {
+ return unversioned.FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/types.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..56b44e8f42abc05d518e4d9b6c95c429371937bc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api/types.go
@@ -0,0 +1,152 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 api
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Where possible, json tags match the cli argument names.
+// Top level config objects and all values required for proper functioning are not "omitempty". Any truly optional piece of config is allowed to be omitted.
+
+// Config holds the information needed to build connect to remote kubernetes clusters as a given user
+// IMPORTANT if you add fields to this struct, please update IsConfigEmpty()
+type Config struct {
+ // Legacy field from pkg/api/types.go TypeMeta.
+ // TODO(jlowdermilk): remove this after eliminating downstream dependencies.
+ Kind string `json:"kind,omitempty"`
+ // DEPRECATED: APIVersion is the preferred api version for communicating with the kubernetes cluster (v1, v2, etc).
+ // Because a cluster can run multiple API groups and potentially multiple versions of each, it no longer makes sense to specify
+ // a single value for the cluster version.
+ // This field isn't really needed anyway, so we are deprecating it without replacement.
+ // It will be ignored if it is present.
+ APIVersion string `json:"apiVersion,omitempty"`
+ // Preferences holds general information to be use for cli interactions
+ Preferences Preferences `json:"preferences"`
+ // Clusters is a map of referencable names to cluster configs
+ Clusters map[string]*Cluster `json:"clusters"`
+ // AuthInfos is a map of referencable names to user configs
+ AuthInfos map[string]*AuthInfo `json:"users"`
+ // Contexts is a map of referencable names to context configs
+ Contexts map[string]*Context `json:"contexts"`
+ // CurrentContext is the name of the context that you would like to use by default
+ CurrentContext string `json:"current-context"`
+ // Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
+ Extensions map[string]runtime.Object `json:"extensions,omitempty"`
+}
+
+// IMPORTANT if you add fields to this struct, please update IsConfigEmpty()
+type Preferences struct {
+ Colors bool `json:"colors,omitempty"`
+ // Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
+ Extensions map[string]runtime.Object `json:"extensions,omitempty"`
+}
+
+// Cluster contains information about how to communicate with a kubernetes cluster
+type Cluster struct {
+ // LocationOfOrigin indicates where this object came from. It is used for round tripping config post-merge, but never serialized.
+ LocationOfOrigin string
+ // Server is the address of the kubernetes cluster (https://hostname:port).
+ Server string `json:"server"`
+ // APIVersion is the preferred api version for communicating with the kubernetes cluster (v1, v2, etc).
+ APIVersion string `json:"api-version,omitempty"`
+ // InsecureSkipTLSVerify skips the validity check for the server's certificate. This will make your HTTPS connections insecure.
+ InsecureSkipTLSVerify bool `json:"insecure-skip-tls-verify,omitempty"`
+ // CertificateAuthority is the path to a cert file for the certificate authority.
+ CertificateAuthority string `json:"certificate-authority,omitempty"`
+ // CertificateAuthorityData contains PEM-encoded certificate authority certificates. Overrides CertificateAuthority
+ CertificateAuthorityData []byte `json:"certificate-authority-data,omitempty"`
+ // Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
+ Extensions map[string]runtime.Object `json:"extensions,omitempty"`
+}
+
+// AuthInfo contains information that describes identity information. This is use to tell the kubernetes cluster who you are.
+type AuthInfo struct {
+ // LocationOfOrigin indicates where this object came from. It is used for round tripping config post-merge, but never serialized.
+ LocationOfOrigin string
+ // ClientCertificate is the path to a client cert file for TLS.
+ ClientCertificate string `json:"client-certificate,omitempty"`
+ // ClientCertificateData contains PEM-encoded data from a client cert file for TLS. Overrides ClientCertificate
+ ClientCertificateData []byte `json:"client-certificate-data,omitempty"`
+ // ClientKey is the path to a client key file for TLS.
+ ClientKey string `json:"client-key,omitempty"`
+ // ClientKeyData contains PEM-encoded data from a client key file for TLS. Overrides ClientKey
+ ClientKeyData []byte `json:"client-key-data,omitempty"`
+ // Token is the bearer token for authentication to the kubernetes cluster.
+ Token string `json:"token,omitempty"`
+ // Impersonate is the username to act-as.
+ Impersonate string `json:"act-as,omitempty"`
+ // Username is the username for basic authentication to the kubernetes cluster.
+ Username string `json:"username,omitempty"`
+ // Password is the password for basic authentication to the kubernetes cluster.
+ Password string `json:"password,omitempty"`
+ // AuthProvider specifies a custom authentication plugin for the kubernetes cluster.
+ AuthProvider *AuthProviderConfig `json:"auth-provider,omitempty"`
+ // Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
+ Extensions map[string]runtime.Object `json:"extensions,omitempty"`
+}
+
+// Context is a tuple of references to a cluster (how do I communicate with a kubernetes cluster), a user (how do I identify myself), and a namespace (what subset of resources do I want to work with)
+type Context struct {
+ // LocationOfOrigin indicates where this object came from. It is used for round tripping config post-merge, but never serialized.
+ LocationOfOrigin string
+ // Cluster is the name of the cluster for this context
+ Cluster string `json:"cluster"`
+ // AuthInfo is the name of the authInfo for this context
+ AuthInfo string `json:"user"`
+ // Namespace is the default namespace to use on unspecified requests
+ Namespace string `json:"namespace,omitempty"`
+ // Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
+ Extensions map[string]runtime.Object `json:"extensions,omitempty"`
+}
+
+// AuthProviderConfig holds the configuration for a specified auth provider.
+type AuthProviderConfig struct {
+ Name string `json:"name"`
+ Config map[string]string `json:"config,omitempty"`
+}
+
+// NewConfig is a convenience function that returns a new Config object with non-nil maps
+func NewConfig() *Config {
+ return &Config{
+ Preferences: *NewPreferences(),
+ Clusters: make(map[string]*Cluster),
+ AuthInfos: make(map[string]*AuthInfo),
+ Contexts: make(map[string]*Context),
+ Extensions: make(map[string]runtime.Object),
+ }
+}
+
+// NewConfig is a convenience function that returns a new Config object with non-nil maps
+func NewContext() *Context {
+ return &Context{Extensions: make(map[string]runtime.Object)}
+}
+
+// NewConfig is a convenience function that returns a new Config object with non-nil maps
+func NewCluster() *Cluster {
+ return &Cluster{Extensions: make(map[string]runtime.Object)}
+}
+
+// NewConfig is a convenience function that returns a new Config object with non-nil maps
+func NewAuthInfo() *AuthInfo {
+ return &AuthInfo{Extensions: make(map[string]runtime.Object)}
+}
+
+// NewConfig is a convenience function that returns a new Config object with non-nil maps
+func NewPreferences() *Preferences {
+ return &Preferences{Extensions: make(map[string]runtime.Object)}
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterrolebindings.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterrolebindings.go
new file mode 100644
index 0000000000000000000000000000000000000000..2a9d79846f35f70ed4590012a96361cbdcb41154
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterrolebindings.go
@@ -0,0 +1,92 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// ClusterRoleBindings has methods to work with ClusterRoleBinding resources in a namespace
+type ClusterRoleBindings interface {
+ ClusterRoleBindings() ClusterRoleBindingInterface
+}
+
+// ClusterRoleBindingInterface has methods to work with ClusterRoleBinding resources.
+type ClusterRoleBindingInterface interface {
+ List(opts api.ListOptions) (*rbac.ClusterRoleBindingList, error)
+ Get(name string) (*rbac.ClusterRoleBinding, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Create(clusterRoleBinding *rbac.ClusterRoleBinding) (*rbac.ClusterRoleBinding, error)
+ Update(clusterRoleBinding *rbac.ClusterRoleBinding) (*rbac.ClusterRoleBinding, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// clusterRoleBindings implements ClusterRoleBindingsNamespacer interface
+type clusterRoleBindings struct {
+ client *RbacClient
+}
+
+// newClusterRoleBindings returns a clusterRoleBindings
+func newClusterRoleBindings(c *RbacClient) *clusterRoleBindings {
+ return &clusterRoleBindings{
+ client: c,
+ }
+}
+
+// List takes label and field selectors, and returns the list of clusterRoleBindings that match those selectors.
+func (c *clusterRoleBindings) List(opts api.ListOptions) (result *rbac.ClusterRoleBindingList, err error) {
+ result = &rbac.ClusterRoleBindingList{}
+ err = c.client.Get().Resource("clusterrolebindings").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get takes the name of the clusterRoleBinding, and returns the corresponding ClusterRoleBinding object, and an error if it occurs
+func (c *clusterRoleBindings) Get(name string) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Get().Resource("clusterrolebindings").Name(name).Do().Into(result)
+ return
+}
+
+// Delete takes the name of the clusterRoleBinding and deletes it. Returns an error if one occurs.
+func (c *clusterRoleBindings) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().Resource("clusterrolebindings").Name(name).Body(options).Do().Error()
+}
+
+// Create takes the representation of a clusterRoleBinding and creates it. Returns the server's representation of the clusterRoleBinding, and an error, if it occurs.
+func (c *clusterRoleBindings) Create(clusterRoleBinding *rbac.ClusterRoleBinding) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Post().Resource("clusterrolebindings").Body(clusterRoleBinding).Do().Into(result)
+ return
+}
+
+// Update takes the representation of a clusterRoleBinding and updates it. Returns the server's representation of the clusterRoleBinding, and an error, if it occurs.
+func (c *clusterRoleBindings) Update(clusterRoleBinding *rbac.ClusterRoleBinding) (result *rbac.ClusterRoleBinding, err error) {
+ result = &rbac.ClusterRoleBinding{}
+ err = c.client.Put().Resource("clusterrolebindings").Name(clusterRoleBinding.Name).Body(clusterRoleBinding).Do().Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested clusterRoleBindings.
+func (c *clusterRoleBindings) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("clusterrolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterroles.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterroles.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d2d375d619a9efe2ac586fa30f22e7b518d9a70
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/clusterroles.go
@@ -0,0 +1,92 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// ClusterRoles has methods to work with ClusterRole resources in a namespace
+type ClusterRoles interface {
+ ClusterRoles() ClusterRoleInterface
+}
+
+// ClusterRoleInterface has methods to work with ClusterRole resources.
+type ClusterRoleInterface interface {
+ List(opts api.ListOptions) (*rbac.ClusterRoleList, error)
+ Get(name string) (*rbac.ClusterRole, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Create(clusterRole *rbac.ClusterRole) (*rbac.ClusterRole, error)
+ Update(clusterRole *rbac.ClusterRole) (*rbac.ClusterRole, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// clusterRoles implements ClusterRolesNamespacer interface
+type clusterRoles struct {
+ client *RbacClient
+}
+
+// newClusterRoles returns a clusterRoles
+func newClusterRoles(c *RbacClient) *clusterRoles {
+ return &clusterRoles{
+ client: c,
+ }
+}
+
+// List takes label and field selectors, and returns the list of clusterRoles that match those selectors.
+func (c *clusterRoles) List(opts api.ListOptions) (result *rbac.ClusterRoleList, err error) {
+ result = &rbac.ClusterRoleList{}
+ err = c.client.Get().Resource("clusterroles").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get takes the name of the clusterRole, and returns the corresponding ClusterRole object, and an error if it occurs
+func (c *clusterRoles) Get(name string) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Get().Resource("clusterroles").Name(name).Do().Into(result)
+ return
+}
+
+// Delete takes the name of the clusterRole and deletes it. Returns an error if one occurs.
+func (c *clusterRoles) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().Resource("clusterroles").Name(name).Body(options).Do().Error()
+}
+
+// Create takes the representation of a clusterRole and creates it. Returns the server's representation of the clusterRole, and an error, if it occurs.
+func (c *clusterRoles) Create(clusterRole *rbac.ClusterRole) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Post().Resource("clusterroles").Body(clusterRole).Do().Into(result)
+ return
+}
+
+// Update takes the representation of a clusterRole and updates it. Returns the server's representation of the clusterRole, and an error, if it occurs.
+func (c *clusterRoles) Update(clusterRole *rbac.ClusterRole) (result *rbac.ClusterRole, err error) {
+ result = &rbac.ClusterRole{}
+ err = c.client.Put().Resource("clusterroles").Name(clusterRole.Name).Body(clusterRole).Do().Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested clusterRoles.
+func (c *clusterRoles) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Resource("clusterroles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/componentstatuses.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/componentstatuses.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/componentstatuses.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/componentstatuses.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/conditions.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/conditions.go
similarity index 55%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/conditions.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/conditions.go
index 5087baa806768de1cc9f24a44f3eab9a73c99dde..f68f98fe121ea2b4ebc56c8e74648c51565e492d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/conditions.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/conditions.go
@@ -17,69 +17,17 @@ limitations under the License.
package unversioned
import (
- "time"
+ "fmt"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/util/wait"
+ "k8s.io/kubernetes/pkg/watch"
)
-// DefaultRetry is the recommended retry for a conflict where multiple clients
-// are making changes to the same resource.
-var DefaultRetry = wait.Backoff{
- Steps: 5,
- Duration: 10 * time.Millisecond,
- Factor: 1.0,
- Jitter: 0.1,
-}
-
-// DefaultBackoff is the recommended backoff for a conflict where a client
-// may be attempting to make an unrelated modification to a resource under
-// active management by one or more controllers.
-var DefaultBackoff = wait.Backoff{
- Steps: 4,
- Duration: 10 * time.Millisecond,
- Factor: 5.0,
- Jitter: 0.1,
-}
-
-// RetryConflict executes the provided function repeatedly, retrying if the server returns a conflicting
-// write. Callers should preserve previous executions if they wish to retry changes. It performs an
-// exponential backoff.
-//
-// var pod *api.Pod
-// err := RetryOnConflict(DefaultBackoff, func() (err error) {
-// pod, err = c.Pods("mynamespace").UpdateStatus(podStatus)
-// return
-// })
-// if err != nil {
-// // may be conflict if max retries were hit
-// return err
-// }
-// ...
-//
-// TODO: Make Backoff an interface?
-func RetryOnConflict(backoff wait.Backoff, fn func() error) error {
- var lastConflictErr error
- err := wait.ExponentialBackoff(backoff, func() (bool, error) {
- err := fn()
- switch {
- case err == nil:
- return true, nil
- case errors.IsConflict(err):
- lastConflictErr = err
- return false, nil
- default:
- return false, err
- }
- })
- if err == wait.ErrWaitTimeout {
- err = lastConflictErr
- }
- return err
-}
-
// ControllerHasDesiredReplicas returns a condition that will be true if and only if
// the desired replica count for a controller's ReplicaSelector equals the Replicas count.
func ControllerHasDesiredReplicas(c Interface, controller *api.ReplicationController) wait.ConditionFunc {
@@ -126,7 +74,7 @@ func ReplicaSetHasDesiredReplicas(c ExtensionsInterface, replicaSet *extensions.
// JobHasDesiredParallelism returns a condition that will be true if the desired parallelism count
// for a job equals the current active counts or is less by an appropriate successful/unsuccessful count.
-func JobHasDesiredParallelism(c ExtensionsInterface, job *extensions.Job) wait.ConditionFunc {
+func JobHasDesiredParallelism(c BatchInterface, job *batch.Job) wait.ConditionFunc {
return func() (bool, error) {
job, err := c.Jobs(job.Namespace).Get(job.Name)
@@ -168,3 +116,125 @@ func DeploymentHasDesiredReplicas(c ExtensionsInterface, deployment *extensions.
deployment.Status.UpdatedReplicas == deployment.Spec.Replicas, nil
}
}
+
+// ErrPodCompleted is returned by PodRunning or PodContainerRunning to indicate that
+// the pod has already reached completed state.
+var ErrPodCompleted = fmt.Errorf("pod ran to completion")
+
+// PodRunning returns true if the pod is running, false if the pod has not yet reached running state,
+// returns ErrPodCompleted if the pod has run to completion, or an error in any other case.
+func PodRunning(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "pods"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.Pod:
+ switch t.Status.Phase {
+ case api.PodRunning:
+ return true, nil
+ case api.PodFailed, api.PodSucceeded:
+ return false, ErrPodCompleted
+ }
+ }
+ return false, nil
+}
+
+// PodCompleted returns true if the pod has run to completion, false if the pod has not yet
+// reached running state, or an error in any other case.
+func PodCompleted(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "pods"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.Pod:
+ switch t.Status.Phase {
+ case api.PodFailed, api.PodSucceeded:
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+// PodRunningAndReady returns true if the pod is running and ready, false if the pod has not
+// yet reached those states, returns ErrPodCompleted if the pod has run to completion, or
+// an error in any other case.
+func PodRunningAndReady(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "pods"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.Pod:
+ switch t.Status.Phase {
+ case api.PodFailed, api.PodSucceeded:
+ return false, ErrPodCompleted
+ case api.PodRunning:
+ return api.IsPodReady(t), nil
+ }
+ }
+ return false, nil
+}
+
+// PodNotPending returns true if the pod has left the pending state, false if it has not,
+// or an error in any other case (such as if the pod was deleted).
+func PodNotPending(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "pods"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.Pod:
+ switch t.Status.Phase {
+ case api.PodPending:
+ return false, nil
+ default:
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+// PodContainerRunning returns false until the named container has ContainerStatus running (at least once),
+// and will return an error if the pod is deleted, runs to completion, or the container pod is not available.
+func PodContainerRunning(containerName string) watch.ConditionFunc {
+ return func(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "pods"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.Pod:
+ switch t.Status.Phase {
+ case api.PodRunning, api.PodPending:
+ case api.PodFailed, api.PodSucceeded:
+ return false, ErrPodCompleted
+ default:
+ return false, nil
+ }
+ for _, s := range t.Status.ContainerStatuses {
+ if s.Name != containerName {
+ continue
+ }
+ return s.State.Running != nil, nil
+ }
+ return false, nil
+ }
+ return false, nil
+ }
+}
+
+// ServiceAccountHasSecrets returns true if the service account has at least one secret,
+// false if it does not, or an error.
+func ServiceAccountHasSecrets(event watch.Event) (bool, error) {
+ switch event.Type {
+ case watch.Deleted:
+ return false, errors.NewNotFound(unversioned.GroupResource{Resource: "serviceaccounts"}, "")
+ }
+ switch t := event.Object.(type) {
+ case *api.ServiceAccount:
+ return len(t.Secrets) > 0, nil
+ }
+ return false, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/configmap.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/configmap.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/configmap.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/configmap.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/containerinfo.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/containerinfo.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/containerinfo.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/containerinfo.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/daemon_sets.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/daemon_sets.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/daemon_sets.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/daemon_sets.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/deployment.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/deployment.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/deployment.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/deployment.go
index 1706418b32e0551f8312109192b78781737a3ff1..cafd4cfd1d39376c13ecfde66f5696851bec5f74 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/deployment.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/deployment.go
@@ -45,6 +45,9 @@ type deployments struct {
ns string
}
+// Ensure statically that deployments implements DeploymentInterface.
+var _ DeploymentInterface = &deployments{}
+
// newDeployments returns a Deployments
func newDeployments(c *ExtensionsClient, namespace string) *deployments {
return &deployments{
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/doc.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/doc.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/doc.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/doc.go
index f9c7f16e712a4bb58f4542abe799437e2d41ef64..252d8097581690dc99824d433c3f74d16b92baa9 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/doc.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/doc.go
@@ -24,8 +24,6 @@ Most consumers should use the Config object to create a Client:
import (
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/fields"
- "k8s.io/kubernetes/pkg/labels"
)
[...]
@@ -39,7 +37,7 @@ Most consumers should use the Config object to create a Client:
if err != nil {
// handle error
}
- pods, err := client.Pods(api.NamespaceDefault).List(labels.Everything(), fields.Everything())
+ pods, err := client.Pods(api.NamespaceDefault).List(api.ListOptions{})
if err != nil {
// handle error
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/endpoints.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/endpoints.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/endpoints.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/endpoints.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/events.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/events.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/events.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/events.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/extensions.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/extensions.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/extensions.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/extensions.go
index 5db86dbb8384f16c5cfdb5261bfe5f0a95655dcc..3c9114d9a88c2090ad2cdb9f11c6d36a6e4bedec 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/extensions.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/extensions.go
@@ -28,12 +28,12 @@ import (
// Features of Extensions group are not supported and may be changed or removed in
// incompatible ways at any time.
type ExtensionsInterface interface {
- HorizontalPodAutoscalersNamespacer
ScaleNamespacer
DaemonSetsNamespacer
DeploymentsNamespacer
JobsNamespacer
IngressNamespacer
+ NetworkPolicyNamespacer
ThirdPartyResourceNamespacer
ReplicaSetsNamespacer
PodSecurityPoliciesInterface
@@ -50,10 +50,6 @@ func (c *ExtensionsClient) PodSecurityPolicies() PodSecurityPolicyInterface {
return newPodSecurityPolicy(c)
}
-func (c *ExtensionsClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
- return newHorizontalPodAutoscalers(c, namespace)
-}
-
func (c *ExtensionsClient) Scales(namespace string) ScaleInterface {
return newScales(c, namespace)
}
@@ -74,8 +70,12 @@ func (c *ExtensionsClient) Ingress(namespace string) IngressInterface {
return newIngress(c, namespace)
}
-func (c *ExtensionsClient) ThirdPartyResources(namespace string) ThirdPartyResourceInterface {
- return newThirdPartyResources(c, namespace)
+func (c *ExtensionsClient) NetworkPolicies(namespace string) NetworkPolicyInterface {
+ return newNetworkPolicies(c, namespace)
+}
+
+func (c *ExtensionsClient) ThirdPartyResources() ThirdPartyResourceInterface {
+ return newThirdPartyResources(c)
}
func (c *ExtensionsClient) ReplicaSets(namespace string) ReplicaSetInterface {
@@ -127,6 +127,7 @@ func setExtensionsDefaults(config *restclient.Config) error {
//}
config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
if config.QPS == 0 {
config.QPS = 5
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go
index 09f1f027452b06c7210996dd80c2e9ef527e9dc8..7fd452d264d0ae25c33287fcc393607f0bbade81 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/fake/fake.go
@@ -70,7 +70,18 @@ func (c *RESTClient) Delete() *restclient.Request {
}
func (c *RESTClient) request(verb string) *restclient.Request {
- return restclient.NewRequest(c, verb, &url.URL{Host: "localhost"}, "", restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion(), Codec: c.Codec}, nil, nil)
+ config := restclient.ContentConfig{
+ ContentType: runtime.ContentTypeJSON,
+ GroupVersion: testapi.Default.GroupVersion(),
+ Codec: c.Codec,
+ }
+ serializers := restclient.Serializers{
+ Encoder: c.Codec,
+ Decoder: c.Codec,
+ StreamingSerializer: c.Codec,
+ Framer: runtime.DefaultFramer,
+ }
+ return restclient.NewRequest(c, verb, &url.URL{Host: "localhost"}, "", config, serializers, nil, nil)
}
func (c *RESTClient) Do(req *http.Request) (*http.Response, error) {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/flags.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/flags.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/flags.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/flags.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/helper.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/helper.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/helper.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/helper.go
index 3ee6d6ec69b4c12d55429bf98fa0f403a0bb71e1..020bb01c26d809e64c2685223033c0f962274397 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/helper.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/helper.go
@@ -18,18 +18,22 @@ package unversioned
import (
"fmt"
- "reflect"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/apps"
"k8s.io/kubernetes/pkg/apis/autoscaling"
"k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/policy"
+ "k8s.io/kubernetes/pkg/apis/rbac"
"k8s.io/kubernetes/pkg/client/restclient"
"k8s.io/kubernetes/pkg/client/typed/discovery"
"k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/pkg/version"
+ // Import solely to initialize client auth plugins.
+ _ "k8s.io/kubernetes/plugin/pkg/client/auth"
)
const (
@@ -83,8 +87,34 @@ func New(c *restclient.Config) (*Client, error) {
return nil, err
}
}
+ var policyClient *PolicyClient
+ if registered.IsRegistered(policy.GroupName) {
+ policyConfig := *c
+ policyClient, err = NewPolicy(&policyConfig)
+ if err != nil {
+ return nil, err
+ }
+ }
- return &Client{RESTClient: client, AutoscalingClient: autoscalingClient, BatchClient: batchClient, ExtensionsClient: extensionsClient, DiscoveryClient: discoveryClient}, nil
+ var appsClient *AppsClient
+ if registered.IsRegistered(apps.GroupName) {
+ appsConfig := *c
+ appsClient, err = NewApps(&appsConfig)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ var rbacClient *RbacClient
+ if registered.IsRegistered(rbac.GroupName) {
+ rbacConfig := *c
+ rbacClient, err = NewRbac(&rbacConfig)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return &Client{RESTClient: client, AutoscalingClient: autoscalingClient, BatchClient: batchClient, ExtensionsClient: extensionsClient, DiscoveryClient: discoveryClient, AppsClient: appsClient, PolicyClient: policyClient, RbacClient: rbacClient}, nil
}
// MatchesServerVersion queries the server to compares the build version
@@ -98,13 +128,14 @@ func MatchesServerVersion(client *Client, c *restclient.Config) error {
return err
}
}
- clientVersion := version.Get()
- serverVersion, err := client.Discovery().ServerVersion()
+ cVer := version.Get()
+ sVer, err := client.Discovery().ServerVersion()
if err != nil {
return fmt.Errorf("couldn't read version from server: %v\n", err)
}
- if s := *serverVersion; !reflect.DeepEqual(clientVersion, s) {
- return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", s, clientVersion)
+ // GitVersion includes GitCommit and GitTreeState, but best to be safe?
+ if cVer.GitVersion != sVer.GitVersion || cVer.GitCommit != sVer.GitCommit || cVer.GitTreeState != cVer.GitTreeState {
+ return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, cVer)
}
return nil
@@ -220,6 +251,9 @@ func SetKubernetesDefaults(config *restclient.Config) error {
// TODO: Unconditionally set the config.Version, until we fix the config.
copyGroupVersion := g.GroupVersion
config.GroupVersion = ©GroupVersion
+ if config.NegotiatedSerializer == nil {
+ config.NegotiatedSerializer = api.Codecs
+ }
if config.Codec == nil {
config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go
new file mode 100644
index 0000000000000000000000000000000000000000..8cdba3a265cfa02398c9cb832e9f39c71047447c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go
@@ -0,0 +1,103 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/autoscaling"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// HorizontalPodAutoscalersNamespacer has methods to work with HorizontalPodAutoscaler resources in a namespace
+type HorizontalPodAutoscalersNamespacer interface {
+ HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface
+}
+
+// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources.
+type HorizontalPodAutoscalerInterface interface {
+ List(opts api.ListOptions) (*autoscaling.HorizontalPodAutoscalerList, error)
+ Get(name string) (*autoscaling.HorizontalPodAutoscaler, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Create(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
+ Update(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
+ UpdateStatus(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (*autoscaling.HorizontalPodAutoscaler, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// horizontalPodAutoscalers implements HorizontalPodAutoscalersNamespacer interface using AutoscalingClient internally
+type horizontalPodAutoscalers struct {
+ client *AutoscalingClient
+ ns string
+}
+
+// newHorizontalPodAutoscalers returns a horizontalPodAutoscalers
+func newHorizontalPodAutoscalers(c *AutoscalingClient, namespace string) *horizontalPodAutoscalers {
+ return &horizontalPodAutoscalers{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// List takes label and field selectors, and returns the list of horizontalPodAutoscalers that match those selectors.
+func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *autoscaling.HorizontalPodAutoscalerList, err error) {
+ result = &autoscaling.HorizontalPodAutoscalerList{}
+ err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get takes the name of the horizontalPodAutoscaler, and returns the corresponding HorizontalPodAutoscaler object, and an error if it occurs
+func (c *horizontalPodAutoscalers) Get(name string) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
+ err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Do().Into(result)
+ return
+}
+
+// Delete takes the name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
+func (c *horizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Body(options).Do().Error()
+}
+
+// Create takes the representation of a horizontalPodAutoscaler and creates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
+func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
+ err = c.client.Post().Namespace(c.ns).Resource("horizontalPodAutoscalers").Body(horizontalPodAutoscaler).Do().Into(result)
+ return
+}
+
+// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
+func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
+ err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).Body(horizontalPodAutoscaler).Do().Into(result)
+ return
+}
+
+// UpdateStatus takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs.
+func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *autoscaling.HorizontalPodAutoscaler) (result *autoscaling.HorizontalPodAutoscaler, err error) {
+ result = &autoscaling.HorizontalPodAutoscaler{}
+ err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).SubResource("status").Body(horizontalPodAutoscaler).Do().Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
+func (c *horizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("horizontalPodAutoscalers").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go
new file mode 100644
index 0000000000000000000000000000000000000000..bbe61472dcae4df24635ef18699db901202341bd
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/import_known_versions.go
@@ -0,0 +1,40 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+// These imports are the API groups the client will support.
+import (
+ "fmt"
+
+ _ "k8s.io/kubernetes/pkg/api/install"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ _ "k8s.io/kubernetes/pkg/apis/apps/install"
+ _ "k8s.io/kubernetes/pkg/apis/authentication.k8s.io/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/componentconfig/install"
+ _ "k8s.io/kubernetes/pkg/apis/extensions/install"
+ _ "k8s.io/kubernetes/pkg/apis/policy/install"
+ _ "k8s.io/kubernetes/pkg/apis/rbac/install"
+)
+
+func init() {
+ if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+ panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/ingress.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/ingress.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/ingress.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/ingress.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/jobs.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/jobs.go
similarity index 75%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/jobs.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/jobs.go
index f965a08749327c80ecf49d339bf22db17270ade0..94b819079a9238e3ce4bc843f9ffc1899087dd6e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/jobs.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/jobs.go
@@ -18,7 +18,7 @@ package unversioned
import (
"k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/watch"
)
@@ -29,13 +29,13 @@ type JobsNamespacer interface {
// JobInterface exposes methods to work on Job resources.
type JobInterface interface {
- List(opts api.ListOptions) (*extensions.JobList, error)
- Get(name string) (*extensions.Job, error)
- Create(job *extensions.Job) (*extensions.Job, error)
- Update(job *extensions.Job) (*extensions.Job, error)
+ List(opts api.ListOptions) (*batch.JobList, error)
+ Get(name string) (*batch.Job, error)
+ Create(job *batch.Job) (*batch.Job, error)
+ Update(job *batch.Job) (*batch.Job, error)
Delete(name string, options *api.DeleteOptions) error
Watch(opts api.ListOptions) (watch.Interface, error)
- UpdateStatus(job *extensions.Job) (*extensions.Job, error)
+ UpdateStatus(job *batch.Job) (*batch.Job, error)
}
// jobs implements JobsNamespacer interface
@@ -53,29 +53,29 @@ func newJobs(c *ExtensionsClient, namespace string) *jobs {
var _ JobInterface = &jobs{}
// List returns a list of jobs that match the label and field selectors.
-func (c *jobs) List(opts api.ListOptions) (result *extensions.JobList, err error) {
- result = &extensions.JobList{}
+func (c *jobs) List(opts api.ListOptions) (result *batch.JobList, err error) {
+ result = &batch.JobList{}
err = c.r.Get().Namespace(c.ns).Resource("jobs").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
return
}
// Get returns information about a particular job.
-func (c *jobs) Get(name string) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Get(name string) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Get().Namespace(c.ns).Resource("jobs").Name(name).Do().Into(result)
return
}
// Create creates a new job.
-func (c *jobs) Create(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Create(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Post().Namespace(c.ns).Resource("jobs").Body(job).Do().Into(result)
return
}
// Update updates an existing job.
-func (c *jobs) Update(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) Update(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Put().Namespace(c.ns).Resource("jobs").Name(job.Name).Body(job).Do().Into(result)
return
}
@@ -96,8 +96,8 @@ func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
}
// UpdateStatus takes the name of the job and the new status. Returns the server's representation of the job, and an error, if it occurs.
-func (c *jobs) UpdateStatus(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobs) UpdateStatus(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Put().Namespace(c.ns).Resource("jobs").Name(job.Name).SubResource("status").Body(job).Do().Into(result)
return
}
@@ -117,29 +117,29 @@ func newJobsV1(c *BatchClient, namespace string) *jobsV1 {
var _ JobInterface = &jobsV1{}
// List returns a list of jobs that match the label and field selectors.
-func (c *jobsV1) List(opts api.ListOptions) (result *extensions.JobList, err error) {
- result = &extensions.JobList{}
+func (c *jobsV1) List(opts api.ListOptions) (result *batch.JobList, err error) {
+ result = &batch.JobList{}
err = c.r.Get().Namespace(c.ns).Resource("jobs").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
return
}
// Get returns information about a particular job.
-func (c *jobsV1) Get(name string) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobsV1) Get(name string) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Get().Namespace(c.ns).Resource("jobs").Name(name).Do().Into(result)
return
}
// Create creates a new job.
-func (c *jobsV1) Create(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobsV1) Create(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Post().Namespace(c.ns).Resource("jobs").Body(job).Do().Into(result)
return
}
// Update updates an existing job.
-func (c *jobsV1) Update(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobsV1) Update(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Put().Namespace(c.ns).Resource("jobs").Name(job.Name).Body(job).Do().Into(result)
return
}
@@ -160,8 +160,8 @@ func (c *jobsV1) Watch(opts api.ListOptions) (watch.Interface, error) {
}
// UpdateStatus takes the name of the job and the new status. Returns the server's representation of the job, and an error, if it occurs.
-func (c *jobsV1) UpdateStatus(job *extensions.Job) (result *extensions.Job, err error) {
- result = &extensions.Job{}
+func (c *jobsV1) UpdateStatus(job *batch.Job) (result *batch.Job, err error) {
+ result = &batch.Job{}
err = c.r.Put().Namespace(c.ns).Resource("jobs").Name(job.Name).SubResource("status").Body(job).Do().Into(result)
return
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/limit_ranges.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/limit_ranges.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/limit_ranges.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/limit_ranges.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/network_policys.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/network_policys.go
new file mode 100644
index 0000000000000000000000000000000000000000..0dc9d97be8930a8cfdd2786fdfecf3ccb07e3f9e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/network_policys.go
@@ -0,0 +1,92 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// NetworkPolicyNamespacer has methods to work with NetworkPolicy resources in a namespace
+type NetworkPolicyNamespacer interface {
+ NetworkPolicies(namespace string) NetworkPolicyInterface
+}
+
+// NetworkPolicyInterface exposes methods to work on NetworkPolicy resources.
+type NetworkPolicyInterface interface {
+ List(opts api.ListOptions) (*extensions.NetworkPolicyList, error)
+ Get(name string) (*extensions.NetworkPolicy, error)
+ Create(networkPolicy *extensions.NetworkPolicy) (*extensions.NetworkPolicy, error)
+ Update(networkPolicy *extensions.NetworkPolicy) (*extensions.NetworkPolicy, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// NetworkPolicies implements NetworkPolicyNamespacer interface
+type NetworkPolicies struct {
+ r *ExtensionsClient
+ ns string
+}
+
+// newNetworkPolicies returns a NetworkPolicies
+func newNetworkPolicies(c *ExtensionsClient, namespace string) *NetworkPolicies {
+ return &NetworkPolicies{c, namespace}
+}
+
+// List returns a list of networkPolicy that match the label and field selectors.
+func (c *NetworkPolicies) List(opts api.ListOptions) (result *extensions.NetworkPolicyList, err error) {
+ result = &extensions.NetworkPolicyList{}
+ err = c.r.Get().Namespace(c.ns).Resource("networkpolicies").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get returns information about a particular networkPolicy.
+func (c *NetworkPolicies) Get(name string) (result *extensions.NetworkPolicy, err error) {
+ result = &extensions.NetworkPolicy{}
+ err = c.r.Get().Namespace(c.ns).Resource("networkpolicies").Name(name).Do().Into(result)
+ return
+}
+
+// Create creates a new networkPolicy.
+func (c *NetworkPolicies) Create(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) {
+ result = &extensions.NetworkPolicy{}
+ err = c.r.Post().Namespace(c.ns).Resource("networkpolicies").Body(networkPolicy).Do().Into(result)
+ return
+}
+
+// Update updates an existing networkPolicy.
+func (c *NetworkPolicies) Update(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) {
+ result = &extensions.NetworkPolicy{}
+ err = c.r.Put().Namespace(c.ns).Resource("networkpolicies").Name(networkPolicy.Name).Body(networkPolicy).Do().Into(result)
+ return
+}
+
+// Delete deletes a networkPolicy, returns error if one occurs.
+func (c *NetworkPolicies) Delete(name string, options *api.DeleteOptions) (err error) {
+ return c.r.Delete().Namespace(c.ns).Resource("networkpolicies").Name(name).Body(options).Do().Error()
+}
+
+// Watch returns a watch.Interface that watches the requested networkPolicy.
+func (c *NetworkPolicies) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.r.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("networkpolicies").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/nodes.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/nodes.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/nodes.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/nodes.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumeclaim.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumeclaim.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumeclaim.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumeclaim.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumes.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumes.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumes.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/persistentvolumes.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/pet_sets.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pet_sets.go
new file mode 100644
index 0000000000000000000000000000000000000000..71b1ea021763e9bb8e7a763e6aff15b1aee94b98
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pet_sets.go
@@ -0,0 +1,100 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// PetSetNamespacer has methods to work with PetSet resources in a namespace
+type PetSetNamespacer interface {
+ PetSets(namespace string) PetSetInterface
+}
+
+// PetSetInterface exposes methods to work on PetSet resources.
+type PetSetInterface interface {
+ List(opts api.ListOptions) (*apps.PetSetList, error)
+ Get(name string) (*apps.PetSet, error)
+ Create(petSet *apps.PetSet) (*apps.PetSet, error)
+ Update(petSet *apps.PetSet) (*apps.PetSet, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ UpdateStatus(petSet *apps.PetSet) (*apps.PetSet, error)
+}
+
+// petSet implements PetSetNamespacer interface
+type petSet struct {
+ r *AppsClient
+ ns string
+}
+
+// newPetSet returns a petSet
+func newPetSet(c *AppsClient, namespace string) *petSet {
+ return &petSet{c, namespace}
+}
+
+// List returns a list of petSet that match the label and field selectors.
+func (c *petSet) List(opts api.ListOptions) (result *apps.PetSetList, err error) {
+ result = &apps.PetSetList{}
+ err = c.r.Get().Namespace(c.ns).Resource("petsets").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get returns information about a particular petSet.
+func (c *petSet) Get(name string) (result *apps.PetSet, err error) {
+ result = &apps.PetSet{}
+ err = c.r.Get().Namespace(c.ns).Resource("petsets").Name(name).Do().Into(result)
+ return
+}
+
+// Create creates a new petSet.
+func (c *petSet) Create(petSet *apps.PetSet) (result *apps.PetSet, err error) {
+ result = &apps.PetSet{}
+ err = c.r.Post().Namespace(c.ns).Resource("petsets").Body(petSet).Do().Into(result)
+ return
+}
+
+// Update updates an existing petSet.
+func (c *petSet) Update(petSet *apps.PetSet) (result *apps.PetSet, err error) {
+ result = &apps.PetSet{}
+ err = c.r.Put().Namespace(c.ns).Resource("petsets").Name(petSet.Name).Body(petSet).Do().Into(result)
+ return
+}
+
+// Delete deletes a petSet, returns error if one occurs.
+func (c *petSet) Delete(name string, options *api.DeleteOptions) (err error) {
+ return c.r.Delete().Namespace(c.ns).Resource("petsets").Name(name).Body(options).Do().Error()
+}
+
+// Watch returns a watch.Interface that watches the requested petSet.
+func (c *petSet) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.r.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("petsets").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
+
+// UpdateStatus takes the name of the petSet and the new status. Returns the server's representation of the petSet, and an error, if it occurs.
+func (c *petSet) UpdateStatus(petSet *apps.PetSet) (result *apps.PetSet, err error) {
+ result = &apps.PetSet{}
+ err = c.r.Put().Namespace(c.ns).Resource("petsets").Name(petSet.Name).SubResource("status").Body(petSet).Do().Into(result)
+ return
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/pod_disruption_budgets.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pod_disruption_budgets.go
new file mode 100644
index 0000000000000000000000000000000000000000..14f373f37601bc7ff664ec85ddcb53b69e972074
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pod_disruption_budgets.go
@@ -0,0 +1,100 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/policy"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// PodDisruptionBudgetNamespacer has methods to work with PodDisruptionBudget resources in a namespace
+type PodDisruptionBudgetNamespacer interface {
+ PodDisruptionBudgets(namespace string) PodDisruptionBudgetInterface
+}
+
+// PodDisruptionBudgetInterface exposes methods to work on PodDisruptionBudget resources.
+type PodDisruptionBudgetInterface interface {
+ List(opts api.ListOptions) (*policy.PodDisruptionBudgetList, error)
+ Get(name string) (*policy.PodDisruptionBudget, error)
+ Create(podDisruptionBudget *policy.PodDisruptionBudget) (*policy.PodDisruptionBudget, error)
+ Update(podDisruptionBudget *policy.PodDisruptionBudget) (*policy.PodDisruptionBudget, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ UpdateStatus(podDisruptionBudget *policy.PodDisruptionBudget) (*policy.PodDisruptionBudget, error)
+}
+
+// podDisruptionBudget implements PodDisruptionBudgetNamespacer interface
+type podDisruptionBudget struct {
+ r *PolicyClient
+ ns string
+}
+
+// newPodDisruptionBudget returns a podDisruptionBudget
+func newPodDisruptionBudget(c *PolicyClient, namespace string) *podDisruptionBudget {
+ return &podDisruptionBudget{c, namespace}
+}
+
+// List returns a list of podDisruptionBudget that match the label and field selectors.
+func (c *podDisruptionBudget) List(opts api.ListOptions) (result *policy.PodDisruptionBudgetList, err error) {
+ result = &policy.PodDisruptionBudgetList{}
+ err = c.r.Get().Namespace(c.ns).Resource("poddisruptionbudgets").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get returns information about a particular podDisruptionBudget.
+func (c *podDisruptionBudget) Get(name string) (result *policy.PodDisruptionBudget, err error) {
+ result = &policy.PodDisruptionBudget{}
+ err = c.r.Get().Namespace(c.ns).Resource("poddisruptionbudgets").Name(name).Do().Into(result)
+ return
+}
+
+// Create creates a new podDisruptionBudget.
+func (c *podDisruptionBudget) Create(podDisruptionBudget *policy.PodDisruptionBudget) (result *policy.PodDisruptionBudget, err error) {
+ result = &policy.PodDisruptionBudget{}
+ err = c.r.Post().Namespace(c.ns).Resource("poddisruptionbudgets").Body(podDisruptionBudget).Do().Into(result)
+ return
+}
+
+// Update updates an existing podDisruptionBudget.
+func (c *podDisruptionBudget) Update(podDisruptionBudget *policy.PodDisruptionBudget) (result *policy.PodDisruptionBudget, err error) {
+ result = &policy.PodDisruptionBudget{}
+ err = c.r.Put().Namespace(c.ns).Resource("poddisruptionbudgets").Name(podDisruptionBudget.Name).Body(podDisruptionBudget).Do().Into(result)
+ return
+}
+
+// Delete deletes a podDisruptionBudget, returns error if one occurs.
+func (c *podDisruptionBudget) Delete(name string, options *api.DeleteOptions) (err error) {
+ return c.r.Delete().Namespace(c.ns).Resource("poddisruptionbudgets").Name(name).Body(options).Do().Error()
+}
+
+// Watch returns a watch.Interface that watches the requested podDisruptionBudget.
+func (c *podDisruptionBudget) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.r.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("poddisruptionbudgets").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
+
+// UpdateStatus takes the name of the podDisruptionBudget and the new status. Returns the server's representation of the podDisruptionBudget, and an error, if it occurs.
+func (c *podDisruptionBudget) UpdateStatus(podDisruptionBudget *policy.PodDisruptionBudget) (result *policy.PodDisruptionBudget, err error) {
+ result = &policy.PodDisruptionBudget{}
+ err = c.r.Put().Namespace(c.ns).Resource("poddisruptionbudgets").Name(podDisruptionBudget.Name).SubResource("status").Body(podDisruptionBudget).Do().Into(result)
+ return
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/pod_templates.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pod_templates.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/pod_templates.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/pod_templates.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/pods.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/pods.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/pods.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/pods.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go
index 64a34b4b23befc4383d22898a71a5a7276071fe1..356d913dbea7f59a245007c689cdb002dc5ba5f2 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/podsecuritypolicy.go
@@ -28,7 +28,7 @@ type PodSecurityPoliciesInterface interface {
type PodSecurityPolicyInterface interface {
Get(name string) (result *extensions.PodSecurityPolicy, err error)
- Create(scc *extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error)
+ Create(psp *extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error)
List(opts api.ListOptions) (*extensions.PodSecurityPolicyList, error)
Delete(name string) error
Update(*extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error)
@@ -45,11 +45,11 @@ func newPodSecurityPolicy(c *ExtensionsClient) *podSecurityPolicy {
return &podSecurityPolicy{c}
}
-func (s *podSecurityPolicy) Create(scc *extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error) {
+func (s *podSecurityPolicy) Create(psp *extensions.PodSecurityPolicy) (*extensions.PodSecurityPolicy, error) {
result := &extensions.PodSecurityPolicy{}
err := s.client.Post().
Resource("podsecuritypolicies").
- Body(scc).
+ Body(psp).
Do().
Into(result)
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/policy.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/policy.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b06ce275ac43332d678f6044f29a00b3ae68ad5
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/policy.go
@@ -0,0 +1,83 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/policy"
+ "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+type PolicyInterface interface {
+ PodDisruptionBudgetNamespacer
+}
+
+// PolicyClient is used to interact with Kubernetes batch features.
+type PolicyClient struct {
+ *restclient.RESTClient
+}
+
+func (c *PolicyClient) PodDisruptionBudgets(namespace string) PodDisruptionBudgetInterface {
+ return newPodDisruptionBudget(c, namespace)
+}
+
+func NewPolicy(c *restclient.Config) (*PolicyClient, error) {
+ config := *c
+ if err := setPolicyDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &PolicyClient{client}, nil
+}
+
+func NewPolicyOrDie(c *restclient.Config) *PolicyClient {
+ client, err := NewPolicy(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+func setPolicyDefaults(config *restclient.Config) error {
+ g, err := registered.Group(policy.GroupName)
+ if err != nil {
+ return err
+ }
+ config.APIPath = defaultAPIPath
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/rbac.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/rbac.go
new file mode 100644
index 0000000000000000000000000000000000000000..76ec392c3e47aeef1d97f781d00cffa2e354a082
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/rbac.go
@@ -0,0 +1,103 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+// Interface holds the methods for clients of Kubernetes to allow mock testing.
+type RbacInterface interface {
+ RoleBindingsNamespacer
+ RolesNamespacer
+ ClusterRoleBindings
+ ClusterRoles
+}
+
+type RbacClient struct {
+ *restclient.RESTClient
+}
+
+func (c *RbacClient) RoleBindings(namespace string) RoleBindingInterface {
+ return newRoleBindings(c, namespace)
+}
+
+func (c *RbacClient) Roles(namespace string) RoleInterface {
+ return newRoles(c, namespace)
+}
+
+func (c *RbacClient) ClusterRoleBindings() ClusterRoleBindingInterface {
+ return newClusterRoleBindings(c)
+}
+
+func (c *RbacClient) ClusterRoles() ClusterRoleInterface {
+ return newClusterRoles(c)
+}
+
+// NewRbac creates a new RbacClient for the given config.
+func NewRbac(c *restclient.Config) (*RbacClient, error) {
+ config := *c
+ if err := setRbacDefaults(&config); err != nil {
+ return nil, err
+ }
+ client, err := restclient.RESTClientFor(&config)
+ if err != nil {
+ return nil, err
+ }
+ return &RbacClient{client}, nil
+}
+
+// NewRbacOrDie creates a new RbacClient for the given config and
+// panics if there is an error in the config.
+func NewRbacOrDie(c *restclient.Config) *RbacClient {
+ client, err := NewRbac(c)
+ if err != nil {
+ panic(err)
+ }
+ return client
+}
+
+func setRbacDefaults(config *restclient.Config) error {
+ // if rbac group is not registered, return an error
+ g, err := registered.Group(rbac.GroupName)
+ if err != nil {
+ return err
+ }
+ config.APIPath = defaultAPIPath
+ if config.UserAgent == "" {
+ config.UserAgent = restclient.DefaultKubernetesUserAgent()
+ }
+
+ // TODO: Unconditionally set the config.Version, until we fix the config.
+ //if config.Version == "" {
+ copyGroupVersion := g.GroupVersion
+ config.GroupVersion = ©GroupVersion
+ //}
+
+ config.Codec = api.Codecs.LegacyCodec(*config.GroupVersion)
+ config.NegotiatedSerializer = api.Codecs
+ if config.QPS == 0 {
+ config.QPS = 5
+ }
+ if config.Burst == 0 {
+ config.Burst = 10
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/doc.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/doc.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go
similarity index 84%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go
index d05e6ba5b3e10384d26c86c7db552e6b4df09a0f..7144f3093c11b720e20c9d11227f422941b14913 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/remotecommand.go
@@ -26,6 +26,7 @@ import (
"k8s.io/kubernetes/pkg/client/restclient"
"k8s.io/kubernetes/pkg/client/transport"
+ "k8s.io/kubernetes/pkg/kubelet/server/remotecommand"
"k8s.io/kubernetes/pkg/util/httpstream"
"k8s.io/kubernetes/pkg/util/httpstream/spdy"
)
@@ -36,7 +37,7 @@ type Executor interface {
// non-nil stream to a remote system, and return an error if a problem occurs. If tty
// is set, the stderr stream is not used (raw TTY manages stdout and stderr over the
// stdout stream).
- Stream(stdin io.Reader, stdout, stderr io.Writer, tty bool) error
+ Stream(supportedProtocols []string, stdin io.Reader, stdout, stderr io.Writer, tty bool) error
}
// StreamExecutor supports the ability to dial an httpstream connection and the ability to
@@ -128,26 +129,13 @@ func (e *streamExecutor) Dial(protocols ...string) (httpstream.Connection, strin
return conn, resp.Header.Get(httpstream.HeaderProtocolVersion), nil
}
-const (
- // The SPDY subprotocol "channel.k8s.io" is used for remote command
- // attachment/execution. This represents the initial unversioned subprotocol,
- // which has the known bugs http://issues.k8s.io/13394 and
- // http://issues.k8s.io/13395.
- StreamProtocolV1Name = "channel.k8s.io"
- // The SPDY subprotocol "v2.channel.k8s.io" is used for remote command
- // attachment/execution. It is the second version of the subprotocol and
- // resolves the issues present in the first version.
- StreamProtocolV2Name = "v2.channel.k8s.io"
-)
-
type streamProtocolHandler interface {
stream(httpstream.Connection) error
}
// Stream opens a protocol streamer to the server and streams until a client closes
// the connection or the server disconnects.
-func (e *streamExecutor) Stream(stdin io.Reader, stdout, stderr io.Writer, tty bool) error {
- supportedProtocols := []string{StreamProtocolV2Name, StreamProtocolV1Name}
+func (e *streamExecutor) Stream(supportedProtocols []string, stdin io.Reader, stdout, stderr io.Writer, tty bool) error {
conn, protocol, err := e.Dial(supportedProtocols...)
if err != nil {
return err
@@ -157,7 +145,7 @@ func (e *streamExecutor) Stream(stdin io.Reader, stdout, stderr io.Writer, tty b
var streamer streamProtocolHandler
switch protocol {
- case StreamProtocolV2Name:
+ case remotecommand.StreamProtocolV2Name:
streamer = &streamProtocolV2{
stdin: stdin,
stdout: stdout,
@@ -165,9 +153,9 @@ func (e *streamExecutor) Stream(stdin io.Reader, stdout, stderr io.Writer, tty b
tty: tty,
}
case "":
- glog.V(4).Infof("The server did not negotiate a streaming protocol version. Falling back to %s", StreamProtocolV1Name)
+ glog.V(4).Infof("The server did not negotiate a streaming protocol version. Falling back to %s", remotecommand.StreamProtocolV1Name)
fallthrough
- case StreamProtocolV1Name:
+ case remotecommand.StreamProtocolV1Name:
streamer = &streamProtocolV1{
stdin: stdin,
stdout: stdout,
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v1.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v1.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v1.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v1.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v2.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v2.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v2.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/remotecommand/v2.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/replica_sets.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/replica_sets.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/replica_sets.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/replica_sets.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/replication_controllers.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/replication_controllers.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/replication_controllers.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/replication_controllers.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/resource_quotas.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/resource_quotas.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/resource_quotas.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/resource_quotas.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/rolebindings.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/rolebindings.go
new file mode 100644
index 0000000000000000000000000000000000000000..a43815c55268d3e51566c10bd0689c301eddbeb7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/rolebindings.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// RoleBindingsNamespacer has methods to work with RoleBinding resources in a namespace
+type RoleBindingsNamespacer interface {
+ RoleBindings(namespace string) RoleBindingInterface
+}
+
+// RoleBindingInterface has methods to work with RoleBinding resources.
+type RoleBindingInterface interface {
+ List(opts api.ListOptions) (*rbac.RoleBindingList, error)
+ Get(name string) (*rbac.RoleBinding, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Create(roleBinding *rbac.RoleBinding) (*rbac.RoleBinding, error)
+ Update(roleBinding *rbac.RoleBinding) (*rbac.RoleBinding, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// roleBindings implements RoleBindingsNamespacer interface
+type roleBindings struct {
+ client *RbacClient
+ ns string
+}
+
+// newRoleBindings returns a roleBindings
+func newRoleBindings(c *RbacClient, namespace string) *roleBindings {
+ return &roleBindings{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// List takes label and field selectors, and returns the list of roleBindings that match those selectors.
+func (c *roleBindings) List(opts api.ListOptions) (result *rbac.RoleBindingList, err error) {
+ result = &rbac.RoleBindingList{}
+ err = c.client.Get().Namespace(c.ns).Resource("rolebindings").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get takes the name of the roleBinding, and returns the corresponding RoleBinding object, and an error if it occurs
+func (c *roleBindings) Get(name string) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Get().Namespace(c.ns).Resource("rolebindings").Name(name).Do().Into(result)
+ return
+}
+
+// Delete takes the name of the roleBinding and deletes it. Returns an error if one occurs.
+func (c *roleBindings) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().Namespace(c.ns).Resource("rolebindings").Name(name).Body(options).Do().Error()
+}
+
+// Create takes the representation of a roleBinding and creates it. Returns the server's representation of the roleBinding, and an error, if it occurs.
+func (c *roleBindings) Create(roleBinding *rbac.RoleBinding) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Post().Namespace(c.ns).Resource("rolebindings").Body(roleBinding).Do().Into(result)
+ return
+}
+
+// Update takes the representation of a roleBinding and updates it. Returns the server's representation of the roleBinding, and an error, if it occurs.
+func (c *roleBindings) Update(roleBinding *rbac.RoleBinding) (result *rbac.RoleBinding, err error) {
+ result = &rbac.RoleBinding{}
+ err = c.client.Put().Namespace(c.ns).Resource("rolebindings").Name(roleBinding.Name).Body(roleBinding).Do().Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested roleBindings.
+func (c *roleBindings) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("rolebindings").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/roles.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/roles.go
new file mode 100644
index 0000000000000000000000000000000000000000..29aee1baee76b0b27165b487bdc5dafc65e376d4
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/roles.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/rbac"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// RolesNamespacer has methods to work with Role resources in a namespace
+type RolesNamespacer interface {
+ Roles(namespace string) RoleInterface
+}
+
+// RoleInterface has methods to work with Role resources.
+type RoleInterface interface {
+ List(opts api.ListOptions) (*rbac.RoleList, error)
+ Get(name string) (*rbac.Role, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Create(role *rbac.Role) (*rbac.Role, error)
+ Update(role *rbac.Role) (*rbac.Role, error)
+ Watch(opts api.ListOptions) (watch.Interface, error)
+}
+
+// roles implements RolesNamespacer interface
+type roles struct {
+ client *RbacClient
+ ns string
+}
+
+// newRoles returns a roles
+func newRoles(c *RbacClient, namespace string) *roles {
+ return &roles{
+ client: c,
+ ns: namespace,
+ }
+}
+
+// List takes label and field selectors, and returns the list of roles that match those selectors.
+func (c *roles) List(opts api.ListOptions) (result *rbac.RoleList, err error) {
+ result = &rbac.RoleList{}
+ err = c.client.Get().Namespace(c.ns).Resource("roles").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get takes the name of the role, and returns the corresponding Role object, and an error if it occurs
+func (c *roles) Get(name string) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Get().Namespace(c.ns).Resource("roles").Name(name).Do().Into(result)
+ return
+}
+
+// Delete takes the name of the role and deletes it. Returns an error if one occurs.
+func (c *roles) Delete(name string, options *api.DeleteOptions) error {
+ return c.client.Delete().Namespace(c.ns).Resource("roles").Name(name).Body(options).Do().Error()
+}
+
+// Create takes the representation of a role and creates it. Returns the server's representation of the role, and an error, if it occurs.
+func (c *roles) Create(role *rbac.Role) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Post().Namespace(c.ns).Resource("roles").Body(role).Do().Into(result)
+ return
+}
+
+// Update takes the representation of a role and updates it. Returns the server's representation of the role, and an error, if it occurs.
+func (c *roles) Update(role *rbac.Role) (result *rbac.Role, err error) {
+ result = &rbac.Role{}
+ err = c.client.Put().Namespace(c.ns).Resource("roles").Name(role.Name).Body(role).Do().Into(result)
+ return
+}
+
+// Watch returns a watch.Interface that watches the requested roles.
+func (c *roles) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.client.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("roles").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/scale.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/scale.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/scale.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/scale.go
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/scheduledjobs.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/scheduledjobs.go
new file mode 100644
index 0000000000000000000000000000000000000000..d2b83fce200970e154861accbb77b567fd5d9738
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/scheduledjobs.go
@@ -0,0 +1,103 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/batch"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// ScheduledJobsNamespacer has methods to work with ScheduledJob resources in a namespace
+type ScheduledJobsNamespacer interface {
+ ScheduledJobs(namespace string) ScheduledJobInterface
+}
+
+// ScheduledJobInterface exposes methods to work on ScheduledJob resources.
+type ScheduledJobInterface interface {
+ List(opts api.ListOptions) (*batch.ScheduledJobList, error)
+ Get(name string) (*batch.ScheduledJob, error)
+ Create(scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error)
+ Update(scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error)
+ Delete(name string, options *api.DeleteOptions) error
+ Watch(opts api.ListOptions) (watch.Interface, error)
+ UpdateStatus(scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error)
+}
+
+// scheduledJobs implements ScheduledJobsNamespacer interface
+type scheduledJobs struct {
+ r *BatchClient
+ ns string
+}
+
+// newScheduledJobs returns a scheduledJobs
+func newScheduledJobs(c *BatchClient, namespace string) *scheduledJobs {
+ return &scheduledJobs{c, namespace}
+}
+
+// Ensure statically that scheduledJobs implements ScheduledJobInterface.
+var _ ScheduledJobInterface = &scheduledJobs{}
+
+// List returns a list of scheduled jobs that match the label and field selectors.
+func (c *scheduledJobs) List(opts api.ListOptions) (result *batch.ScheduledJobList, err error) {
+ result = &batch.ScheduledJobList{}
+ err = c.r.Get().Namespace(c.ns).Resource("scheduledJobs").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ return
+}
+
+// Get returns information about a particular scheduled job.
+func (c *scheduledJobs) Get(name string) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.r.Get().Namespace(c.ns).Resource("scheduledJobs").Name(name).Do().Into(result)
+ return
+}
+
+// Create creates a new scheduled job.
+func (c *scheduledJobs) Create(job *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.r.Post().Namespace(c.ns).Resource("scheduledJobs").Body(job).Do().Into(result)
+ return
+}
+
+// Update updates an existing scheduled job.
+func (c *scheduledJobs) Update(job *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.r.Put().Namespace(c.ns).Resource("scheduledJobs").Name(job.Name).Body(job).Do().Into(result)
+ return
+}
+
+// Delete deletes a scheduled job, returns error if one occurs.
+func (c *scheduledJobs) Delete(name string, options *api.DeleteOptions) (err error) {
+ return c.r.Delete().Namespace(c.ns).Resource("scheduledJobs").Name(name).Body(options).Do().Error()
+}
+
+// Watch returns a watch.Interface that watches the requested scheduled jobs.
+func (c *scheduledJobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+ return c.r.Get().
+ Prefix("watch").
+ Namespace(c.ns).
+ Resource("scheduledJobs").
+ VersionedParams(&opts, api.ParameterCodec).
+ Watch()
+}
+
+// UpdateStatus takes the name of the scheduled job and the new status. Returns the server's representation of the scheduled job, and an error, if it occurs.
+func (c *scheduledJobs) UpdateStatus(job *batch.ScheduledJob) (result *batch.ScheduledJob, err error) {
+ result = &batch.ScheduledJob{}
+ err = c.r.Put().Namespace(c.ns).Resource("scheduledJobs").Name(job.Name).SubResource("status").Body(job).Do().Into(result)
+ return
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/secrets.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/secrets.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/secrets.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/secrets.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/services.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/services.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go
rename to vendor/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go
index 09bc4e4afc81955fe8b839d188d97332a2741fc1..0908db06eb726ac3d8d64134daee75249fbbd698 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/thirdpartyresources.go
@@ -24,7 +24,7 @@ import (
// ThirdPartyResourceNamespacer has methods to work with ThirdPartyResource resources in a namespace
type ThirdPartyResourceNamespacer interface {
- ThirdPartyResources(namespace string) ThirdPartyResourceInterface
+ ThirdPartyResources() ThirdPartyResourceInterface
}
type ThirdPartyResourceInterface interface {
@@ -39,12 +39,11 @@ type ThirdPartyResourceInterface interface {
// thirdPartyResources implements DaemonsSetsNamespacer interface
type thirdPartyResources struct {
- r *ExtensionsClient
- ns string
+ r *ExtensionsClient
}
-func newThirdPartyResources(c *ExtensionsClient, namespace string) *thirdPartyResources {
- return &thirdPartyResources{c, namespace}
+func newThirdPartyResources(c *ExtensionsClient) *thirdPartyResources {
+ return &thirdPartyResources{c}
}
// Ensure statically that thirdPartyResources implements ThirdPartyResourcesInterface.
@@ -52,48 +51,47 @@ var _ ThirdPartyResourceInterface = &thirdPartyResources{}
func (c *thirdPartyResources) List(opts api.ListOptions) (result *extensions.ThirdPartyResourceList, err error) {
result = &extensions.ThirdPartyResourceList{}
- err = c.r.Get().Namespace(c.ns).Resource("thirdpartyresources").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
+ err = c.r.Get().Resource("thirdpartyresources").VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
return
}
// Get returns information about a particular third party resource.
func (c *thirdPartyResources) Get(name string) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
- err = c.r.Get().Namespace(c.ns).Resource("thirdpartyresources").Name(name).Do().Into(result)
+ err = c.r.Get().Resource("thirdpartyresources").Name(name).Do().Into(result)
return
}
// Create creates a new third party resource.
func (c *thirdPartyResources) Create(resource *extensions.ThirdPartyResource) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
- err = c.r.Post().Namespace(c.ns).Resource("thirdpartyresources").Body(resource).Do().Into(result)
+ err = c.r.Post().Resource("thirdpartyresources").Body(resource).Do().Into(result)
return
}
// Update updates an existing third party resource.
func (c *thirdPartyResources) Update(resource *extensions.ThirdPartyResource) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
- err = c.r.Put().Namespace(c.ns).Resource("thirdpartyresources").Name(resource.Name).Body(resource).Do().Into(result)
+ err = c.r.Put().Resource("thirdpartyresources").Name(resource.Name).Body(resource).Do().Into(result)
return
}
// UpdateStatus updates an existing third party resource status
func (c *thirdPartyResources) UpdateStatus(resource *extensions.ThirdPartyResource) (result *extensions.ThirdPartyResource, err error) {
result = &extensions.ThirdPartyResource{}
- err = c.r.Put().Namespace(c.ns).Resource("thirdpartyresources").Name(resource.Name).SubResource("status").Body(resource).Do().Into(result)
+ err = c.r.Put().Resource("thirdpartyresources").Name(resource.Name).SubResource("status").Body(resource).Do().Into(result)
return
}
// Delete deletes an existing third party resource.
func (c *thirdPartyResources) Delete(name string) error {
- return c.r.Delete().Namespace(c.ns).Resource("thirdpartyresources").Name(name).Do().Error()
+ return c.r.Delete().Resource("thirdpartyresources").Name(name).Do().Error()
}
// Watch returns a watch.Interface that watches the requested third party resources.
func (c *thirdPartyResources) Watch(opts api.ListOptions) (watch.Interface, error) {
return c.r.Get().
Prefix("watch").
- Namespace(c.ns).
Resource("thirdpartyresources").
VersionedParams(&opts, api.ParameterCodec).
Watch()
diff --git a/vendor/k8s.io/kubernetes/pkg/client/unversioned/util.go b/vendor/k8s.io/kubernetes/pkg/client/unversioned/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..37ada3c3d67c62e52d0b0b3b37e0e3c698543baa
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/client/unversioned/util.go
@@ -0,0 +1,79 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 unversioned
+
+import (
+ "time"
+
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/util/wait"
+)
+
+// DefaultRetry is the recommended retry for a conflict where multiple clients
+// are making changes to the same resource.
+var DefaultRetry = wait.Backoff{
+ Steps: 5,
+ Duration: 10 * time.Millisecond,
+ Factor: 1.0,
+ Jitter: 0.1,
+}
+
+// DefaultBackoff is the recommended backoff for a conflict where a client
+// may be attempting to make an unrelated modification to a resource under
+// active management by one or more controllers.
+var DefaultBackoff = wait.Backoff{
+ Steps: 4,
+ Duration: 10 * time.Millisecond,
+ Factor: 5.0,
+ Jitter: 0.1,
+}
+
+// RetryConflict executes the provided function repeatedly, retrying if the server returns a conflicting
+// write. Callers should preserve previous executions if they wish to retry changes. It performs an
+// exponential backoff.
+//
+// var pod *api.Pod
+// err := RetryOnConflict(DefaultBackoff, func() (err error) {
+// pod, err = c.Pods("mynamespace").UpdateStatus(podStatus)
+// return
+// })
+// if err != nil {
+// // may be conflict if max retries were hit
+// return err
+// }
+// ...
+//
+// TODO: Make Backoff an interface?
+func RetryOnConflict(backoff wait.Backoff, fn func() error) error {
+ var lastConflictErr error
+ err := wait.ExponentialBackoff(backoff, func() (bool, error) {
+ err := fn()
+ switch {
+ case err == nil:
+ return true, nil
+ case errors.IsConflict(err):
+ lastConflictErr = err
+ return false, nil
+ default:
+ return false, err
+ }
+ })
+ if err == wait.ErrWaitTimeout {
+ err = lastConflictErr
+ }
+ return err
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/OWNERS b/vendor/k8s.io/kubernetes/pkg/controller/OWNERS
similarity index 82%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/controller/OWNERS
index 35859cd8c025205204e27ff81de6abe7a88845fb..ac83016025ce1536d453501010587c43fd2af21a 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/OWNERS
+++ b/vendor/k8s.io/kubernetes/pkg/controller/OWNERS
@@ -1,5 +1,4 @@
assignees:
- bprashanth
- - davidopp
- derekwaynecarr
- mikedanese
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/controller_utils.go b/vendor/k8s.io/kubernetes/pkg/controller/controller_utils.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/controller_utils.go
rename to vendor/k8s.io/kubernetes/pkg/controller/controller_utils.go
index fc377134d930037ef62d88da8bc7b730c6815866..a7aba40bece59b3db201cf63158f36618e361c85 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/controller_utils.go
+++ b/vendor/k8s.io/kubernetes/pkg/controller/controller_utils.go
@@ -24,6 +24,7 @@ import (
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/validation"
"k8s.io/kubernetes/pkg/apis/extensions"
@@ -174,7 +175,7 @@ func (exp *ControlleeExpectations) isExpired() bool {
// SetExpectations registers new expectations for the given controller. Forgets existing expectations.
func (r *ControllerExpectations) SetExpectations(controllerKey string, add, del int) error {
exp := &ControlleeExpectations{add: int64(add), del: int64(del), key: controllerKey, timestamp: util.RealClock{}.Now()}
- glog.V(4).Infof("Setting expectations %+v", exp)
+ glog.V(4).Infof("Setting expectations %#v", exp)
return r.Add(exp)
}
@@ -398,7 +399,7 @@ func getPodsAnnotationSet(template *api.PodTemplateSpec, object runtime.Object)
func getPodsPrefix(controllerName string) string {
// use the dash (if the name isn't too long) to make the pod name a bit prettier
prefix := fmt.Sprintf("%s-", controllerName)
- if ok, _ := validation.ValidatePodName(prefix, true); !ok {
+ if len(validation.ValidatePodName(prefix, true)) != 0 {
prefix = controllerName
}
return prefix
@@ -412,17 +413,17 @@ func (r RealPodControl) CreatePodsOnNode(nodeName, namespace string, template *a
return r.createPods(nodeName, namespace, template, object)
}
-func (r RealPodControl) createPods(nodeName, namespace string, template *api.PodTemplateSpec, object runtime.Object) error {
+func GetPodFromTemplate(template *api.PodTemplateSpec, parentObject runtime.Object) (*api.Pod, error) {
desiredLabels := getPodsLabelSet(template)
- desiredAnnotations, err := getPodsAnnotationSet(template, object)
+ desiredAnnotations, err := getPodsAnnotationSet(template, parentObject)
if err != nil {
- return err
+ return nil, err
}
- meta, err := api.ObjectMetaFor(object)
+ accessor, err := meta.Accessor(parentObject)
if err != nil {
- return fmt.Errorf("object does not have ObjectMeta, %v", err)
+ return nil, fmt.Errorf("parentObject does not have ObjectMeta, %v", err)
}
- prefix := getPodsPrefix(meta.Name)
+ prefix := getPodsPrefix(accessor.GetName())
pod := &api.Pod{
ObjectMeta: api.ObjectMeta{
@@ -432,7 +433,15 @@ func (r RealPodControl) createPods(nodeName, namespace string, template *api.Pod
},
}
if err := api.Scheme.Convert(&template.Spec, &pod.Spec); err != nil {
- return fmt.Errorf("unable to convert pod template: %v", err)
+ return nil, fmt.Errorf("unable to convert pod template: %v", err)
+ }
+ return pod, nil
+}
+
+func (r RealPodControl) createPods(nodeName, namespace string, template *api.PodTemplateSpec, object runtime.Object) error {
+ pod, err := GetPodFromTemplate(template, object)
+ if err != nil {
+ return err
}
if len(nodeName) != 0 {
pod.Spec.NodeName = nodeName
@@ -444,14 +453,19 @@ func (r RealPodControl) createPods(nodeName, namespace string, template *api.Pod
r.Recorder.Eventf(object, api.EventTypeWarning, "FailedCreate", "Error creating: %v", err)
return fmt.Errorf("unable to create pods: %v", err)
} else {
- glog.V(4).Infof("Controller %v created pod %v", meta.Name, newPod.Name)
+ accessor, err := meta.Accessor(object)
+ if err != nil {
+ glog.Errorf("parentObject does not have ObjectMeta, %v", err)
+ return nil
+ }
+ glog.V(4).Infof("Controller %v created pod %v", accessor.GetName(), newPod.Name)
r.Recorder.Eventf(object, api.EventTypeNormal, "SuccessfulCreate", "Created pod: %v", newPod.Name)
}
return nil
}
func (r RealPodControl) DeletePod(namespace string, podID string, object runtime.Object) error {
- meta, err := api.ObjectMetaFor(object)
+ accessor, err := meta.Accessor(object)
if err != nil {
return fmt.Errorf("object does not have ObjectMeta, %v", err)
}
@@ -459,7 +473,7 @@ func (r RealPodControl) DeletePod(namespace string, podID string, object runtime
r.Recorder.Eventf(object, api.EventTypeWarning, "FailedDelete", "Error deleting: %v", err)
return fmt.Errorf("unable to delete pods: %v", err)
} else {
- glog.V(4).Infof("Controller %v deleted pod %v", meta.Name, podID)
+ glog.V(4).Infof("Controller %v deleted pod %v", accessor.GetName(), podID)
r.Recorder.Eventf(object, api.EventTypeNormal, "SuccessfulDelete", "Deleted pod: %v", podID)
}
return nil
@@ -575,7 +589,7 @@ func podReadyTime(pod *api.Pod) unversioned.Time {
func maxContainerRestarts(pod *api.Pod) int {
maxRestarts := 0
for _, c := range pod.Status.ContainerStatuses {
- maxRestarts = integer.IntMax(maxRestarts, c.RestartCount)
+ maxRestarts = integer.IntMax(maxRestarts, int(c.RestartCount))
}
return maxRestarts
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/doc.go b/vendor/k8s.io/kubernetes/pkg/controller/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/doc.go
rename to vendor/k8s.io/kubernetes/pkg/controller/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/controller.go b/vendor/k8s.io/kubernetes/pkg/controller/framework/controller.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/controller.go
rename to vendor/k8s.io/kubernetes/pkg/controller/framework/controller.go
index ed819525266d54bbecb3b1e99a54532f3d2c1166..c6363952b0cf9a3ef7246e4cb8c311bba29a9daa 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/controller.go
+++ b/vendor/k8s.io/kubernetes/pkg/controller/framework/controller.go
@@ -68,6 +68,12 @@ type Controller struct {
reflectorMutex sync.RWMutex
}
+// TODO make the "Controller" private, and convert all references to use ControllerInterface instead
+type ControllerInterface interface {
+ Run(stopCh <-chan struct{})
+ HasSynced() bool
+}
+
// New makes a new Controller from the given Config.
func New(c *Config) *Controller {
ctlr := &Controller{
@@ -118,8 +124,7 @@ func (c *Controller) Requeue(obj interface{}) error {
// concurrently.
func (c *Controller) processLoop() {
for {
- obj := c.config.Queue.Pop()
- err := c.config.Process(obj)
+ obj, err := c.config.Queue.Pop(cache.PopProcessFunc(c.config.Process))
if err != nil {
if c.config.RetryOnError {
// This is the safe way to re-enqueue.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/doc.go b/vendor/k8s.io/kubernetes/pkg/controller/framework/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/doc.go
rename to vendor/k8s.io/kubernetes/pkg/controller/framework/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go b/vendor/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go
similarity index 67%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go
rename to vendor/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go
index fa28171137c42ceaf9b27878e1ead6a9ad1aacc5..9e90e7c916e4f67b920d7d56e6dd66f312883935 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go
+++ b/vendor/k8s.io/kubernetes/pkg/controller/framework/fake_controller_source.go
@@ -31,17 +31,41 @@ import (
func NewFakeControllerSource() *FakeControllerSource {
return &FakeControllerSource{
- items: map[nnu]runtime.Object{},
- broadcaster: watch.NewBroadcaster(100, watch.WaitIfChannelFull),
+ Items: map[nnu]runtime.Object{},
+ Broadcaster: watch.NewBroadcaster(100, watch.WaitIfChannelFull),
}
}
+func NewFakePVControllerSource() *FakePVControllerSource {
+ return &FakePVControllerSource{
+ FakeControllerSource{
+ Items: map[nnu]runtime.Object{},
+ Broadcaster: watch.NewBroadcaster(100, watch.WaitIfChannelFull),
+ }}
+}
+
+func NewFakePVCControllerSource() *FakePVCControllerSource {
+ return &FakePVCControllerSource{
+ FakeControllerSource{
+ Items: map[nnu]runtime.Object{},
+ Broadcaster: watch.NewBroadcaster(100, watch.WaitIfChannelFull),
+ }}
+}
+
// FakeControllerSource implements listing/watching for testing.
type FakeControllerSource struct {
lock sync.RWMutex
- items map[nnu]runtime.Object
+ Items map[nnu]runtime.Object
changes []watch.Event // one change per resourceVersion
- broadcaster *watch.Broadcaster
+ Broadcaster *watch.Broadcaster
+}
+
+type FakePVControllerSource struct {
+ FakeControllerSource
+}
+
+type FakePVCControllerSource struct {
+ FakeControllerSource
}
// namespace, name, uid to be used as a key.
@@ -89,8 +113,8 @@ func (f *FakeControllerSource) DeleteDropWatch(lastValue runtime.Object) {
f.Change(watch.Event{Type: watch.Deleted, Object: lastValue}, 0)
}
-func (f *FakeControllerSource) key(meta *api.ObjectMeta) nnu {
- return nnu{meta.Namespace, meta.Name, meta.UID}
+func (f *FakeControllerSource) key(accessor meta.Object) nnu {
+ return nnu{accessor.GetNamespace(), accessor.GetName(), accessor.GetUID()}
}
// Change records the given event (setting the object's resource version) and
@@ -99,33 +123,30 @@ func (f *FakeControllerSource) Change(e watch.Event, watchProbability float64) {
f.lock.Lock()
defer f.lock.Unlock()
- objMeta, err := api.ObjectMetaFor(e.Object)
+ accessor, err := meta.Accessor(e.Object)
if err != nil {
panic(err) // this is test code only
}
resourceVersion := len(f.changes) + 1
- objMeta.ResourceVersion = strconv.Itoa(resourceVersion)
+ accessor.SetResourceVersion(strconv.Itoa(resourceVersion))
f.changes = append(f.changes, e)
- key := f.key(objMeta)
+ key := f.key(accessor)
switch e.Type {
case watch.Added, watch.Modified:
- f.items[key] = e.Object
+ f.Items[key] = e.Object
case watch.Deleted:
- delete(f.items, key)
+ delete(f.Items, key)
}
if rand.Float64() < watchProbability {
- f.broadcaster.Action(e.Type, e.Object)
+ f.Broadcaster.Action(e.Type, e.Object)
}
}
-// List returns a list object, with its resource version set.
-func (f *FakeControllerSource) List(options api.ListOptions) (runtime.Object, error) {
- f.lock.RLock()
- defer f.lock.RUnlock()
- list := make([]runtime.Object, 0, len(f.items))
- for _, obj := range f.items {
+func (f *FakeControllerSource) getListItemsLocked() ([]runtime.Object, error) {
+ list := make([]runtime.Object, 0, len(f.Items))
+ for _, obj := range f.Items {
// Must make a copy to allow clients to modify the object.
// Otherwise, if they make a change and write it back, they
// will inadvertently change our canonical copy (in
@@ -136,6 +157,17 @@ func (f *FakeControllerSource) List(options api.ListOptions) (runtime.Object, er
}
list = append(list, objCopy.(runtime.Object))
}
+ return list, nil
+}
+
+// List returns a list object, with its resource version set.
+func (f *FakeControllerSource) List(options api.ListOptions) (runtime.Object, error) {
+ f.lock.RLock()
+ defer f.lock.RUnlock()
+ list, err := f.getListItemsLocked()
+ if err != nil {
+ return nil, err
+ }
listObj := &api.List{}
if err := meta.SetList(listObj, list); err != nil {
return nil, err
@@ -149,6 +181,48 @@ func (f *FakeControllerSource) List(options api.ListOptions) (runtime.Object, er
return listObj, nil
}
+// List returns a list object, with its resource version set.
+func (f *FakePVControllerSource) List(options api.ListOptions) (runtime.Object, error) {
+ f.lock.RLock()
+ defer f.lock.RUnlock()
+ list, err := f.FakeControllerSource.getListItemsLocked()
+ if err != nil {
+ return nil, err
+ }
+ listObj := &api.PersistentVolumeList{}
+ if err := meta.SetList(listObj, list); err != nil {
+ return nil, err
+ }
+ objMeta, err := api.ListMetaFor(listObj)
+ if err != nil {
+ return nil, err
+ }
+ resourceVersion := len(f.changes)
+ objMeta.ResourceVersion = strconv.Itoa(resourceVersion)
+ return listObj, nil
+}
+
+// List returns a list object, with its resource version set.
+func (f *FakePVCControllerSource) List(options api.ListOptions) (runtime.Object, error) {
+ f.lock.RLock()
+ defer f.lock.RUnlock()
+ list, err := f.FakeControllerSource.getListItemsLocked()
+ if err != nil {
+ return nil, err
+ }
+ listObj := &api.PersistentVolumeClaimList{}
+ if err := meta.SetList(listObj, list); err != nil {
+ return nil, err
+ }
+ objMeta, err := api.ListMetaFor(listObj)
+ if err != nil {
+ return nil, err
+ }
+ resourceVersion := len(f.changes)
+ objMeta.ResourceVersion = strconv.Itoa(resourceVersion)
+ return listObj, nil
+}
+
// Watch returns a watch, which will be pre-populated with all changes
// after resourceVersion.
func (f *FakeControllerSource) Watch(options api.ListOptions) (watch.Interface, error) {
@@ -172,11 +246,11 @@ func (f *FakeControllerSource) Watch(options api.ListOptions) (watch.Interface,
}
changes = append(changes, watch.Event{Type: c.Type, Object: objCopy.(runtime.Object)})
}
- return f.broadcaster.WatchWithPrefix(changes), nil
+ return f.Broadcaster.WatchWithPrefix(changes), nil
} else if rc > len(f.changes) {
return nil, errors.New("resource version in the future not supported by this fake")
}
- return f.broadcaster.Watch(), nil
+ return f.Broadcaster.Watch(), nil
}
// Shutdown closes the underlying broadcaster, waiting for events to be
@@ -184,5 +258,5 @@ func (f *FakeControllerSource) Watch(options api.ListOptions) (watch.Interface,
// enforced by Shutdown() leaving f locked.
func (f *FakeControllerSource) Shutdown() {
f.lock.Lock() // Purposely no unlock.
- f.broadcaster.Shutdown()
+ f.Broadcaster.Shutdown()
}
diff --git a/vendor/k8s.io/kubernetes/pkg/controller/framework/shared_informer.go b/vendor/k8s.io/kubernetes/pkg/controller/framework/shared_informer.go
new file mode 100644
index 0000000000000000000000000000000000000000..c557bf97548a4e7054b05e0b158ba194b7dd59f2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/controller/framework/shared_informer.go
@@ -0,0 +1,342 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 framework
+
+import (
+ "fmt"
+ "sync"
+ "time"
+
+ "k8s.io/kubernetes/pkg/client/cache"
+ "k8s.io/kubernetes/pkg/runtime"
+ utilruntime "k8s.io/kubernetes/pkg/util/runtime"
+)
+
+// if you use this, there is one behavior change compared to a standard Informer.
+// When you receive a notification, the cache will be AT LEAST as fresh as the
+// notification, but it MAY be more fresh. You should NOT depend on the contents
+// of the cache exactly matching the notification you've received in handler
+// functions. If there was a create, followed by a delete, the cache may NOT
+// have your item. This has advantages over the broadcaster since it allows us
+// to share a common cache across many controllers. Extending the broadcaster
+// would have required us keep duplicate caches for each watch.
+type SharedInformer interface {
+ // events to a single handler are delivered sequentially, but there is no coordination between different handlers
+ // You may NOT add a handler *after* the SharedInformer is running. That will result in an error being returned.
+ // TODO we should try to remove this restriction eventually.
+ AddEventHandler(handler ResourceEventHandler) error
+ GetStore() cache.Store
+ // GetController gives back a synthetic interface that "votes" to start the informer
+ GetController() ControllerInterface
+ Run(stopCh <-chan struct{})
+ HasSynced() bool
+}
+
+type SharedIndexInformer interface {
+ SharedInformer
+ // AddIndexers add indexers to the informer before it starts.
+ AddIndexers(indexers cache.Indexers) error
+ GetIndexer() cache.Indexer
+}
+
+// NewSharedInformer creates a new instance for the listwatcher.
+// TODO: create a cache/factory of these at a higher level for the list all, watch all of a given resource that can
+// be shared amongst all consumers.
+func NewSharedInformer(lw cache.ListerWatcher, objType runtime.Object, resyncPeriod time.Duration) SharedInformer {
+ return NewSharedIndexInformer(lw, objType, resyncPeriod, cache.Indexers{})
+}
+
+// NewSharedIndexInformer creates a new instance for the listwatcher.
+// TODO: create a cache/factory of these at a higher level for the list all, watch all of a given resource that can
+// be shared amongst all consumers.
+func NewSharedIndexInformer(lw cache.ListerWatcher, objType runtime.Object, resyncPeriod time.Duration, indexers cache.Indexers) SharedIndexInformer {
+ sharedIndexInformer := &sharedIndexInformer{
+ processor: &sharedProcessor{},
+ indexer: cache.NewIndexer(DeletionHandlingMetaNamespaceKeyFunc, indexers),
+ listerWatcher: lw,
+ objectType: objType,
+ fullResyncPeriod: resyncPeriod,
+ }
+ return sharedIndexInformer
+}
+
+type sharedIndexInformer struct {
+ indexer cache.Indexer
+ controller *Controller
+
+ processor *sharedProcessor
+
+ // This block is tracked to handle late initialization of the controller
+ listerWatcher cache.ListerWatcher
+ objectType runtime.Object
+ fullResyncPeriod time.Duration
+
+ started bool
+ startedLock sync.Mutex
+}
+
+// dummyController hides the fact that a SharedInformer is different from a dedicated one
+// where a caller can `Run`. The run method is disonnected in this case, because higher
+// level logic will decide when to start the SharedInformer and related controller.
+// Because returning information back is always asynchronous, the legacy callers shouldn't
+// notice any change in behavior.
+type dummyController struct {
+ informer *sharedIndexInformer
+}
+
+func (v *dummyController) Run(stopCh <-chan struct{}) {
+}
+
+func (v *dummyController) HasSynced() bool {
+ return v.informer.HasSynced()
+}
+
+type updateNotification struct {
+ oldObj interface{}
+ newObj interface{}
+}
+
+type addNotification struct {
+ newObj interface{}
+}
+
+type deleteNotification struct {
+ oldObj interface{}
+}
+
+func (s *sharedIndexInformer) Run(stopCh <-chan struct{}) {
+ defer utilruntime.HandleCrash()
+
+ fifo := cache.NewDeltaFIFO(cache.MetaNamespaceKeyFunc, nil, s.indexer)
+
+ cfg := &Config{
+ Queue: fifo,
+ ListerWatcher: s.listerWatcher,
+ ObjectType: s.objectType,
+ FullResyncPeriod: s.fullResyncPeriod,
+ RetryOnError: false,
+
+ Process: s.HandleDeltas,
+ }
+
+ func() {
+ s.startedLock.Lock()
+ defer s.startedLock.Unlock()
+
+ s.controller = New(cfg)
+ s.started = true
+ }()
+
+ s.processor.run(stopCh)
+ s.controller.Run(stopCh)
+}
+
+func (s *sharedIndexInformer) isStarted() bool {
+ s.startedLock.Lock()
+ defer s.startedLock.Unlock()
+ return s.started
+}
+
+func (s *sharedIndexInformer) HasSynced() bool {
+ s.startedLock.Lock()
+ defer s.startedLock.Unlock()
+
+ if s.controller == nil {
+ return false
+ }
+ return s.controller.HasSynced()
+}
+
+func (s *sharedIndexInformer) GetStore() cache.Store {
+ return s.indexer
+}
+
+func (s *sharedIndexInformer) GetIndexer() cache.Indexer {
+ return s.indexer
+}
+
+func (s *sharedIndexInformer) AddIndexers(indexers cache.Indexers) error {
+ s.startedLock.Lock()
+ defer s.startedLock.Unlock()
+
+ if s.started {
+ return fmt.Errorf("informer has already started")
+ }
+
+ return s.indexer.AddIndexers(indexers)
+}
+
+func (s *sharedIndexInformer) GetController() ControllerInterface {
+ return &dummyController{informer: s}
+}
+
+func (s *sharedIndexInformer) AddEventHandler(handler ResourceEventHandler) error {
+ s.startedLock.Lock()
+ defer s.startedLock.Unlock()
+
+ if s.started {
+ return fmt.Errorf("informer has already started")
+ }
+
+ listener := newProcessListener(handler)
+ s.processor.listeners = append(s.processor.listeners, listener)
+ return nil
+}
+
+func (s *sharedIndexInformer) HandleDeltas(obj interface{}) error {
+ // from oldest to newest
+ for _, d := range obj.(cache.Deltas) {
+ switch d.Type {
+ case cache.Sync, cache.Added, cache.Updated:
+ if old, exists, err := s.indexer.Get(d.Object); err == nil && exists {
+ if err := s.indexer.Update(d.Object); err != nil {
+ return err
+ }
+ s.processor.distribute(updateNotification{oldObj: old, newObj: d.Object})
+ } else {
+ if err := s.indexer.Add(d.Object); err != nil {
+ return err
+ }
+ s.processor.distribute(addNotification{newObj: d.Object})
+ }
+ case cache.Deleted:
+ if err := s.indexer.Delete(d.Object); err != nil {
+ return err
+ }
+ s.processor.distribute(deleteNotification{oldObj: d.Object})
+ }
+ }
+ return nil
+}
+
+type sharedProcessor struct {
+ listeners []*processorListener
+}
+
+func (p *sharedProcessor) distribute(obj interface{}) {
+ for _, listener := range p.listeners {
+ listener.add(obj)
+ }
+}
+
+func (p *sharedProcessor) run(stopCh <-chan struct{}) {
+ for _, listener := range p.listeners {
+ go listener.run(stopCh)
+ go listener.pop(stopCh)
+ }
+}
+
+type processorListener struct {
+ // lock/cond protects access to 'pendingNotifications'.
+ lock sync.RWMutex
+ cond sync.Cond
+
+ // pendingNotifications is an unbounded slice that holds all notifications not yet distributed
+ // there is one per listener, but a failing/stalled listener will have infinite pendingNotifications
+ // added until we OOM.
+ // TODO This is no worse that before, since reflectors were backed by unbounded DeltaFIFOs, but
+ // we should try to do something better
+ pendingNotifications []interface{}
+
+ nextCh chan interface{}
+
+ handler ResourceEventHandler
+}
+
+func newProcessListener(handler ResourceEventHandler) *processorListener {
+ ret := &processorListener{
+ pendingNotifications: []interface{}{},
+ nextCh: make(chan interface{}),
+ handler: handler,
+ }
+
+ ret.cond.L = &ret.lock
+ return ret
+}
+
+func (p *processorListener) add(notification interface{}) {
+ p.lock.Lock()
+ defer p.lock.Unlock()
+
+ p.pendingNotifications = append(p.pendingNotifications, notification)
+ p.cond.Broadcast()
+}
+
+func (p *processorListener) pop(stopCh <-chan struct{}) {
+ defer utilruntime.HandleCrash()
+
+ for {
+ blockingGet := func() (interface{}, bool) {
+ p.lock.Lock()
+ defer p.lock.Unlock()
+
+ for len(p.pendingNotifications) == 0 {
+ // check if we're shutdown
+ select {
+ case <-stopCh:
+ return nil, true
+ default:
+ }
+ p.cond.Wait()
+ }
+
+ nt := p.pendingNotifications[0]
+ p.pendingNotifications = p.pendingNotifications[1:]
+ return nt, false
+ }
+
+ notification, stopped := blockingGet()
+ if stopped {
+ return
+ }
+
+ select {
+ case <-stopCh:
+ return
+ case p.nextCh <- notification:
+ }
+ }
+}
+
+func (p *processorListener) run(stopCh <-chan struct{}) {
+ defer utilruntime.HandleCrash()
+
+ for {
+ var next interface{}
+ select {
+ case <-stopCh:
+ func() {
+ p.lock.Lock()
+ defer p.lock.Unlock()
+ p.cond.Broadcast()
+ }()
+ return
+ case next = <-p.nextCh:
+ }
+
+ switch notification := next.(type) {
+ case updateNotification:
+ p.handler.OnUpdate(notification.oldObj, notification.newObj)
+ case addNotification:
+ p.handler.OnAdd(notification.newObj)
+ case deleteNotification:
+ p.handler.OnDelete(notification.oldObj)
+ default:
+ utilruntime.HandleError(fmt.Errorf("unrecognized notification: %#v", next))
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/lookup_cache.go b/vendor/k8s.io/kubernetes/pkg/controller/lookup_cache.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/lookup_cache.go
rename to vendor/k8s.io/kubernetes/pkg/controller/lookup_cache.go
index 5d82908be01f3ed88f83311e92e8db0207cc720a..0333eff38ceb4103744515232d8455aac5fcfe09 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/lookup_cache.go
+++ b/vendor/k8s.io/kubernetes/pkg/controller/lookup_cache.go
@@ -72,6 +72,8 @@ func (c *MatchingCache) Add(labelObj objectWithMeta, selectorObj objectWithMeta)
// we need check in the external request to ensure the cache data is not dirty.
func (c *MatchingCache) GetMatchingObject(labelObj objectWithMeta) (controller interface{}, exists bool) {
key := keyFunc(labelObj)
+ // NOTE: we use Lock() instead of RLock() here because lru's Get() method also modifies state(
+ // it need update the least recently usage information). So we can not call it concurrently.
c.mutex.Lock()
defer c.mutex.Unlock()
return c.cache.Get(key)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/OWNERS b/vendor/k8s.io/kubernetes/pkg/conversion/OWNERS
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/conversion/OWNERS
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/cloner.go b/vendor/k8s.io/kubernetes/pkg/conversion/cloner.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/cloner.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/cloner.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/converter.go b/vendor/k8s.io/kubernetes/pkg/conversion/converter.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/converter.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/converter.go
index 19cd4bef9d2f9cc77d97c13f6b7d6123637549b2..e045dcd2f77c5634f9c449280471c196e45565ac 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/converter.go
+++ b/vendor/k8s.io/kubernetes/pkg/conversion/converter.go
@@ -40,6 +40,8 @@ type NameFunc func(t reflect.Type) string
var DefaultNameFunc = func(t reflect.Type) string { return t.Name() }
+type GenericConversionFunc func(a, b interface{}, scope Scope) (bool, error)
+
// Converter knows how to convert one type to another.
type Converter struct {
// Map from the conversion pair to a function which can
@@ -47,6 +49,11 @@ type Converter struct {
conversionFuncs ConversionFuncs
generatedConversionFuncs ConversionFuncs
+ // genericConversions are called during normal conversion to offer a "fast-path"
+ // that avoids all reflection. These methods are not called outside of the .Convert()
+ // method.
+ genericConversions []GenericConversionFunc
+
// Set of conversions that should be treated as a no-op
ignoredConversions map[typePair]struct{}
@@ -95,10 +102,18 @@ func NewConverter(nameFn NameFunc) *Converter {
inputFieldMappingFuncs: make(map[reflect.Type]FieldMappingFunc),
inputDefaultFlags: make(map[reflect.Type]FieldMatchingFlags),
}
- c.RegisterConversionFunc(ByteSliceCopy)
+ c.RegisterConversionFunc(Convert_Slice_byte_To_Slice_byte)
return c
}
+// AddGenericConversionFunc adds a function that accepts the ConversionFunc call pattern
+// (for two conversion types) to the converter. These functions are checked first during
+// a normal conversion, but are otherwise not called. Use AddConversionFuncs when registering
+// typed conversions.
+func (c *Converter) AddGenericConversionFunc(fn GenericConversionFunc) {
+ c.genericConversions = append(c.genericConversions, fn)
+}
+
// WithConversions returns a Converter that is a copy of c but with the additional
// fns merged on top.
func (c *Converter) WithConversions(fns ConversionFuncs) *Converter {
@@ -114,8 +129,12 @@ func (c *Converter) DefaultMeta(t reflect.Type) (FieldMatchingFlags, *Meta) {
}
}
-// ByteSliceCopy prevents recursing into every byte
-func ByteSliceCopy(in *[]byte, out *[]byte, s Scope) error {
+// Convert_Slice_byte_To_Slice_byte prevents recursing into every byte
+func Convert_Slice_byte_To_Slice_byte(in *[]byte, out *[]byte, s Scope) error {
+ if *in == nil {
+ *out = nil
+ return nil
+ }
*out = make([]byte, len(*in))
copy(*out, *in)
return nil
@@ -191,9 +210,6 @@ func (c ConversionFuncs) Merge(other ConversionFuncs) ConversionFuncs {
// Meta is supplied by Scheme, when it calls Convert.
type Meta struct {
- SrcVersion string
- DestVersion string
-
// KeyNameMapping is an optional function which may map the listed key (field name)
// into a source and destination value.
KeyNameMapping FieldMappingFunc
@@ -496,6 +512,15 @@ func (f FieldMatchingFlags) IsSet(flag FieldMatchingFlags) bool {
// it is not used by Convert() other than storing it in the scope.
// Not safe for objects with cyclic references!
func (c *Converter) Convert(src, dest interface{}, flags FieldMatchingFlags, meta *Meta) error {
+ if len(c.genericConversions) > 0 {
+ // TODO: avoid scope allocation
+ s := &scope{converter: c, flags: flags, meta: meta}
+ for _, fn := range c.genericConversions {
+ if ok, err := fn(src, dest, s); ok {
+ return err
+ }
+ }
+ }
return c.doConversion(src, dest, flags, meta, c.convert)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/deep_equal.go b/vendor/k8s.io/kubernetes/pkg/conversion/deep_equal.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/deep_equal.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/deep_equal.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/doc.go b/vendor/k8s.io/kubernetes/pkg/conversion/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/doc.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/helper.go b/vendor/k8s.io/kubernetes/pkg/conversion/helper.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/helper.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/helper.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/queryparams/convert.go b/vendor/k8s.io/kubernetes/pkg/conversion/queryparams/convert.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/queryparams/convert.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/queryparams/convert.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/queryparams/doc.go b/vendor/k8s.io/kubernetes/pkg/conversion/queryparams/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/queryparams/doc.go
rename to vendor/k8s.io/kubernetes/pkg/conversion/queryparams/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/OWNERS b/vendor/k8s.io/kubernetes/pkg/credentialprovider/OWNERS
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/OWNERS
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/config.go b/vendor/k8s.io/kubernetes/pkg/credentialprovider/config.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/config.go
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/config.go
index f03bd26c318931e144c975551ac06323b870912f..b80fa5945ca6decf6ab5c0fa72721440135c975a 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/config.go
+++ b/vendor/k8s.io/kubernetes/pkg/credentialprovider/config.go
@@ -46,6 +46,7 @@ type DockerConfigEntry struct {
Username string
Password string
Email string
+ Provider DockerConfigProvider
}
var (
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/doc.go b/vendor/k8s.io/kubernetes/pkg/credentialprovider/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/doc.go
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go b/vendor/k8s.io/kubernetes/pkg/credentialprovider/keyring.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/keyring.go
index 2378156dcd399f554a125d4f04817b0b7bfa82cf..eedbee5ad8f79134ef8795a02290e22e35d714d4 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go
+++ b/vendor/k8s.io/kubernetes/pkg/credentialprovider/keyring.go
@@ -24,9 +24,9 @@ import (
"sort"
"strings"
- docker "github.com/fsouza/go-dockerclient"
"github.com/golang/glog"
+ dockertypes "github.com/docker/engine-api/types"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/util/sets"
)
@@ -39,13 +39,13 @@ import (
// most specific match for a given image
// - iterating a map does not yield predictable results
type DockerKeyring interface {
- Lookup(image string) ([]docker.AuthConfiguration, bool)
+ Lookup(image string) ([]LazyAuthConfiguration, bool)
}
// BasicDockerKeyring is a trivial map-backed implementation of DockerKeyring
type BasicDockerKeyring struct {
index []string
- creds map[string][]docker.AuthConfiguration
+ creds map[string][]LazyAuthConfiguration
}
// lazyDockerKeyring is an implementation of DockerKeyring that lazily
@@ -54,17 +54,38 @@ type lazyDockerKeyring struct {
Providers []DockerConfigProvider
}
+// LazyAuthConfiguration wraps dockertypes.AuthConfig, potentially deferring its
+// binding. If Provider is non-nil, it will be used to obtain new credentials
+// by calling LazyProvide() on it.
+type LazyAuthConfiguration struct {
+ dockertypes.AuthConfig
+ Provider DockerConfigProvider
+}
+
+func DockerConfigEntryToLazyAuthConfiguration(ident DockerConfigEntry) LazyAuthConfiguration {
+ return LazyAuthConfiguration{
+ AuthConfig: dockertypes.AuthConfig{
+ Username: ident.Username,
+ Password: ident.Password,
+ Email: ident.Email,
+ },
+ }
+}
+
func (dk *BasicDockerKeyring) Add(cfg DockerConfig) {
if dk.index == nil {
dk.index = make([]string, 0)
- dk.creds = make(map[string][]docker.AuthConfiguration)
+ dk.creds = make(map[string][]LazyAuthConfiguration)
}
for loc, ident := range cfg {
- creds := docker.AuthConfiguration{
- Username: ident.Username,
- Password: ident.Password,
- Email: ident.Email,
+ var creds LazyAuthConfiguration
+ if ident.Provider != nil {
+ creds = LazyAuthConfiguration{
+ Provider: ident.Provider,
+ }
+ } else {
+ creds = DockerConfigEntryToLazyAuthConfiguration(ident)
}
value := loc
@@ -215,9 +236,9 @@ func urlsMatch(globUrl *url.URL, targetUrl *url.URL) (bool, error) {
// Lookup implements the DockerKeyring method for fetching credentials based on image name.
// Multiple credentials may be returned if there are multiple potentially valid credentials
// available. This allows for rotation.
-func (dk *BasicDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
+func (dk *BasicDockerKeyring) Lookup(image string) ([]LazyAuthConfiguration, bool) {
// range over the index as iterating over a map does not provide a predictable ordering
- ret := []docker.AuthConfiguration{}
+ ret := []LazyAuthConfiguration{}
for _, k := range dk.index {
// both k and image are schemeless URLs because even though schemes are allowed
// in the credential configurations, we remove them in Add.
@@ -239,12 +260,12 @@ func (dk *BasicDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration,
}
}
- return []docker.AuthConfiguration{}, false
+ return []LazyAuthConfiguration{}, false
}
// Lookup implements the DockerKeyring method for fetching credentials
// based on image name.
-func (dk *lazyDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
+func (dk *lazyDockerKeyring) Lookup(image string) ([]LazyAuthConfiguration, bool) {
keyring := &BasicDockerKeyring{}
for _, p := range dk.Providers {
@@ -255,11 +276,11 @@ func (dk *lazyDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, b
}
type FakeKeyring struct {
- auth []docker.AuthConfiguration
+ auth []LazyAuthConfiguration
ok bool
}
-func (f *FakeKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
+func (f *FakeKeyring) Lookup(image string) ([]LazyAuthConfiguration, bool) {
return f.auth, f.ok
}
@@ -268,9 +289,8 @@ type unionDockerKeyring struct {
keyrings []DockerKeyring
}
-func (k *unionDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
- authConfigs := []docker.AuthConfiguration{}
-
+func (k *unionDockerKeyring) Lookup(image string) ([]LazyAuthConfiguration, bool) {
+ authConfigs := []LazyAuthConfiguration{}
for _, subKeyring := range k.keyrings {
if subKeyring == nil {
continue
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/plugins.go b/vendor/k8s.io/kubernetes/pkg/credentialprovider/plugins.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/plugins.go
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/plugins.go
index cc29ffd83182154b472dc49a161201cdd3d9ee43..a871cc02bcd9b2dc34f3e8b52b6c2f19688aeada 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/plugins.go
+++ b/vendor/k8s.io/kubernetes/pkg/credentialprovider/plugins.go
@@ -38,7 +38,7 @@ func RegisterCredentialProvider(name string, provider DockerConfigProvider) {
if found {
glog.Fatalf("Credential provider %q was registered twice", name)
}
- glog.V(1).Infof("Registered credential provider %q", name)
+ glog.V(4).Infof("Registered credential provider %q", name)
providers[name] = provider
}
@@ -53,7 +53,7 @@ func NewDockerKeyring() DockerKeyring {
// introduce the notion of priorities for conflict resolution.
for name, provider := range providers {
if provider.Enabled() {
- glog.Infof("Registering credential provider: %v", name)
+ glog.V(4).Infof("Registering credential provider: %v", name)
keyring.Providers = append(keyring.Providers, provider)
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/provider.go b/vendor/k8s.io/kubernetes/pkg/credentialprovider/provider.go
similarity index 74%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/provider.go
rename to vendor/k8s.io/kubernetes/pkg/credentialprovider/provider.go
index f4f52c8fd88100ccbd45abe59520913ef6f58c07..215650392bd83f72170c5ddede115c2d98e2c391 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/provider.go
+++ b/vendor/k8s.io/kubernetes/pkg/credentialprovider/provider.go
@@ -22,6 +22,7 @@ import (
"sync"
"time"
+ dockertypes "github.com/docker/engine-api/types"
"github.com/golang/glog"
)
@@ -30,6 +31,19 @@ import (
type DockerConfigProvider interface {
Enabled() bool
Provide() DockerConfig
+ // LazyProvide() gets called after URL matches have been performed, so the
+ // location used as the key in DockerConfig would be redundant.
+ LazyProvide() *DockerConfigEntry
+}
+
+func LazyProvide(creds LazyAuthConfiguration) dockertypes.AuthConfig {
+ if creds.Provider != nil {
+ entry := *creds.Provider.LazyProvide()
+ return DockerConfigEntryToLazyAuthConfiguration(entry).AuthConfig
+ } else {
+ return creds.AuthConfig
+ }
+
}
// A DockerConfigProvider that simply reads the .dockercfg file
@@ -73,11 +87,21 @@ func (d *defaultDockerConfigProvider) Provide() DockerConfig {
return DockerConfig{}
}
+// LazyProvide implements dockerConfigProvider. Should never be called.
+func (d *defaultDockerConfigProvider) LazyProvide() *DockerConfigEntry {
+ return nil
+}
+
// Enabled implements dockerConfigProvider
func (d *CachingDockerConfigProvider) Enabled() bool {
return d.Provider.Enabled()
}
+// LazyProvide implements dockerConfigProvider. Should never be called.
+func (d *CachingDockerConfigProvider) LazyProvide() *DockerConfigEntry {
+ return nil
+}
+
// Provide implements dockerConfigProvider
func (d *CachingDockerConfigProvider) Provide() DockerConfig {
d.mu.Lock()
@@ -88,7 +112,7 @@ func (d *CachingDockerConfigProvider) Provide() DockerConfig {
return d.cacheDockerConfig
}
- glog.Infof("Refreshing cache for provider: %v", reflect.TypeOf(d.Provider).String())
+ glog.V(2).Infof("Refreshing cache for provider: %v", reflect.TypeOf(d.Provider).String())
d.cacheDockerConfig = d.Provider.Provide()
d.expiration = time.Now().Add(d.Lifetime)
return d.cacheDockerConfig
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fieldpath/doc.go b/vendor/k8s.io/kubernetes/pkg/fieldpath/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/fieldpath/doc.go
rename to vendor/k8s.io/kubernetes/pkg/fieldpath/doc.go
diff --git a/vendor/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go b/vendor/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go
new file mode 100644
index 0000000000000000000000000000000000000000..bede9b2c0bfa75764788abab5d2f5f8e11d56fed
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/fieldpath/fieldpath.go
@@ -0,0 +1,124 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 fieldpath
+
+import (
+ "fmt"
+ "math"
+ "strconv"
+ "strings"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/resource"
+)
+
+// formatMap formats map[string]string to a string.
+func FormatMap(m map[string]string) (fmtStr string) {
+ for key, value := range m {
+ fmtStr += fmt.Sprintf("%v=%q\n", key, value)
+ }
+ fmtStr = strings.TrimSuffix(fmtStr, "\n")
+
+ return
+}
+
+// ExtractFieldPathAsString extracts the field from the given object
+// and returns it as a string. The object must be a pointer to an
+// API type.
+//
+// Currently, this API is limited to supporting the fieldpaths:
+//
+// 1. metadata.name - The name of an API object
+// 2. metadata.namespace - The namespace of an API object
+func ExtractFieldPathAsString(obj interface{}, fieldPath string) (string, error) {
+ accessor, err := meta.Accessor(obj)
+ if err != nil {
+ return "", nil
+ }
+
+ switch fieldPath {
+ case "metadata.annotations":
+ return FormatMap(accessor.GetAnnotations()), nil
+ case "metadata.labels":
+ return FormatMap(accessor.GetLabels()), nil
+ case "metadata.name":
+ return accessor.GetName(), nil
+ case "metadata.namespace":
+ return accessor.GetNamespace(), nil
+ }
+
+ return "", fmt.Errorf("Unsupported fieldPath: %v", fieldPath)
+}
+
+// ExtractResourceValueByContainerName extracts the value of a resource
+// by providing container name
+func ExtractResourceValueByContainerName(fs *api.ResourceFieldSelector, pod *api.Pod, containerName string) (string, error) {
+ container, err := findContainerInPod(pod, containerName)
+ if err != nil {
+ return "", err
+ }
+ return ExtractContainerResourceValue(fs, container)
+}
+
+// ExtractContainerResourceValue extracts the value of a resource
+// in an already known container
+func ExtractContainerResourceValue(fs *api.ResourceFieldSelector, container *api.Container) (string, error) {
+ divisor := resource.Quantity{}
+ if divisor.Cmp(fs.Divisor) == 0 {
+ divisor = resource.MustParse("1")
+ } else {
+ divisor = fs.Divisor
+ }
+
+ switch fs.Resource {
+ case "limits.cpu":
+ return convertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
+ case "limits.memory":
+ return convertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
+ case "requests.cpu":
+ return convertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
+ case "requests.memory":
+ return convertResourceMemoryToString(container.Resources.Requests.Memory(), divisor)
+ }
+
+ return "", fmt.Errorf("Unsupported container resource : %v", fs.Resource)
+}
+
+// findContainerInPod finds a container by its name in the provided pod
+func findContainerInPod(pod *api.Pod, containerName string) (*api.Container, error) {
+ for _, container := range pod.Spec.Containers {
+ if container.Name == containerName {
+ return &container, nil
+ }
+ }
+ return nil, fmt.Errorf("container %s not found", containerName)
+}
+
+// convertResourceCPUTOString converts cpu value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceCPUToString(cpu *resource.Quantity, divisor resource.Quantity) (string, error) {
+ c := int64(math.Ceil(float64(cpu.MilliValue()) / float64(divisor.MilliValue())))
+ return strconv.FormatInt(c, 10), nil
+}
+
+// convertResourceMemoryToString converts memory value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceMemoryToString(memory *resource.Quantity, divisor resource.Quantity) (string, error) {
+ m := int64(math.Ceil(float64(memory.Value()) / float64(divisor.Value())))
+ return strconv.FormatInt(m, 10), nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/doc.go b/vendor/k8s.io/kubernetes/pkg/fields/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/doc.go
rename to vendor/k8s.io/kubernetes/pkg/fields/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/fields.go b/vendor/k8s.io/kubernetes/pkg/fields/fields.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/fields.go
rename to vendor/k8s.io/kubernetes/pkg/fields/fields.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/selector.go b/vendor/k8s.io/kubernetes/pkg/fields/selector.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/fields/selector.go
rename to vendor/k8s.io/kubernetes/pkg/fields/selector.go
diff --git a/vendor/k8s.io/kubernetes/pkg/httplog/doc.go b/vendor/k8s.io/kubernetes/pkg/httplog/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..99973e2d7ef0cf597e73d2b8566812be206e9bb2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/httplog/doc.go
@@ -0,0 +1,19 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 httplog contains a helper object and functions to maintain a log
+// along with an http response.
+package httplog
diff --git a/vendor/k8s.io/kubernetes/pkg/httplog/log.go b/vendor/k8s.io/kubernetes/pkg/httplog/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..d4530dbd8b8d84c9f052c4d06ac8de9f4191c076
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/httplog/log.go
@@ -0,0 +1,219 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 httplog
+
+import (
+ "bufio"
+ "fmt"
+ "net"
+ "net/http"
+ "runtime"
+ "time"
+
+ "github.com/golang/glog"
+)
+
+// Handler wraps all HTTP calls to delegate with nice logging.
+// delegate may use LogOf(w).Addf(...) to write additional info to
+// the per-request log message.
+//
+// Intended to wrap calls to your ServeMux.
+func Handler(delegate http.Handler, pred StacktracePred) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+ defer NewLogged(req, &w).StacktraceWhen(pred).Log()
+ delegate.ServeHTTP(w, req)
+ })
+}
+
+// StacktracePred returns true if a stacktrace should be logged for this status.
+type StacktracePred func(httpStatus int) (logStacktrace bool)
+
+type logger interface {
+ Addf(format string, data ...interface{})
+}
+
+// Add a layer on top of ResponseWriter, so we can track latency and error
+// message sources.
+//
+// TODO now that we're using go-restful, we shouldn't need to be wrapping
+// the http.ResponseWriter. We can recover panics from go-restful, and
+// the logging value is questionable.
+type respLogger struct {
+ hijacked bool
+ statusRecorded bool
+ status int
+ statusStack string
+ addedInfo string
+ startTime time.Time
+
+ req *http.Request
+ w http.ResponseWriter
+
+ logStacktracePred StacktracePred
+}
+
+// Simple logger that logs immediately when Addf is called
+type passthroughLogger struct{}
+
+// Addf logs info immediately.
+func (passthroughLogger) Addf(format string, data ...interface{}) {
+ glog.InfoDepth(1, fmt.Sprintf(format, data...))
+}
+
+// DefaultStacktracePred is the default implementation of StacktracePred.
+func DefaultStacktracePred(status int) bool {
+ return (status < http.StatusOK || status >= http.StatusInternalServerError) && status != http.StatusSwitchingProtocols
+}
+
+// NewLogged turns a normal response writer into a logged response writer.
+//
+// Usage:
+//
+// defer NewLogged(req, &w).StacktraceWhen(StatusIsNot(200, 202)).Log()
+//
+// (Only the call to Log() is deferred, so you can set everything up in one line!)
+//
+// Note that this *changes* your writer, to route response writing actions
+// through the logger.
+//
+// Use LogOf(w).Addf(...) to log something along with the response result.
+func NewLogged(req *http.Request, w *http.ResponseWriter) *respLogger {
+ if _, ok := (*w).(*respLogger); ok {
+ // Don't double-wrap!
+ panic("multiple NewLogged calls!")
+ }
+ rl := &respLogger{
+ startTime: time.Now(),
+ req: req,
+ w: *w,
+ logStacktracePred: DefaultStacktracePred,
+ }
+ *w = rl // hijack caller's writer!
+ return rl
+}
+
+// LogOf returns the logger hiding in w. If there is not an existing logger
+// then a passthroughLogger will be created which will log to stdout immediately
+// when Addf is called.
+func LogOf(req *http.Request, w http.ResponseWriter) logger {
+ if _, exists := w.(*respLogger); !exists {
+ pl := &passthroughLogger{}
+ return pl
+ }
+ if rl, ok := w.(*respLogger); ok {
+ return rl
+ }
+ panic("Unable to find or create the logger!")
+}
+
+// Unlogged returns the original ResponseWriter, or w if it is not our inserted logger.
+func Unlogged(w http.ResponseWriter) http.ResponseWriter {
+ if rl, ok := w.(*respLogger); ok {
+ return rl.w
+ }
+ return w
+}
+
+// StacktraceWhen sets the stacktrace logging predicate, which decides when to log a stacktrace.
+// There's a default, so you don't need to call this unless you don't like the default.
+func (rl *respLogger) StacktraceWhen(pred StacktracePred) *respLogger {
+ rl.logStacktracePred = pred
+ return rl
+}
+
+// StatusIsNot returns a StacktracePred which will cause stacktraces to be logged
+// for any status *not* in the given list.
+func StatusIsNot(statuses ...int) StacktracePred {
+ return func(status int) bool {
+ for _, s := range statuses {
+ if status == s {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+// Addf adds additional data to be logged with this request.
+func (rl *respLogger) Addf(format string, data ...interface{}) {
+ rl.addedInfo += "\n" + fmt.Sprintf(format, data...)
+}
+
+// Log is intended to be called once at the end of your request handler, via defer
+func (rl *respLogger) Log() {
+ latency := time.Since(rl.startTime)
+ if glog.V(2) {
+ if !rl.hijacked {
+ glog.InfoDepth(1, fmt.Sprintf("%s %s: (%v) %v%v%v [%s %s]", rl.req.Method, rl.req.RequestURI, latency, rl.status, rl.statusStack, rl.addedInfo, rl.req.Header["User-Agent"], rl.req.RemoteAddr))
+ } else {
+ glog.InfoDepth(1, fmt.Sprintf("%s %s: (%v) hijacked [%s %s]", rl.req.Method, rl.req.RequestURI, latency, rl.req.Header["User-Agent"], rl.req.RemoteAddr))
+ }
+ }
+}
+
+// Header implements http.ResponseWriter.
+func (rl *respLogger) Header() http.Header {
+ return rl.w.Header()
+}
+
+// Write implements http.ResponseWriter.
+func (rl *respLogger) Write(b []byte) (int, error) {
+ if !rl.statusRecorded {
+ rl.recordStatus(http.StatusOK) // Default if WriteHeader hasn't been called
+ }
+ return rl.w.Write(b)
+}
+
+// Flush implements http.Flusher even if the underlying http.Writer doesn't implement it.
+// Flush is used for streaming purposes and allows to flush buffered data to the client.
+func (rl *respLogger) Flush() {
+ if flusher, ok := rl.w.(http.Flusher); ok {
+ flusher.Flush()
+ } else if glog.V(2) {
+ glog.InfoDepth(1, fmt.Sprintf("Unable to convert %+v into http.Flusher", rl.w))
+ }
+}
+
+// WriteHeader implements http.ResponseWriter.
+func (rl *respLogger) WriteHeader(status int) {
+ rl.recordStatus(status)
+ rl.w.WriteHeader(status)
+}
+
+// Hijack implements http.Hijacker.
+func (rl *respLogger) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ rl.hijacked = true
+ return rl.w.(http.Hijacker).Hijack()
+}
+
+// CloseNotify implements http.CloseNotifier
+func (rl *respLogger) CloseNotify() <-chan bool {
+ return rl.w.(http.CloseNotifier).CloseNotify()
+}
+
+func (rl *respLogger) recordStatus(status int) {
+ rl.status = status
+ rl.statusRecorded = true
+ if rl.logStacktracePred(status) {
+ // Only log stacks for errors
+ stack := make([]byte, 50*1024)
+ stack = stack[:runtime.Stack(stack, false)]
+ rl.statusStack = "\n" + string(stack)
+ } else {
+ rl.statusStack = ""
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/OWNERS b/vendor/k8s.io/kubernetes/pkg/kubectl/OWNERS
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/kubectl/OWNERS
index 66431ddd0498cad346828ee3ba781b4d6c1960ed..60bc436d441bedef9e864db80c4a1b85fdd083b5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/OWNERS
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/OWNERS
@@ -4,4 +4,5 @@ assignees:
- deads2k
- janetkuo
- jlowdermilk
+ - pwittrock
- smarterclayton
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/apply.go b/vendor/k8s.io/kubernetes/pkg/kubectl/apply.go
similarity index 73%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/apply.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/apply.go
index 3149bcb29daa466a7e684c433cc67f8d828d0355..1836fc2507dceb8db0af5ee401532d04e7e42144 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/apply.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/apply.go
@@ -19,6 +19,7 @@ package kubectl
import (
"encoding/json"
+ "k8s.io/kubernetes/pkg/api/annotations"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/kubectl/resource"
"k8s.io/kubernetes/pkg/runtime"
@@ -28,23 +29,19 @@ type debugError interface {
DebugError() (msg string, args []interface{})
}
-// LastAppliedConfigAnnotation is the annotation used to store the previous
-// configuration of a resource for use in a three way diff by UpdateApplyAnnotation.
-const LastAppliedConfigAnnotation = kubectlAnnotationPrefix + "last-applied-configuration"
-
// GetOriginalConfiguration retrieves the original configuration of the object
// from the annotation, or nil if no annotation was found.
-func GetOriginalConfiguration(info *resource.Info) ([]byte, error) {
- annotations, err := info.Mapping.MetadataAccessor.Annotations(info.Object)
+func GetOriginalConfiguration(mapping *meta.RESTMapping, obj runtime.Object) ([]byte, error) {
+ annots, err := mapping.MetadataAccessor.Annotations(obj)
if err != nil {
return nil, err
}
- if annotations == nil {
+ if annots == nil {
return nil, nil
}
- original, ok := annotations[LastAppliedConfigAnnotation]
+ original, ok := annots[annotations.LastAppliedConfigAnnotation]
if !ok {
return nil, nil
}
@@ -60,17 +57,17 @@ func SetOriginalConfiguration(info *resource.Info, original []byte) error {
}
accessor := info.Mapping.MetadataAccessor
- annotations, err := accessor.Annotations(info.Object)
+ annots, err := accessor.Annotations(info.Object)
if err != nil {
return err
}
- if annotations == nil {
- annotations = map[string]string{}
+ if annots == nil {
+ annots = map[string]string{}
}
- annotations[LastAppliedConfigAnnotation] = string(original)
- if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annotations); err != nil {
+ annots[annotations.LastAppliedConfigAnnotation] = string(original)
+ if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
return err
}
@@ -93,14 +90,14 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
}
// Get the current annotations from the object.
- annotations := accessor.GetAnnotations()
- if annotations == nil {
- annotations = map[string]string{}
+ annots := accessor.GetAnnotations()
+ if annots == nil {
+ annots = map[string]string{}
}
- original := annotations[LastAppliedConfigAnnotation]
- delete(annotations, LastAppliedConfigAnnotation)
- accessor.SetAnnotations(annotations)
+ original := annots[annotations.LastAppliedConfigAnnotation]
+ delete(annots, annotations.LastAppliedConfigAnnotation)
+ accessor.SetAnnotations(annots)
// TODO: this needs to be abstracted - there should be no assumption that versioned object
// can be marshalled to JSON.
modified, err = json.Marshal(info.VersionedObject)
@@ -109,8 +106,8 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
}
if annotate {
- annotations[LastAppliedConfigAnnotation] = string(modified)
- accessor.SetAnnotations(annotations)
+ annots[annotations.LastAppliedConfigAnnotation] = string(modified)
+ accessor.SetAnnotations(annots)
// TODO: this needs to be abstracted - there should be no assumption that versioned object
// can be marshalled to JSON.
modified, err = json.Marshal(info.VersionedObject)
@@ -120,24 +117,24 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
}
// Restore the object to its original condition.
- annotations[LastAppliedConfigAnnotation] = original
- accessor.SetAnnotations(annotations)
+ annots[annotations.LastAppliedConfigAnnotation] = original
+ accessor.SetAnnotations(annots)
} else {
// Otherwise, use the server side version of the object.
accessor := info.Mapping.MetadataAccessor
// Get the current annotations from the object.
- annotations, err := accessor.Annotations(info.Object)
+ annots, err := accessor.Annotations(info.Object)
if err != nil {
return nil, err
}
- if annotations == nil {
- annotations = map[string]string{}
+ if annots == nil {
+ annots = map[string]string{}
}
- original := annotations[LastAppliedConfigAnnotation]
- delete(annotations, LastAppliedConfigAnnotation)
- if err := accessor.SetAnnotations(info.Object, annotations); err != nil {
+ original := annots[annotations.LastAppliedConfigAnnotation]
+ delete(annots, annotations.LastAppliedConfigAnnotation)
+ if err := accessor.SetAnnotations(info.Object, annots); err != nil {
return nil, err
}
@@ -147,8 +144,8 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
}
if annotate {
- annotations[LastAppliedConfigAnnotation] = string(modified)
- if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annotations); err != nil {
+ annots[annotations.LastAppliedConfigAnnotation] = string(modified)
+ if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
return nil, err
}
@@ -159,8 +156,8 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
}
// Restore the object to its original condition.
- annotations[LastAppliedConfigAnnotation] = original
- if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annotations); err != nil {
+ annots[annotations.LastAppliedConfigAnnotation] = original
+ if err := info.Mapping.MetadataAccessor.SetAnnotations(info.Object, annots); err != nil {
return nil, err
}
}
@@ -171,7 +168,7 @@ func GetModifiedConfiguration(info *resource.Info, annotate bool, codec runtime.
// UpdateApplyAnnotation calls CreateApplyAnnotation if the last applied
// configuration annotation is already present. Otherwise, it does nothing.
func UpdateApplyAnnotation(info *resource.Info, codec runtime.Encoder) error {
- if original, err := GetOriginalConfiguration(info); err != nil || len(original) <= 0 {
+ if original, err := GetOriginalConfiguration(info.Mapping, info.Object); err != nil || len(original) <= 0 {
return err
}
return CreateApplyAnnotation(info, codec)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/autoscale.go b/vendor/k8s.io/kubernetes/pkg/kubectl/autoscale.go
similarity index 67%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/autoscale.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/autoscale.go
index e831bca70ca3c722573edb23a77e0b51a227b5cd..979a93bf0f0f40e9f8eb67d18381148d35886330 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/autoscale.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/autoscale.go
@@ -21,14 +21,10 @@ import (
"strconv"
"k8s.io/kubernetes/pkg/api"
- "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/autoscaling"
"k8s.io/kubernetes/pkg/runtime"
)
-const (
- scaleSubResource = "scale"
-)
-
type HorizontalPodAutoscalerV1Beta1 struct{}
func (HorizontalPodAutoscalerV1Beta1) ParamNames() []GeneratorParam {
@@ -46,6 +42,29 @@ func (HorizontalPodAutoscalerV1Beta1) ParamNames() []GeneratorParam {
}
func (HorizontalPodAutoscalerV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+ return generateHPA(genericParams)
+}
+
+type HorizontalPodAutoscalerV1 struct{}
+
+func (HorizontalPodAutoscalerV1) ParamNames() []GeneratorParam {
+ return []GeneratorParam{
+ {"default-name", true},
+ {"name", false},
+ {"scaleRef-kind", false},
+ {"scaleRef-name", false},
+ {"scaleRef-apiVersion", false},
+ {"min", false},
+ {"max", true},
+ {"cpu-percent", false},
+ }
+}
+
+func (HorizontalPodAutoscalerV1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+ return generateHPA(genericParams)
+}
+
+func generateHPA(genericParams map[string]interface{}) (runtime.Object, error) {
params := map[string]string{}
for key, value := range genericParams {
strVal, isString := value.(string)
@@ -86,25 +105,26 @@ func (HorizontalPodAutoscalerV1Beta1) Generate(genericParams map[string]interfac
}
}
- scaler := extensions.HorizontalPodAutoscaler{
+ scaler := autoscaling.HorizontalPodAutoscaler{
ObjectMeta: api.ObjectMeta{
Name: name,
},
- Spec: extensions.HorizontalPodAutoscalerSpec{
- ScaleRef: extensions.SubresourceReference{
- Kind: params["scaleRef-kind"],
- Name: params["scaleRef-name"],
- APIVersion: params["scaleRef-apiVersion"],
- Subresource: scaleSubResource,
+ Spec: autoscaling.HorizontalPodAutoscalerSpec{
+ ScaleTargetRef: autoscaling.CrossVersionObjectReference{
+ Kind: params["scaleRef-kind"],
+ Name: params["scaleRef-name"],
+ APIVersion: params["scaleRef-apiVersion"],
},
- MaxReplicas: max,
+ MaxReplicas: int32(max),
},
}
if min > 0 {
- scaler.Spec.MinReplicas = &min
+ v := int32(min)
+ scaler.Spec.MinReplicas = &v
}
if cpu >= 0 {
- scaler.Spec.CPUUtilization = &extensions.CPUTargetUtilization{cpu}
+ c := int32(cpu)
+ scaler.Spec.TargetCPUUtilizationPercentage = &c
}
return &scaler, nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go b/vendor/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go
index a89fef07a060daf8713ef4df053ea76958c558a9..e3eaf30e4bb7377f5fb56844b5843f76b3afa73c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/bash_comp_utils.go
@@ -28,7 +28,7 @@ import (
func AddJsonFilenameFlag(cmd *cobra.Command, value *[]string, usage string) {
cmd.Flags().StringSliceVarP(value, "filename", "f", *value, usage)
- annotations := []string{}
+ annotations := make([]string, 0, len(resource.FileExtensions))
for _, ext := range resource.FileExtensions {
annotations = append(annotations, strings.TrimLeft(ext, "."))
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/configmap.go b/vendor/k8s.io/kubernetes/pkg/kubectl/configmap.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/configmap.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/configmap.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go b/vendor/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go
index fb29a0a7ed28c57ca0505ab66cb82c8ec9a7544e..255ad1de84d1799e16399223d561d70529cce172 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/custom_column_printer.go
@@ -191,10 +191,10 @@ func (s *CustomColumnsPrinter) printOneObject(obj runtime.Object, parsers []*jso
columns := make([]string, len(parsers))
switch u := obj.(type) {
case *runtime.Unknown:
- if len(u.RawJSON) > 0 {
+ if len(u.Raw) > 0 {
var err error
- if obj, err = runtime.Decode(s.Decoder, u.RawJSON); err != nil {
- return fmt.Errorf("can't decode object for printing: %v (%s)", err, u.RawJSON)
+ if obj, err = runtime.Decode(s.Decoder, u.Raw); err != nil {
+ return fmt.Errorf("can't decode object for printing: %v (%s)", err, u.Raw)
}
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/describe.go b/vendor/k8s.io/kubernetes/pkg/kubectl/describe.go
similarity index 76%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/describe.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/describe.go
index f0415c08a5c0c10e4babf954ab319e2d6c4b9931..faa0ef98d91e8deca3864603fa9d2136d1441900 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/describe.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/describe.go
@@ -29,15 +29,19 @@ import (
"time"
"github.com/golang/glog"
+ "k8s.io/kubernetes/federation/apis/federation"
+ fed_clientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/apps"
"k8s.io/kubernetes/pkg/apis/autoscaling"
"k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
client "k8s.io/kubernetes/pkg/client/unversioned"
+ adapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset"
"k8s.io/kubernetes/pkg/fieldpath"
"k8s.io/kubernetes/pkg/fields"
qosutil "k8s.io/kubernetes/pkg/kubelet/qos/util"
@@ -52,7 +56,13 @@ import (
// if the output could not be generated. Implementers typically
// abstract the retrieval of the named object from a remote server.
type Describer interface {
- Describe(namespace, name string) (output string, err error)
+ Describe(namespace, name string, describerSettings DescriberSettings) (output string, err error)
+}
+
+// DescriberSettings holds display configuration for each object
+// describer to control what is printed.
+type DescriberSettings struct {
+ ShowEvents bool
}
// ObjectDescriber is an interface for displaying arbitrary objects with extra
@@ -93,11 +103,13 @@ func describerMap(c *client.Client) map[unversioned.GroupKind]Describer {
extensions.Kind("ReplicaSet"): &ReplicaSetDescriber{c},
extensions.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{c},
+ extensions.Kind("NetworkPolicy"): &NetworkPolicyDescriber{c},
autoscaling.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{c},
extensions.Kind("DaemonSet"): &DaemonSetDescriber{c},
- extensions.Kind("Deployment"): &DeploymentDescriber{clientset.FromUnversionedClient(c)},
+ extensions.Kind("Deployment"): &DeploymentDescriber{adapter.FromUnversionedClient(c)},
extensions.Kind("Job"): &JobDescriber{c},
batch.Kind("Job"): &JobDescriber{c},
+ apps.Kind("PetSet"): &PetSetDescriber{c},
extensions.Kind("Ingress"): &IngressDescriber{c},
}
@@ -148,7 +160,7 @@ type NamespaceDescriber struct {
client.Interface
}
-func (d *NamespaceDescriber) Describe(namespace, name string) (string, error) {
+func (d *NamespaceDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
ns, err := d.Namespaces().Get(name)
if err != nil {
return "", err
@@ -168,7 +180,7 @@ func (d *NamespaceDescriber) Describe(namespace, name string) (string, error) {
func describeNamespace(namespace *api.Namespace, resourceQuotaList *api.ResourceQuotaList, limitRangeList *api.LimitRangeList) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", namespace.Name)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(namespace.Labels))
+ printLabelsMultiline(out, "Labels", namespace.Labels)
fmt.Fprintf(out, "Status:\t%s\n", string(namespace.Status.Phase))
if resourceQuotaList != nil {
fmt.Fprintf(out, "\n")
@@ -268,7 +280,7 @@ func DescribeResourceQuotas(quotas *api.ResourceQuotaList, w io.Writer) {
for _, q := range quotas.Items {
fmt.Fprintf(w, "\n Name:\t%s\n", q.Name)
if len(q.Spec.Scopes) > 0 {
- scopes := []string{}
+ scopes := make([]string, 0, len(q.Spec.Scopes))
for _, scope := range q.Spec.Scopes {
scopes = append(scopes, string(scope))
}
@@ -285,7 +297,7 @@ func DescribeResourceQuotas(quotas *api.ResourceQuotaList, w io.Writer) {
fmt.Fprintf(w, " Resource\tUsed\tHard\n")
fmt.Fprint(w, " --------\t---\t---\n")
- resources := []api.ResourceName{}
+ resources := make([]api.ResourceName, 0, len(q.Status.Hard))
for resource := range q.Status.Hard {
resources = append(resources, resource)
}
@@ -304,7 +316,7 @@ type LimitRangeDescriber struct {
client.Interface
}
-func (d *LimitRangeDescriber) Describe(namespace, name string) (string, error) {
+func (d *LimitRangeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
lr := d.LimitRanges(namespace)
limitRange, err := lr.Get(name)
@@ -391,7 +403,7 @@ type ResourceQuotaDescriber struct {
client.Interface
}
-func (d *ResourceQuotaDescriber) Describe(namespace, name string) (string, error) {
+func (d *ResourceQuotaDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
rq := d.ResourceQuotas(namespace)
resourceQuota, err := rq.Get(name)
@@ -421,7 +433,7 @@ func describeQuota(resourceQuota *api.ResourceQuota) (string, error) {
fmt.Fprintf(out, "Name:\t%s\n", resourceQuota.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", resourceQuota.Namespace)
if len(resourceQuota.Spec.Scopes) > 0 {
- scopes := []string{}
+ scopes := make([]string, 0, len(resourceQuota.Spec.Scopes))
for _, scope := range resourceQuota.Spec.Scopes {
scopes = append(scopes, string(scope))
}
@@ -437,7 +449,7 @@ func describeQuota(resourceQuota *api.ResourceQuota) (string, error) {
fmt.Fprintf(out, "Resource\tUsed\tHard\n")
fmt.Fprintf(out, "--------\t----\t----\n")
- resources := []api.ResourceName{}
+ resources := make([]api.ResourceName, 0, len(resourceQuota.Status.Hard))
for resource := range resourceQuota.Status.Hard {
resources = append(resources, resource)
}
@@ -460,29 +472,33 @@ type PodDescriber struct {
client.Interface
}
-func (d *PodDescriber) Describe(namespace, name string) (string, error) {
+func (d *PodDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
pod, err := d.Pods(namespace).Get(name)
if err != nil {
- eventsInterface := d.Events(namespace)
- selector := eventsInterface.GetFieldSelector(&name, &namespace, nil, nil)
- options := api.ListOptions{FieldSelector: selector}
- events, err2 := eventsInterface.List(options)
- if err2 == nil && len(events.Items) > 0 {
- return tabbedString(func(out io.Writer) error {
- fmt.Fprintf(out, "Pod '%v': error '%v', but found events.\n", name, err)
- DescribeEvents(events, out)
- return nil
- })
+ if describerSettings.ShowEvents {
+ eventsInterface := d.Events(namespace)
+ selector := eventsInterface.GetFieldSelector(&name, &namespace, nil, nil)
+ options := api.ListOptions{FieldSelector: selector}
+ events, err2 := eventsInterface.List(options)
+ if describerSettings.ShowEvents && err2 == nil && len(events.Items) > 0 {
+ return tabbedString(func(out io.Writer) error {
+ fmt.Fprintf(out, "Pod '%v': error '%v', but found events.\n", name, err)
+ DescribeEvents(events, out)
+ return nil
+ })
+ }
}
return "", err
}
var events *api.EventList
- if ref, err := api.GetReference(pod); err != nil {
- glog.Errorf("Unable to construct reference to '%#v': %v", pod, err)
- } else {
- ref.Kind = ""
- events, _ = d.Events(namespace).Search(ref)
+ if describerSettings.ShowEvents {
+ if ref, err := api.GetReference(pod); err != nil {
+ glog.Errorf("Unable to construct reference to '%#v': %v", pod, err)
+ } else {
+ ref.Kind = ""
+ events, _ = d.Events(namespace).Search(ref)
+ }
}
return describePod(pod, events)
@@ -496,7 +512,7 @@ func describePod(pod *api.Pod, events *api.EventList) (string, error) {
if pod.Status.StartTime != nil {
fmt.Fprintf(out, "Start Time:\t%s\n", pod.Status.StartTime.Time.Format(time.RFC1123Z))
}
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(pod.Labels))
+ printLabelsMultiline(out, "Labels", pod.Labels)
if pod.DeletionTimestamp != nil {
fmt.Fprintf(out, "Status:\tTerminating (expires %s)\n", pod.DeletionTimestamp.Time.Format(time.RFC1123Z))
fmt.Fprintf(out, "Termination Grace Period:\t%ds\n", *pod.DeletionGracePeriodSeconds)
@@ -511,8 +527,10 @@ func describePod(pod *api.Pod, events *api.EventList) (string, error) {
}
fmt.Fprintf(out, "IP:\t%s\n", pod.Status.PodIP)
fmt.Fprintf(out, "Controllers:\t%s\n", printControllers(pod.Annotations))
- fmt.Fprintf(out, "Containers:\n")
- DescribeContainers(pod.Spec.Containers, pod.Status.ContainerStatuses, EnvValueRetriever(pod), out)
+ if len(pod.Spec.InitContainers) > 0 {
+ describeContainers("Init Containers", pod.Spec.InitContainers, pod.Status.InitContainerStatuses, EnvValueRetriever(pod), out, "")
+ }
+ describeContainers("Containers", pod.Spec.Containers, pod.Status.ContainerStatuses, EnvValueRetriever(pod), out, "")
if len(pod.Status.Conditions) > 0 {
fmt.Fprint(out, "Conditions:\n Type\tStatus\n")
for _, c := range pod.Status.Conditions {
@@ -521,7 +539,8 @@ func describePod(pod *api.Pod, events *api.EventList) (string, error) {
c.Status)
}
}
- describeVolumes(pod.Spec.Volumes, out)
+ describeVolumes(pod.Spec.Volumes, out, "")
+ fmt.Fprintf(out, "QoS Tier:\t%s\n", qosutil.GetPodQos(pod))
if events != nil {
DescribeEvents(events, out)
}
@@ -541,14 +560,19 @@ func printControllers(annotation map[string]string) string {
return "<none>"
}
-func describeVolumes(volumes []api.Volume, out io.Writer) {
+// TODO: Do a better job at indenting, maybe by using a prefix writer
+func describeVolumes(volumes []api.Volume, out io.Writer, space string) {
if volumes == nil || len(volumes) == 0 {
- fmt.Fprint(out, "No volumes.\n")
+ fmt.Fprintf(out, "%sNo volumes.\n", space)
return
}
- fmt.Fprint(out, "Volumes:\n")
+ fmt.Fprintf(out, "%sVolumes:\n", space)
for _, volume := range volumes {
- fmt.Fprintf(out, " %v:\n", volume.Name)
+ nameIndent := ""
+ if len(space) > 0 {
+ nameIndent = " "
+ }
+ fmt.Fprintf(out, " %s%v:\n", nameIndent, volume.Name)
switch {
case volume.VolumeSource.HostPath != nil:
printHostPathVolumeSource(volume.VolumeSource.HostPath, out)
@@ -677,7 +701,12 @@ func printRBDVolumeSource(rbd *api.RBDVolumeSource, out io.Writer) {
func printDownwardAPIVolumeSource(d *api.DownwardAPIVolumeSource, out io.Writer) {
fmt.Fprintf(out, " Type:\tDownwardAPI (a volume populated by information about the pod)\n Items:\n")
for _, mapping := range d.Items {
- fmt.Fprintf(out, " %v -> %v\n", mapping.FieldRef.FieldPath, mapping.Path)
+ if mapping.FieldRef != nil {
+ fmt.Fprintf(out, " %v -> %v\n", mapping.FieldRef.FieldPath, mapping.Path)
+ }
+ if mapping.ResourceFieldRef != nil {
+ fmt.Fprintf(out, " %v -> %v\n", mapping.ResourceFieldRef.Resource, mapping.Path)
+ }
}
}
@@ -685,7 +714,7 @@ type PersistentVolumeDescriber struct {
client.Interface
}
-func (d *PersistentVolumeDescriber) Describe(namespace, name string) (string, error) {
+func (d *PersistentVolumeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.PersistentVolumes()
pv, err := c.Get(name)
@@ -695,9 +724,14 @@ func (d *PersistentVolumeDescriber) Describe(namespace, name string) (string, er
storage := pv.Spec.Capacity[api.ResourceStorage]
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(pv)
+ }
+
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", pv.Name)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(pv.Labels))
+ printLabelsMultiline(out, "Labels", pv.Labels)
fmt.Fprintf(out, "Status:\t%s\n", pv.Status.Phase)
if pv.Spec.ClaimRef != nil {
fmt.Fprintf(out, "Claim:\t%s\n", pv.Spec.ClaimRef.Namespace+"/"+pv.Spec.ClaimRef.Name)
@@ -727,6 +761,10 @@ func (d *PersistentVolumeDescriber) Describe(namespace, name string) (string, er
printRBDVolumeSource(pv.Spec.RBD, out)
}
+ if events != nil {
+ DescribeEvents(events, out)
+ }
+
return nil
})
}
@@ -735,7 +773,7 @@ type PersistentVolumeClaimDescriber struct {
client.Interface
}
-func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string) (string, error) {
+func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.PersistentVolumeClaims(namespace)
pvc, err := c.Get(name)
@@ -743,7 +781,6 @@ func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string) (strin
return "", err
}
- labels := labels.FormatLabels(pvc.Labels)
storage := pvc.Spec.Resources.Requests[api.ResourceStorage]
capacity := ""
accessModes := ""
@@ -753,29 +790,42 @@ func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string) (strin
capacity = storage.String()
}
+ events, _ := d.Events(namespace).Search(pvc)
+
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", pvc.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", pvc.Namespace)
fmt.Fprintf(out, "Status:\t%v\n", pvc.Status.Phase)
fmt.Fprintf(out, "Volume:\t%s\n", pvc.Spec.VolumeName)
- fmt.Fprintf(out, "Labels:\t%s\n", labels)
+ printLabelsMultiline(out, "Labels", pvc.Labels)
fmt.Fprintf(out, "Capacity:\t%s\n", capacity)
fmt.Fprintf(out, "Access Modes:\t%s\n", accessModes)
+ if events != nil {
+ DescribeEvents(events, out)
+ }
+
return nil
})
}
-// DescribeContainers is exported for consumers in other API groups that have container templates
-func DescribeContainers(containers []api.Container, containerStatuses []api.ContainerStatus, resolverFn EnvVarResolverFunc, out io.Writer) {
+// TODO: Do a better job at indenting, maybe by using a prefix writer
+func describeContainers(label string, containers []api.Container, containerStatuses []api.ContainerStatus, resolverFn EnvVarResolverFunc, out io.Writer, space string) {
statuses := map[string]api.ContainerStatus{}
for _, status := range containerStatuses {
statuses[status.Name] = status
}
-
+ if len(containers) == 0 {
+ fmt.Fprintf(out, "%s%s: <none>\n", space, label)
+ } else {
+ fmt.Fprintf(out, "%s%s:\n", space, label)
+ }
for _, container := range containers {
status, ok := statuses[container.Name]
-
- fmt.Fprintf(out, " %v:\n", container.Name)
+ nameIndent := ""
+ if len(space) > 0 {
+ nameIndent = " "
+ }
+ fmt.Fprintf(out, " %s%v:\n", nameIndent, container.Name)
if ok {
fmt.Fprintf(out, " Container ID:\t%s\n", status.ContainerID)
}
@@ -803,25 +853,20 @@ func DescribeContainers(containers []api.Container, containerStatuses []api.Cont
}
}
- resourceToQoS := qosutil.GetQoS(&container)
- if len(resourceToQoS) > 0 {
- fmt.Fprintf(out, " QoS Tier:\n")
- }
- for resource, qos := range resourceToQoS {
- fmt.Fprintf(out, " %s:\t%s\n", resource, qos)
- }
-
- if len(container.Resources.Limits) > 0 {
+ resources := container.Resources
+ if len(resources.Limits) > 0 {
fmt.Fprintf(out, " Limits:\n")
}
- for name, quantity := range container.Resources.Limits {
+ for _, name := range SortedResourceNames(resources.Limits) {
+ quantity := resources.Limits[name]
fmt.Fprintf(out, " %s:\t%s\n", name, quantity.String())
}
- if len(container.Resources.Requests) > 0 {
+ if len(resources.Requests) > 0 {
fmt.Fprintf(out, " Requests:\n")
}
- for name, quantity := range container.Resources.Requests {
+ for _, name := range SortedResourceNames(resources.Requests) {
+ quantity := resources.Requests[name]
fmt.Fprintf(out, " %s:\t%s\n", name, quantity.String())
}
@@ -842,23 +887,41 @@ func DescribeContainers(containers []api.Container, containerStatuses []api.Cont
probe := DescribeProbe(container.ReadinessProbe)
fmt.Fprintf(out, " Readiness:\t%s\n", probe)
}
- fmt.Fprintf(out, " Environment Variables:\n")
+ none := ""
+ if len(container.Env) == 0 {
+ none = "\t<none>"
+ }
+ fmt.Fprintf(out, " Environment Variables:%s\n", none)
for _, e := range container.Env {
- if e.ValueFrom != nil && e.ValueFrom.FieldRef != nil {
+ if e.ValueFrom == nil {
+ fmt.Fprintf(out, " %s:\t%s\n", e.Name, e.Value)
+ continue
+ }
+
+ switch {
+ case e.ValueFrom.FieldRef != nil:
var valueFrom string
if resolverFn != nil {
valueFrom = resolverFn(e)
}
fmt.Fprintf(out, " %s:\t%s (%s:%s)\n", e.Name, valueFrom, e.ValueFrom.FieldRef.APIVersion, e.ValueFrom.FieldRef.FieldPath)
- } else {
- fmt.Fprintf(out, " %s:\t%s\n", e.Name, e.Value)
+ case e.ValueFrom.ResourceFieldRef != nil:
+ valueFrom, err := fieldpath.ExtractContainerResourceValue(e.ValueFrom.ResourceFieldRef, &container)
+ if err != nil {
+ valueFrom = ""
+ }
+ fmt.Fprintf(out, " %s:\t%s (%s)\n", e.Name, valueFrom, e.ValueFrom.ResourceFieldRef.Resource)
+ case e.ValueFrom.SecretKeyRef != nil:
+ fmt.Fprintf(out, " %s:\t<set to the key '%s' in secret '%s'>\n", e.Name, e.ValueFrom.SecretKeyRef.Key, e.ValueFrom.SecretKeyRef.Name)
+ case e.ValueFrom.ConfigMapKeyRef != nil:
+ fmt.Fprintf(out, " %s:\t<set to the key '%s' of config map '%s'>\n", e.Name, e.ValueFrom.ConfigMapKeyRef.Key, e.ValueFrom.ConfigMapKeyRef.Name)
}
}
}
}
func describeContainerPorts(cPorts []api.ContainerPort) string {
- ports := []string{}
+ ports := make([]string, 0, len(cPorts))
for _, cPort := range cPorts {
ports = append(ports, fmt.Sprintf("%d/%s", cPort.ContainerPort, cPort.Protocol))
}
@@ -949,7 +1012,7 @@ type ReplicationControllerDescriber struct {
client.Interface
}
-func (d *ReplicationControllerDescriber) Describe(namespace, name string) (string, error) {
+func (d *ReplicationControllerDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
rc := d.ReplicationControllers(namespace)
pc := d.Pods(namespace)
@@ -963,7 +1026,10 @@ func (d *ReplicationControllerDescriber) Describe(namespace, name string) (strin
return "", err
}
- events, _ := d.Events(namespace).Search(controller)
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(controller)
+ }
return describeReplicationController(controller, events, running, waiting, succeeded, failed)
}
@@ -978,11 +1044,11 @@ func describeReplicationController(controller *api.ReplicationController, events
fmt.Fprintf(out, "Image(s):\t%s\n", "<unset>")
}
fmt.Fprintf(out, "Selector:\t%s\n", labels.FormatLabels(controller.Spec.Selector))
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(controller.Labels))
+ printLabelsMultiline(out, "Labels", controller.Labels)
fmt.Fprintf(out, "Replicas:\t%d current / %d desired\n", controller.Status.Replicas, controller.Spec.Replicas)
fmt.Fprintf(out, "Pods Status:\t%d Running / %d Waiting / %d Succeeded / %d Failed\n", running, waiting, succeeded, failed)
if controller.Spec.Template != nil {
- describeVolumes(controller.Spec.Template.Spec.Volumes, out)
+ describeVolumes(controller.Spec.Template.Spec.Volumes, out, "")
}
if events != nil {
DescribeEvents(events, out)
@@ -991,18 +1057,23 @@ func describeReplicationController(controller *api.ReplicationController, events
})
}
-func DescribePodTemplate(template *api.PodTemplateSpec) (string, error) {
- return tabbedString(func(out io.Writer) error {
- if template == nil {
- fmt.Fprintf(out, "<unset>")
- return nil
- }
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(template.Labels))
- fmt.Fprintf(out, "Annotations:\t%s\n", labels.FormatLabels(template.Annotations))
- fmt.Fprintf(out, "Image(s):\t%s\n", makeImageList(&template.Spec))
- describeVolumes(template.Spec.Volumes, out)
- return nil
- })
+func DescribePodTemplate(template *api.PodTemplateSpec, out io.Writer) {
+ if template == nil {
+ fmt.Fprintf(out, " <unset>")
+ return
+ }
+ printLabelsMultiline(out, " Labels", template.Labels)
+ if len(template.Annotations) > 0 {
+ printLabelsMultiline(out, " Annotations", template.Annotations)
+ }
+ if len(template.Spec.ServiceAccountName) > 0 {
+ fmt.Fprintf(out, " Service Account:\t%s\n", template.Spec.ServiceAccountName)
+ }
+ if len(template.Spec.InitContainers) > 0 {
+ describeContainers("Init Containers", template.Spec.InitContainers, nil, nil, out, " ")
+ }
+ describeContainers("Containers", template.Spec.Containers, nil, nil, out, " ")
+ describeVolumes(template.Spec.Volumes, out, " ")
}
// ReplicaSetDescriber generates information about a ReplicaSet and the pods it has created.
@@ -1010,7 +1081,7 @@ type ReplicaSetDescriber struct {
client.Interface
}
-func (d *ReplicaSetDescriber) Describe(namespace, name string) (string, error) {
+func (d *ReplicaSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
rsc := d.Extensions().ReplicaSets(namespace)
pc := d.Pods(namespace)
@@ -1029,7 +1100,10 @@ func (d *ReplicaSetDescriber) Describe(namespace, name string) (string, error) {
return "", err
}
- events, _ := d.Events(namespace).Search(rs)
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(rs)
+ }
return describeReplicaSet(rs, events, running, waiting, succeeded, failed)
}
@@ -1040,10 +1114,10 @@ func describeReplicaSet(rs *extensions.ReplicaSet, events *api.EventList, runnin
fmt.Fprintf(out, "Namespace:\t%s\n", rs.Namespace)
fmt.Fprintf(out, "Image(s):\t%s\n", makeImageList(&rs.Spec.Template.Spec))
fmt.Fprintf(out, "Selector:\t%s\n", unversioned.FormatLabelSelector(rs.Spec.Selector))
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(rs.Labels))
+ printLabelsMultiline(out, "Labels", rs.Labels)
fmt.Fprintf(out, "Replicas:\t%d current / %d desired\n", rs.Status.Replicas, rs.Spec.Replicas)
fmt.Fprintf(out, "Pods Status:\t%d Running / %d Waiting / %d Succeeded / %d Failed\n", running, waiting, succeeded, failed)
- describeVolumes(rs.Spec.Template.Spec.Volumes, out)
+ describeVolumes(rs.Spec.Template.Spec.Volumes, out, "")
if events != nil {
DescribeEvents(events, out)
}
@@ -1056,18 +1130,21 @@ type JobDescriber struct {
client *client.Client
}
-func (d *JobDescriber) Describe(namespace, name string) (string, error) {
+func (d *JobDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
job, err := d.client.Extensions().Jobs(namespace).Get(name)
if err != nil {
return "", err
}
- events, _ := d.client.Events(namespace).Search(job)
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.client.Events(namespace).Search(job)
+ }
return describeJob(job, events)
}
-func describeJob(job *extensions.Job, events *api.EventList) (string, error) {
+func describeJob(job *batch.Job, events *api.EventList) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", job.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", job.Namespace)
@@ -1086,9 +1163,9 @@ func describeJob(job *extensions.Job, events *api.EventList) (string, error) {
if job.Spec.ActiveDeadlineSeconds != nil {
fmt.Fprintf(out, "Active Deadline Seconds:\t%ds\n", *job.Spec.ActiveDeadlineSeconds)
}
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(job.Labels))
+ printLabelsMultiline(out, "Labels", job.Labels)
fmt.Fprintf(out, "Pods Statuses:\t%d Running / %d Succeeded / %d Failed\n", job.Status.Active, job.Status.Succeeded, job.Status.Failed)
- describeVolumes(job.Spec.Template.Spec.Volumes, out)
+ describeVolumes(job.Spec.Template.Spec.Volumes, out, "")
if events != nil {
DescribeEvents(events, out)
}
@@ -1101,7 +1178,7 @@ type DaemonSetDescriber struct {
client.Interface
}
-func (d *DaemonSetDescriber) Describe(namespace, name string) (string, error) {
+func (d *DaemonSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
dc := d.Extensions().DaemonSets(namespace)
pc := d.Pods(namespace)
@@ -1119,7 +1196,10 @@ func (d *DaemonSetDescriber) Describe(namespace, name string) (string, error) {
return "", err
}
- events, _ := d.Events(namespace).Search(daemon)
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(daemon)
+ }
return describeDaemonSet(daemon, events, running, waiting, succeeded, failed)
}
@@ -1135,7 +1215,7 @@ func describeDaemonSet(daemon *extensions.DaemonSet, events *api.EventList, runn
}
fmt.Fprintf(out, "Selector:\t%s\n", selector)
fmt.Fprintf(out, "Node-Selector:\t%s\n", labels.FormatLabels(daemon.Spec.Template.Spec.NodeSelector))
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(daemon.Labels))
+ printLabelsMultiline(out, "Labels", daemon.Labels)
fmt.Fprintf(out, "Desired Number of Nodes Scheduled: %d\n", daemon.Status.DesiredNumberScheduled)
fmt.Fprintf(out, "Current Number of Nodes Scheduled: %d\n", daemon.Status.CurrentNumberScheduled)
fmt.Fprintf(out, "Number of Nodes Misscheduled: %d\n", daemon.Status.NumberMisscheduled)
@@ -1152,7 +1232,7 @@ type SecretDescriber struct {
client.Interface
}
-func (d *SecretDescriber) Describe(namespace, name string) (string, error) {
+func (d *SecretDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.Secrets(namespace)
secret, err := c.Get(name)
@@ -1167,8 +1247,8 @@ func describeSecret(secret *api.Secret) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", secret.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", secret.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(secret.Labels))
- fmt.Fprintf(out, "Annotations:\t%s\n", labels.FormatLabels(secret.Annotations))
+ printLabelsMultiline(out, "Labels", secret.Labels)
+ printLabelsMultiline(out, "Annotations", secret.Annotations)
fmt.Fprintf(out, "\nType:\t%s\n", secret.Type)
@@ -1190,13 +1270,13 @@ type IngressDescriber struct {
client.Interface
}
-func (i *IngressDescriber) Describe(namespace, name string) (string, error) {
+func (i *IngressDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := i.Extensions().Ingress(namespace)
ing, err := c.Get(name)
if err != nil {
return "", err
}
- return i.describeIngress(ing)
+ return i.describeIngress(ing, describerSettings)
}
func (i *IngressDescriber) describeBackend(ns string, backend *extensions.IngressBackend) string {
@@ -1211,7 +1291,7 @@ func (i *IngressDescriber) describeBackend(ns string, backend *extensions.Ingres
spName = sp.Name
}
case intstr.Int:
- if int(backend.ServicePort.IntVal) == sp.Port {
+ if int32(backend.ServicePort.IntVal) == sp.Port {
spName = sp.Name
}
}
@@ -1219,11 +1299,11 @@ func (i *IngressDescriber) describeBackend(ns string, backend *extensions.Ingres
return formatEndpoints(endpoints, sets.NewString(spName))
}
-func (i *IngressDescriber) describeIngress(ing *extensions.Ingress) (string, error) {
+func (i *IngressDescriber) describeIngress(ing *extensions.Ingress, describerSettings DescriberSettings) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%v\n", ing.Name)
fmt.Fprintf(out, "Namespace:\t%v\n", ing.Namespace)
- fmt.Fprintf(out, "Address:\t%v\n", loadBalancerStatusStringer(ing.Status.LoadBalancer))
+ fmt.Fprintf(out, "Address:\t%v\n", loadBalancerStatusStringer(ing.Status.LoadBalancer, true))
def := ing.Spec.Backend
ns := ing.Namespace
if def == nil {
@@ -1241,20 +1321,31 @@ func (i *IngressDescriber) describeIngress(ing *extensions.Ingress) (string, err
}
fmt.Fprint(out, "Rules:\n Host\tPath\tBackends\n")
fmt.Fprint(out, " ----\t----\t--------\n")
+ count := 0
for _, rules := range ing.Spec.Rules {
if rules.HTTP == nil {
continue
}
- fmt.Fprintf(out, " %s\t\n", rules.Host)
+ count++
+ host := rules.Host
+ if len(host) == 0 {
+ host = "*"
+ }
+ fmt.Fprintf(out, " %s\t\n", host)
for _, path := range rules.HTTP.Paths {
- fmt.Fprintf(out, " \t%s \t%s (%s)\n", path.Path, backendStringer(&path.Backend), i.describeBackend(ing.Namespace, &path.Backend))
+ fmt.Fprintf(out, " \t%s \t%s (%s)\n", path.Path, backendStringer(&path.Backend), i.describeBackend(ns, &path.Backend))
}
}
+ if count == 0 {
+ fmt.Fprintf(out, " %s\t%s \t%s (%s)\n", "*", "*", backendStringer(def), i.describeBackend(ns, def))
+ }
describeIngressAnnotations(out, ing.Annotations)
- events, _ := i.Events(ing.Namespace).Search(ing)
- if events != nil {
- DescribeEvents(events, out)
+ if describerSettings.ShowEvents {
+ events, _ := i.Events(ing.Namespace).Search(ing)
+ if events != nil {
+ DescribeEvents(events, out)
+ }
}
return nil
})
@@ -1291,7 +1382,7 @@ type ServiceDescriber struct {
client.Interface
}
-func (d *ServiceDescriber) Describe(namespace, name string) (string, error) {
+func (d *ServiceDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.Services(namespace)
service, err := c.Get(name)
@@ -1300,8 +1391,10 @@ func (d *ServiceDescriber) Describe(namespace, name string) (string, error) {
}
endpoints, _ := d.Endpoints(namespace).Get(name)
- events, _ := d.Events(namespace).Search(service)
-
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(service)
+ }
return describeService(service, endpoints, events)
}
@@ -1328,7 +1421,7 @@ func describeService(service *api.Service, endpoints *api.Endpoints, events *api
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", service.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", service.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(service.Labels))
+ printLabelsMultiline(out, "Labels", service.Labels)
fmt.Fprintf(out, "Selector:\t%s\n", labels.FormatLabels(service.Spec.Selector))
fmt.Fprintf(out, "Type:\t%s\n", service.Spec.Type)
fmt.Fprintf(out, "IP:\t%s\n", service.Spec.ClusterIP)
@@ -1362,7 +1455,7 @@ type EndpointsDescriber struct {
client.Interface
}
-func (d *EndpointsDescriber) Describe(namespace, name string) (string, error) {
+func (d *EndpointsDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.Endpoints(namespace)
ep, err := c.Get(name)
@@ -1370,7 +1463,10 @@ func (d *EndpointsDescriber) Describe(namespace, name string) (string, error) {
return "", err
}
- events, _ := d.Events(namespace).Search(ep)
+ var events *api.EventList
+ if describerSettings.ShowEvents {
+ events, _ = d.Events(namespace).Search(ep)
+ }
return describeEndpoints(ep, events)
}
@@ -1379,13 +1475,13 @@ func describeEndpoints(ep *api.Endpoints, events *api.EventList) (string, error)
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", ep.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", ep.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(ep.Labels))
+ printLabelsMultiline(out, "Labels", ep.Labels)
fmt.Fprintf(out, "Subsets:\n")
for i := range ep.Subsets {
subset := &ep.Subsets[i]
- addresses := []string{}
+ addresses := make([]string, 0, len(subset.Addresses))
for _, addr := range subset.Addresses {
addresses = append(addresses, addr.IP)
}
@@ -1395,7 +1491,7 @@ func describeEndpoints(ep *api.Endpoints, events *api.EventList) (string, error)
}
fmt.Fprintf(out, " Addresses:\t%s\n", addressesString)
- notReadyAddresses := []string{}
+ notReadyAddresses := make([]string, 0, len(subset.NotReadyAddresses))
for _, addr := range subset.NotReadyAddresses {
notReadyAddresses = append(notReadyAddresses, addr.IP)
}
@@ -1432,7 +1528,7 @@ type ServiceAccountDescriber struct {
client.Interface
}
-func (d *ServiceAccountDescriber) Describe(namespace, name string) (string, error) {
+func (d *ServiceAccountDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.ServiceAccounts(namespace)
serviceAccount, err := c.Get(name)
@@ -1462,7 +1558,7 @@ func describeServiceAccount(serviceAccount *api.ServiceAccount, tokens []api.Sec
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", serviceAccount.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", serviceAccount.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(serviceAccount.Labels))
+ printLabelsMultiline(out, "Labels", serviceAccount.Labels)
fmt.Fprintln(out)
var (
@@ -1513,7 +1609,7 @@ type NodeDescriber struct {
client.Interface
}
-func (d *NodeDescriber) Describe(namespace, name string) (string, error) {
+func (d *NodeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
mc := d.Nodes()
node, err := mc.Get(name)
if err != nil {
@@ -1536,12 +1632,14 @@ func (d *NodeDescriber) Describe(namespace, name string) (string, error) {
}
var events *api.EventList
- if ref, err := api.GetReference(node); err != nil {
- glog.Errorf("Unable to construct reference to '%#v': %v", node, err)
- } else {
- // TODO: We haven't decided the namespace for Node object yet.
- ref.UID = types.UID(ref.Name)
- events, _ = d.Events("").Search(ref)
+ if describerSettings.ShowEvents {
+ if ref, err := api.GetReference(node); err != nil {
+ glog.Errorf("Unable to construct reference to '%#v': %v", node, err)
+ } else {
+ // TODO: We haven't decided the namespace for Node object yet.
+ ref.UID = types.UID(ref.Name)
+ events, _ = d.Events("").Search(ref)
+ }
}
return describeNode(node, nodeNonTerminatedPodsList, events, canViewPods)
@@ -1550,7 +1648,8 @@ func (d *NodeDescriber) Describe(namespace, name string) (string, error) {
func describeNode(node *api.Node, nodeNonTerminatedPodsList *api.PodList, events *api.EventList, canViewPods bool) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", node.Name)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(node.Labels))
+ printLabelsMultiline(out, "Labels", node.Labels)
+ printTaintsInAnnotationMultiline(out, "Taints", node.Annotations)
fmt.Fprintf(out, "CreationTimestamp:\t%s\n", node.CreationTimestamp.Time.Format(time.RFC1123Z))
fmt.Fprintf(out, "Phase:\t%v\n", node.Status.Phase)
if len(node.Status.Conditions) > 0 {
@@ -1566,16 +1665,31 @@ func describeNode(node *api.Node, nodeNonTerminatedPodsList *api.PodList, events
c.Message)
}
}
- var addresses []string
+ addresses := make([]string, 0, len(node.Status.Addresses))
for _, address := range node.Status.Addresses {
addresses = append(addresses, address.Address)
}
+
+ printResourceList := func(resourceList api.ResourceList) {
+ resources := make([]api.ResourceName, 0, len(resourceList))
+ for resource := range resourceList {
+ resources = append(resources, resource)
+ }
+ sort.Sort(SortableResourceNames(resources))
+ for _, resource := range resources {
+ value := resourceList[resource]
+ fmt.Fprintf(out, " %s:\t%s\n", resource, value.String())
+ }
+ }
+
fmt.Fprintf(out, "Addresses:\t%s\n", strings.Join(addresses, ","))
if len(node.Status.Capacity) > 0 {
fmt.Fprintf(out, "Capacity:\n")
- for resource, value := range node.Status.Capacity {
- fmt.Fprintf(out, " %s:\t%s\n", resource, value.String())
- }
+ printResourceList(node.Status.Capacity)
+ }
+ if len(node.Status.Allocatable) > 0 {
+ fmt.Fprintf(out, "Allocatable:\n")
+ printResourceList(node.Status.Allocatable)
}
fmt.Fprintf(out, "System Info:\n")
@@ -1584,6 +1698,8 @@ func describeNode(node *api.Node, nodeNonTerminatedPodsList *api.PodList, events
fmt.Fprintf(out, " Boot ID:\t%s\n", node.Status.NodeInfo.BootID)
fmt.Fprintf(out, " Kernel Version:\t%s\n", node.Status.NodeInfo.KernelVersion)
fmt.Fprintf(out, " OS Image:\t%s\n", node.Status.NodeInfo.OSImage)
+ fmt.Fprintf(out, " Operating System:\t%s\n", node.Status.NodeInfo.OperatingSystem)
+ fmt.Fprintf(out, " Architecture:\t%s\n", node.Status.NodeInfo.Architecture)
fmt.Fprintf(out, " Container Runtime Version:\t%s\n", node.Status.NodeInfo.ContainerRuntimeVersion)
fmt.Fprintf(out, " Kubelet Version:\t%s\n", node.Status.NodeInfo.KubeletVersion)
fmt.Fprintf(out, " Kube-Proxy Version:\t%s\n", node.Status.NodeInfo.KubeProxyVersion)
@@ -1608,28 +1724,69 @@ func describeNode(node *api.Node, nodeNonTerminatedPodsList *api.PodList, events
})
}
+type PetSetDescriber struct {
+ client *client.Client
+}
+
+func (p *PetSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
+ ps, err := p.client.Apps().PetSets(namespace).Get(name)
+ if err != nil {
+ return "", err
+ }
+ pc := p.client.Pods(namespace)
+
+ selector, err := unversioned.LabelSelectorAsSelector(ps.Spec.Selector)
+ if err != nil {
+ return "", err
+ }
+
+ running, waiting, succeeded, failed, err := getPodStatusForController(pc, selector)
+ if err != nil {
+ return "", err
+ }
+
+ return tabbedString(func(out io.Writer) error {
+ fmt.Fprintf(out, "Name:\t%s\n", ps.Name)
+ fmt.Fprintf(out, "Namespace:\t%s\n", ps.Namespace)
+ fmt.Fprintf(out, "Image(s):\t%s\n", makeImageList(&ps.Spec.Template.Spec))
+ fmt.Fprintf(out, "Selector:\t%s\n", unversioned.FormatLabelSelector(ps.Spec.Selector))
+ fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(ps.Labels))
+ fmt.Fprintf(out, "Replicas:\t%d current / %d desired\n", ps.Status.Replicas, ps.Spec.Replicas)
+ fmt.Fprintf(out, "Annotations:\t%s\n", labels.FormatLabels(ps.Annotations))
+ fmt.Fprintf(out, "CreationTimestamp:\t%s\n", ps.CreationTimestamp.Time.Format(time.RFC1123Z))
+ fmt.Fprintf(out, "Pods Status:\t%d Running / %d Waiting / %d Succeeded / %d Failed\n", running, waiting, succeeded, failed)
+ describeVolumes(ps.Spec.Template.Spec.Volumes, out, "")
+ if describerSettings.ShowEvents {
+ events, _ := p.client.Events(namespace).Search(ps)
+ if events != nil {
+ DescribeEvents(events, out)
+ }
+ }
+ return nil
+ })
+}
+
// HorizontalPodAutoscalerDescriber generates information about a horizontal pod autoscaler.
type HorizontalPodAutoscalerDescriber struct {
client *client.Client
}
-func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string) (string, error) {
- hpa, err := d.client.Extensions().HorizontalPodAutoscalers(namespace).Get(name)
+func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
+ hpa, err := d.client.Autoscaling().HorizontalPodAutoscalers(namespace).Get(name)
if err != nil {
return "", err
}
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", hpa.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", hpa.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(hpa.Labels))
- fmt.Fprintf(out, "Annotations:\t%s\n", labels.FormatLabels(hpa.Annotations))
+ printLabelsMultiline(out, "Labels", hpa.Labels)
+ printLabelsMultiline(out, "Annotations", hpa.Annotations)
fmt.Fprintf(out, "CreationTimestamp:\t%s\n", hpa.CreationTimestamp.Time.Format(time.RFC1123Z))
- fmt.Fprintf(out, "Reference:\t%s/%s/%s\n",
- hpa.Spec.ScaleRef.Kind,
- hpa.Spec.ScaleRef.Name,
- hpa.Spec.ScaleRef.Subresource)
- if hpa.Spec.CPUUtilization != nil {
- fmt.Fprintf(out, "Target CPU utilization:\t%d%%\n", hpa.Spec.CPUUtilization.TargetPercentage)
+ fmt.Fprintf(out, "Reference:\t%s/%s\n",
+ hpa.Spec.ScaleTargetRef.Kind,
+ hpa.Spec.ScaleTargetRef.Name)
+ if hpa.Spec.TargetCPUUtilizationPercentage != nil {
+ fmt.Fprintf(out, "Target CPU utilization:\t%d%%\n", *hpa.Spec.TargetCPUUtilizationPercentage)
fmt.Fprintf(out, "Current CPU utilization:\t")
if hpa.Status.CurrentCPUUtilizationPercentage != nil {
fmt.Fprintf(out, "%d%%\n", *hpa.Status.CurrentCPUUtilizationPercentage)
@@ -1645,9 +1802,9 @@ func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string) (str
fmt.Fprintf(out, "Max replicas:\t%d\n", hpa.Spec.MaxReplicas)
// TODO: switch to scale subresource once the required code is submitted.
- if strings.ToLower(hpa.Spec.ScaleRef.Kind) == "replicationcontroller" {
+ if strings.ToLower(hpa.Spec.ScaleTargetRef.Kind) == "replicationcontroller" {
fmt.Fprintf(out, "ReplicationController pods:\t")
- rc, err := d.client.ReplicationControllers(hpa.Namespace).Get(hpa.Spec.ScaleRef.Name)
+ rc, err := d.client.ReplicationControllers(hpa.Namespace).Get(hpa.Spec.ScaleTargetRef.Name)
if err == nil {
fmt.Fprintf(out, "%d current / %d desired\n", rc.Status.Replicas, rc.Spec.Replicas)
} else {
@@ -1655,9 +1812,11 @@ func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string) (str
}
}
- events, _ := d.client.Events(namespace).Search(hpa)
- if events != nil {
- DescribeEvents(events, out)
+ if describerSettings.ShowEvents {
+ events, _ := d.client.Events(namespace).Search(hpa)
+ if events != nil {
+ DescribeEvents(events, out)
+ }
}
return nil
})
@@ -1667,32 +1826,37 @@ func describeNodeResource(nodeNonTerminatedPodsList *api.PodList, node *api.Node
fmt.Fprintf(out, "Non-terminated Pods:\t(%d in total)\n", len(nodeNonTerminatedPodsList.Items))
fmt.Fprint(out, " Namespace\tName\t\tCPU Requests\tCPU Limits\tMemory Requests\tMemory Limits\n")
fmt.Fprint(out, " ---------\t----\t\t------------\t----------\t---------------\t-------------\n")
+ allocatable := node.Status.Capacity
+ if len(node.Status.Allocatable) > 0 {
+ allocatable = node.Status.Allocatable
+ }
+
for _, pod := range nodeNonTerminatedPodsList.Items {
req, limit, err := api.PodRequestsAndLimits(&pod)
if err != nil {
return err
}
cpuReq, cpuLimit, memoryReq, memoryLimit := req[api.ResourceCPU], limit[api.ResourceCPU], req[api.ResourceMemory], limit[api.ResourceMemory]
- fractionCpuReq := float64(cpuReq.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
- fractionCpuLimit := float64(cpuLimit.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
- fractionMemoryReq := float64(memoryReq.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
- fractionMemoryLimit := float64(memoryLimit.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
+ fractionCpuReq := float64(cpuReq.MilliValue()) / float64(allocatable.Cpu().MilliValue()) * 100
+ fractionCpuLimit := float64(cpuLimit.MilliValue()) / float64(allocatable.Cpu().MilliValue()) * 100
+ fractionMemoryReq := float64(memoryReq.Value()) / float64(allocatable.Memory().Value()) * 100
+ fractionMemoryLimit := float64(memoryLimit.Value()) / float64(allocatable.Memory().Value()) * 100
fmt.Fprintf(out, " %s\t%s\t\t%s (%d%%)\t%s (%d%%)\t%s (%d%%)\t%s (%d%%)\n", pod.Namespace, pod.Name,
cpuReq.String(), int64(fractionCpuReq), cpuLimit.String(), int64(fractionCpuLimit),
memoryReq.String(), int64(fractionMemoryReq), memoryLimit.String(), int64(fractionMemoryLimit))
}
- fmt.Fprint(out, "Allocated resources:\n (Total limits may be over 100%, i.e., overcommitted. More info: http://releases.k8s.io/HEAD/docs/user-guide/compute-resources.md)\n CPU Requests\tCPU Limits\tMemory Requests\tMemory Limits\n")
+ fmt.Fprint(out, "Allocated resources:\n (Total limits may be over 100 percent, i.e., overcommitted. More info: http://releases.k8s.io/HEAD/docs/user-guide/compute-resources.md)\n CPU Requests\tCPU Limits\tMemory Requests\tMemory Limits\n")
fmt.Fprint(out, " ------------\t----------\t---------------\t-------------\n")
reqs, limits, err := getPodsTotalRequestsAndLimits(nodeNonTerminatedPodsList)
if err != nil {
return err
}
cpuReqs, cpuLimits, memoryReqs, memoryLimits := reqs[api.ResourceCPU], limits[api.ResourceCPU], reqs[api.ResourceMemory], limits[api.ResourceMemory]
- fractionCpuReqs := float64(cpuReqs.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
- fractionCpuLimits := float64(cpuLimits.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
- fractionMemoryReqs := float64(memoryReqs.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
- fractionMemoryLimits := float64(memoryLimits.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
+ fractionCpuReqs := float64(cpuReqs.MilliValue()) / float64(allocatable.Cpu().MilliValue()) * 100
+ fractionCpuLimits := float64(cpuLimits.MilliValue()) / float64(allocatable.Cpu().MilliValue()) * 100
+ fractionMemoryReqs := float64(memoryReqs.Value()) / float64(allocatable.Memory().Value()) * 100
+ fractionMemoryLimits := float64(memoryLimits.Value()) / float64(allocatable.Memory().Value()) * 100
fmt.Fprintf(out, " %s (%d%%)\t%s (%d%%)\t%s (%d%%)\t%s (%d%%)\n",
cpuReqs.String(), int64(fractionCpuReqs), cpuLimits.String(), int64(fractionCpuLimits),
memoryReqs.String(), int64(fractionMemoryReqs), memoryLimits.String(), int64(fractionMemoryLimits))
@@ -1723,15 +1887,17 @@ func getPodsTotalRequestsAndLimits(podList *api.PodList) (reqs map[api.ResourceN
for podReqName, podReqValue := range podReqs {
if value, ok := reqs[podReqName]; !ok {
reqs[podReqName] = *podReqValue.Copy()
- } else if err = value.Add(podReqValue); err != nil {
- return nil, nil, err
+ } else {
+ value.Add(podReqValue)
+ reqs[podReqName] = value
}
}
for podLimitName, podLimitValue := range podLimits {
if value, ok := limits[podLimitName]; !ok {
limits[podLimitName] = *podLimitValue.Copy()
- } else if err = value.Add(podLimitValue); err != nil {
- return nil, nil, err
+ } else {
+ value.Add(podLimitValue)
+ limits[podLimitName] = value
}
}
}
@@ -1764,7 +1930,7 @@ type DeploymentDescriber struct {
clientset.Interface
}
-func (dd *DeploymentDescriber) Describe(namespace, name string) (string, error) {
+func (dd *DeploymentDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
d, err := dd.Extensions().Deployments(namespace).Get(name)
if err != nil {
return "", err
@@ -1777,7 +1943,7 @@ func (dd *DeploymentDescriber) Describe(namespace, name string) (string, error)
fmt.Fprintf(out, "Name:\t%s\n", d.ObjectMeta.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", d.ObjectMeta.Namespace)
fmt.Fprintf(out, "CreationTimestamp:\t%s\n", d.CreationTimestamp.Time.Format(time.RFC1123Z))
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(d.Labels))
+ printLabelsMultiline(out, "Labels", d.Labels)
fmt.Fprintf(out, "Selector:\t%s\n", selector)
fmt.Fprintf(out, "Replicas:\t%d updated | %d total | %d available | %d unavailable\n", d.Status.UpdatedReplicas, d.Spec.Replicas, d.Status.AvailableReplicas, d.Status.UnavailableReplicas)
fmt.Fprintf(out, "StrategyType:\t%s\n", d.Spec.Strategy.Type)
@@ -1786,21 +1952,20 @@ func (dd *DeploymentDescriber) Describe(namespace, name string) (string, error)
ru := d.Spec.Strategy.RollingUpdate
fmt.Fprintf(out, "RollingUpdateStrategy:\t%s max unavailable, %s max surge\n", ru.MaxUnavailable.String(), ru.MaxSurge.String())
}
- oldRSs, _, err := deploymentutil.GetOldReplicaSets(d, dd)
+ oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd)
if err == nil {
fmt.Fprintf(out, "OldReplicaSets:\t%s\n", printReplicaSetsByLabels(oldRSs))
- }
- newRS, err := deploymentutil.GetNewReplicaSet(d, dd)
- if err == nil {
var newRSs []*extensions.ReplicaSet
if newRS != nil {
newRSs = append(newRSs, newRS)
}
fmt.Fprintf(out, "NewReplicaSet:\t%s\n", printReplicaSetsByLabels(newRSs))
}
- events, err := dd.Core().Events(namespace).Search(d)
- if err == nil && events != nil {
- DescribeEvents(events, out)
+ if describerSettings.ShowEvents {
+ events, err := dd.Core().Events(namespace).Search(d)
+ if err == nil && events != nil {
+ DescribeEvents(events, out)
+ }
}
return nil
})
@@ -1836,7 +2001,7 @@ func getDaemonSetsForLabels(c client.DaemonSetInterface, labelsToMatch labels.La
func printReplicationControllersByLabels(matchingRCs []*api.ReplicationController) string {
// Format the matching RC's into strings.
- var rcStrings []string
+ rcStrings := make([]string, 0, len(matchingRCs))
for _, controller := range matchingRCs {
rcStrings = append(rcStrings, fmt.Sprintf("%s (%d/%d replicas created)", controller.Name, controller.Status.Replicas, controller.Spec.Replicas))
}
@@ -1850,7 +2015,7 @@ func printReplicationControllersByLabels(matchingRCs []*api.ReplicationControlle
func printReplicaSetsByLabels(matchingRSs []*extensions.ReplicaSet) string {
// Format the matching ReplicaSets into strings.
- var rsStrings []string
+ rsStrings := make([]string, 0, len(matchingRSs))
for _, rs := range matchingRSs {
rsStrings = append(rsStrings, fmt.Sprintf("%s (%d/%d replicas created)", rs.Name, rs.Status.Replicas, rs.Spec.Replicas))
}
@@ -1888,7 +2053,7 @@ type ConfigMapDescriber struct {
client.Interface
}
-func (d *ConfigMapDescriber) Describe(namespace, name string) (string, error) {
+func (d *ConfigMapDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
c := d.ConfigMaps(namespace)
configMap, err := c.Get(name)
@@ -1903,8 +2068,8 @@ func describeConfigMap(configMap *api.ConfigMap) (string, error) {
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "Name:\t%s\n", configMap.Name)
fmt.Fprintf(out, "Namespace:\t%s\n", configMap.Namespace)
- fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(configMap.Labels))
- fmt.Fprintf(out, "Annotations:\t%s\n", labels.FormatLabels(configMap.Annotations))
+ printLabelsMultiline(out, "Labels", configMap.Labels)
+ printLabelsMultiline(out, "Annotations", configMap.Annotations)
fmt.Fprintf(out, "\nData\n====\n")
for k, v := range configMap.Data {
@@ -1915,9 +2080,76 @@ func describeConfigMap(configMap *api.ConfigMap) (string, error) {
})
}
+type ClusterDescriber struct {
+ fed_clientset.Interface
+}
+
+func (d *ClusterDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
+ cluster, err := d.Federation().Clusters().Get(name)
+ if err != nil {
+ return "", err
+ }
+ return describeCluster(cluster)
+}
+
+func describeCluster(cluster *federation.Cluster) (string, error) {
+ return tabbedString(func(out io.Writer) error {
+ fmt.Fprintf(out, "Name:\t%s\n", cluster.Name)
+ fmt.Fprintf(out, "Labels:\t%s\n", labels.FormatLabels(cluster.Labels))
+
+ fmt.Fprintf(out, "ServerAddressByClientCIDRs:\n ClientCIDR\tServerAddress\n")
+ fmt.Fprintf(out, " ----\t----\n")
+ for _, cidrAddr := range cluster.Spec.ServerAddressByClientCIDRs {
+ fmt.Fprintf(out, " %v \t%v\n\n", cidrAddr.ClientCIDR, cidrAddr.ServerAddress)
+ }
+
+ if len(cluster.Status.Conditions) > 0 {
+ fmt.Fprint(out, "Conditions:\n Type\tStatus\tLastUpdateTime\tLastTransitionTime\tReason\tMessage\n")
+ fmt.Fprint(out, " ----\t------\t-----------------\t------------------\t------\t-------\n")
+ for _, c := range cluster.Status.Conditions {
+ fmt.Fprintf(out, " %v \t%v \t%s \t%s \t%v \t%v\n",
+ c.Type,
+ c.Status,
+ c.LastProbeTime.Time.Format(time.RFC1123Z),
+ c.LastTransitionTime.Time.Format(time.RFC1123Z),
+ c.Reason,
+ c.Message)
+ }
+ }
+ return nil
+ })
+}
+
+// NetworkPolicyDescriber generates information about a NetworkPolicy
+type NetworkPolicyDescriber struct {
+ client.Interface
+}
+
+func (d *NetworkPolicyDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {
+ c := d.Extensions().NetworkPolicies(namespace)
+
+ networkPolicy, err := c.Get(name)
+ if err != nil {
+ return "", err
+ }
+
+ return describeNetworkPolicy(networkPolicy)
+}
+
+func describeNetworkPolicy(networkPolicy *extensions.NetworkPolicy) (string, error) {
+ return tabbedString(func(out io.Writer) error {
+ fmt.Fprintf(out, "Name:\t%s\n", networkPolicy.Name)
+ fmt.Fprintf(out, "Namespace:\t%s\n", networkPolicy.Namespace)
+ printLabelsMultiline(out, "Labels", networkPolicy.Labels)
+ printLabelsMultiline(out, "Annotations", networkPolicy.Annotations)
+
+ return nil
+ })
+}
+
// newErrNoDescriber creates a new ErrNoDescriber with the names of the provided types.
func newErrNoDescriber(types ...reflect.Type) error {
- names := []string{}
+ names := make([]string, 0, len(types))
for _, t := range types {
names = append(names, t.String())
}
@@ -1956,7 +2188,7 @@ func (d *Describers) DescribeObject(exact interface{}, extra ...interface{}) (st
return fns[0].Describe(exact, extra...)
}
- types := []reflect.Type{}
+ types := make([]reflect.Type, 0, len(extra))
for _, obj := range extra {
types = append(types, reflect.TypeOf(obj))
}
@@ -1981,14 +2213,15 @@ func (d *Describers) Add(fns ...interface{}) error {
if ft.Kind() != reflect.Func {
return fmt.Errorf("expected func, got: %v", ft)
}
- if ft.NumIn() == 0 {
+ numIn := ft.NumIn()
+ if numIn == 0 {
return fmt.Errorf("expected at least one 'in' params, got: %v", ft)
}
if ft.NumOut() != 2 {
return fmt.Errorf("expected two 'out' params - (string, error), got: %v", ft)
}
- types := []reflect.Type{}
- for i := 0; i < ft.NumIn(); i++ {
+ types := make([]reflect.Type, 0, numIn)
+ for i := 0; i < numIn; i++ {
types = append(types, ft.In(i))
}
if ft.Out(0) != reflect.TypeOf(string("")) {
@@ -2054,3 +2287,74 @@ func (fn typeFunc) Describe(exact interface{}, extra ...interface{}) (string, er
}
return s, err
}
+
+// printLabelsMultiline prints multiple labels with a proper alignment.
+func printLabelsMultiline(out io.Writer, title string, labels map[string]string) {
+ printLabelsMultilineWithIndent(out, "", title, "\t", labels)
+}
+
+// printLabelsMultiline prints multiple labels with a user-defined alignment.
+func printLabelsMultilineWithIndent(out io.Writer, initialIndent, title, innerIndent string, labels map[string]string) {
+
+ fmt.Fprintf(out, "%s%s:%s", initialIndent, title, innerIndent)
+
+ if labels == nil || len(labels) == 0 {
+ fmt.Fprintln(out, "<none>")
+ return
+ }
+
+ // to print labels in the sorted order
+ keys := make([]string, 0, len(labels))
+ for key := range labels {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+
+ for i, key := range keys {
+ if i != 0 {
+ fmt.Fprint(out, initialIndent)
+ fmt.Fprint(out, innerIndent)
+ }
+ fmt.Fprintf(out, "%s=%s\n", key, labels[key])
+ i++
+ }
+}
+
+// printTaintsMultiline prints multiple taints with a proper alignment.
+func printTaintsInAnnotationMultiline(out io.Writer, title string, annotations map[string]string) {
+ taints, err := api.GetTaintsFromNodeAnnotations(annotations)
+ if err != nil {
+ taints = []api.Taint{}
+ }
+ printTaintsMultilineWithIndent(out, "", title, "\t", taints)
+}
+
+// printTaintsMultilineWithIndent prints multiple taints with a user-defined alignment.
+func printTaintsMultilineWithIndent(out io.Writer, initialIndent, title, innerIndent string, taints []api.Taint) {
+ fmt.Fprintf(out, "%s%s:%s", initialIndent, title, innerIndent)
+
+ if taints == nil || len(taints) == 0 {
+ fmt.Fprintln(out, "<none>")
+ return
+ }
+
+ // to print taints in the sorted order
+ keys := make([]string, 0, len(taints))
+ for _, taint := range taints {
+ keys = append(keys, taint.Key)
+ }
+ sort.Strings(keys)
+
+ for i, key := range keys {
+ for _, taint := range taints {
+ if taint.Key == key {
+ if i != 0 {
+ fmt.Fprint(out, initialIndent)
+ fmt.Fprint(out, innerIndent)
+ }
+ fmt.Fprintf(out, "%s=%s:%s\n", taint.Key, taint.Value, taint.Effect)
+ i++
+ }
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/doc.go b/vendor/k8s.io/kubernetes/pkg/kubectl/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/doc.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/explain.go b/vendor/k8s.io/kubernetes/pkg/kubectl/explain.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/explain.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/explain.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/generate.go b/vendor/k8s.io/kubernetes/pkg/kubectl/generate.go
similarity index 86%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/generate.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/generate.go
index 6a71b619d80ea3f18f1c02e581c5be59c1d0e9c9..ea254bcb54878594f7b432a902f2b1fcca63dbc0 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/generate.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/generate.go
@@ -134,6 +134,34 @@ func MakeParams(cmd *cobra.Command, params []GeneratorParam) map[string]interfac
return result
}
+func MakeProtocols(protocols map[string]string) string {
+ out := []string{}
+ for key, value := range protocols {
+ out = append(out, fmt.Sprintf("%s/%s", key, value))
+ }
+ return strings.Join(out, ",")
+}
+
+func ParseProtocols(protocols interface{}) (map[string]string, error) {
+ protocolsString, isString := protocols.(string)
+ if !isString {
+ return nil, fmt.Errorf("expected string, found %v", protocols)
+ }
+ if len(protocolsString) == 0 {
+ return nil, fmt.Errorf("no protocols passed")
+ }
+ portProtocolMap := map[string]string{}
+ protocolsSlice := strings.Split(protocolsString, ",")
+ for ix := range protocolsSlice {
+ portProtocol := strings.Split(protocolsSlice[ix], "/")
+ if len(portProtocol) != 2 {
+ return nil, fmt.Errorf("unexpected port protocol mapping: %s", protocolsSlice[ix])
+ }
+ portProtocolMap[portProtocol[0]] = portProtocol[1]
+ }
+ return portProtocolMap, nil
+}
+
func MakeLabels(labels map[string]string) string {
out := []string{}
for key, value := range labels {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/history.go b/vendor/k8s.io/kubernetes/pkg/kubectl/history.go
similarity index 75%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/history.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/history.go
index 37cb9e0b29a2e1f11bca3fad5bdb3c09058e152d..0e81ebf28195fd95336a31a6ae19f06a00723323 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/history.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/history.go
@@ -19,16 +19,15 @@ package kubectl
import (
"fmt"
"io"
- "sort"
- "strconv"
"k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
"k8s.io/kubernetes/pkg/runtime"
deploymentutil "k8s.io/kubernetes/pkg/util/deployment"
- "k8s.io/kubernetes/pkg/util/errors"
+ sliceutil "k8s.io/kubernetes/pkg/util/slice"
)
const (
@@ -67,15 +66,14 @@ func (h *DeploymentHistoryViewer) History(namespace, name string) (HistoryInfo,
if err != nil {
return historyInfo, fmt.Errorf("failed to retrieve deployment %s: %v", name, err)
}
- _, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, h.c)
+ _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, h.c)
if err != nil {
- return historyInfo, fmt.Errorf("failed to retrieve old replica sets from deployment %s: %v", name, err)
+ return historyInfo, fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", name, err)
}
- newRS, err := deploymentutil.GetNewReplicaSet(deployment, h.c)
- if err != nil {
- return historyInfo, fmt.Errorf("failed to retrieve new replica set from deployment %s: %v", name, err)
+ allRSs := allOldRSs
+ if newRS != nil {
+ allRSs = append(allRSs, newRS)
}
- allRSs := append(allOldRSs, newRS)
for _, rs := range allRSs {
v, err := deploymentutil.Revision(rs)
if err != nil {
@@ -86,7 +84,9 @@ func (h *DeploymentHistoryViewer) History(namespace, name string) (HistoryInfo,
if historyInfo.RevisionToTemplate[v].Annotations == nil {
historyInfo.RevisionToTemplate[v].Annotations = make(map[string]string)
}
- historyInfo.RevisionToTemplate[v].Annotations[ChangeCauseAnnotation] = changeCause
+ if len(changeCause) > 0 {
+ historyInfo.RevisionToTemplate[v].Annotations[ChangeCauseAnnotation] = changeCause
+ }
}
return historyInfo, nil
}
@@ -97,38 +97,32 @@ func PrintRolloutHistory(historyInfo HistoryInfo, resource, name string) (string
return fmt.Sprintf("No rollout history found in %s %q", resource, name), nil
}
// Sort the revisionToChangeCause map by revision
- var revisions []string
- for k := range historyInfo.RevisionToTemplate {
- revisions = append(revisions, strconv.FormatInt(k, 10))
+ revisions := make([]int64, 0, len(historyInfo.RevisionToTemplate))
+ for r := range historyInfo.RevisionToTemplate {
+ revisions = append(revisions, r)
}
- sort.Strings(revisions)
+ sliceutil.SortInts64(revisions)
return tabbedString(func(out io.Writer) error {
fmt.Fprintf(out, "%s %q:\n", resource, name)
fmt.Fprintf(out, "REVISION\tCHANGE-CAUSE\n")
- errs := []error{}
for _, r := range revisions {
// Find the change-cause of revision r
- r64, err := strconv.ParseInt(r, 10, 64)
- if err != nil {
- errs = append(errs, err)
- continue
- }
- changeCause := historyInfo.RevisionToTemplate[r64].Annotations[ChangeCauseAnnotation]
+ changeCause := historyInfo.RevisionToTemplate[r].Annotations[ChangeCauseAnnotation]
if len(changeCause) == 0 {
changeCause = "<none>"
}
- fmt.Fprintf(out, "%s\t%s\n", r, changeCause)
+ fmt.Fprintf(out, "%d\t%s\n", r, changeCause)
}
- return errors.NewAggregate(errs)
+ return nil
})
}
// getChangeCause returns the change-cause annotation of the input object
func getChangeCause(obj runtime.Object) string {
- meta, err := api.ObjectMetaFor(obj)
+ accessor, err := meta.Accessor(obj)
if err != nil {
return ""
}
- return meta.Annotations[ChangeCauseAnnotation]
+ return accessor.GetAnnotations()[ChangeCauseAnnotation]
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/interfaces.go b/vendor/k8s.io/kubernetes/pkg/kubectl/interfaces.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/interfaces.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/interfaces.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/kubectl.go b/vendor/k8s.io/kubernetes/pkg/kubectl/kubectl.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/kubectl.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/kubectl.go
index 39cd1681a2d7996c5381bbe345a058708489a200..9f5cb22ff8e52aa3ae6ec3530c145bbf539011f1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/kubectl.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/kubectl.go
@@ -34,7 +34,7 @@ const (
PossibleResourceTypes = `Possible resource types include (case insensitive): pods (po), services (svc), deployments,
replicasets (rs), replicationcontrollers (rc), nodes (no), events (ev), limitranges (limits),
persistentvolumes (pv), persistentvolumeclaims (pvc), resourcequotas (quota), namespaces (ns),
-serviceaccounts, ingresses (ing), horizontalpodautoscalers (hpa), daemonsets (ds), configmaps,
+serviceaccounts (sa), ingresses (ing), horizontalpodautoscalers (hpa), daemonsets (ds), configmaps,
componentstatuses (cs), endpoints (ep), and secrets.`
)
@@ -43,7 +43,7 @@ type NamespaceInfo struct {
}
func listOfImages(spec *api.PodSpec) []string {
- var images []string
+ images := make([]string, 0, len(spec.Containers))
for _, container := range spec.Containers {
images = append(images, container.Image)
}
@@ -54,6 +54,28 @@ func makeImageList(spec *api.PodSpec) string {
return strings.Join(listOfImages(spec), ",")
}
+func NewThirdPartyResourceMapper(gvs []unversioned.GroupVersion, gvks []unversioned.GroupVersionKind) (meta.RESTMapper, error) {
+ mapper := meta.NewDefaultRESTMapper(gvs, func(gv unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+ for ix := range gvs {
+ if gvs[ix].Group == gv.Group && gvs[ix].Version == gv.Version {
+ return &meta.VersionInterfaces{
+ ObjectConvertor: api.Scheme,
+ MetadataAccessor: meta.NewAccessor(),
+ }, nil
+ }
+ }
+ groupVersions := make([]string, 0, len(gvs))
+ for ix := range gvs {
+ groupVersions = append(groupVersions, gvs[ix].String())
+ }
+ return nil, fmt.Errorf("unsupported storage version: %s (valid: %s)", gv.String(), strings.Join(groupVersions, ", "))
+ })
+ for ix := range gvks {
+ mapper.Add(gvks[ix], meta.RESTScopeNamespace)
+ }
+ return mapper, nil
+}
+
// OutputVersionMapper is a RESTMapper that will prefer mappings that
// correspond to a preferred output version (if feasible)
type OutputVersionMapper struct {
@@ -138,6 +160,7 @@ var shortForms = map[string]string{
"quota": "resourcequotas",
"rc": "replicationcontrollers",
"rs": "replicasets",
+ "sa": "serviceaccounts",
"svc": "services",
}
@@ -152,6 +175,35 @@ func expandResourceShortcut(resource unversioned.GroupVersionResource) unversion
return resource
}
+// ResourceAliases returns the resource shortcuts and plural forms for the given resources.
+func ResourceAliases(rs []string) []string {
+ as := make([]string, 0, len(rs))
+ plurals := make(map[string]struct{}, len(rs))
+ for _, r := range rs {
+ var plural string
+ switch {
+ case r == "endpoints":
+ plural = r // exception. "endpoint" does not exist. Why?
+ case strings.HasSuffix(r, "y"):
+ plural = r[0:len(r)-1] + "ies"
+ case strings.HasSuffix(r, "s"):
+ plural = r + "es"
+ default:
+ plural = r + "s"
+ }
+ as = append(as, plural)
+
+ plurals[plural] = struct{}{}
+ }
+
+ for sf, r := range shortForms {
+ if _, found := plurals[r]; found {
+ as = append(as, sf)
+ }
+ }
+ return as
+}
+
// parseFileSource parses the source given. Acceptable formats include:
//
// 1. source-path: the basename will become the key name
@@ -177,7 +229,12 @@ func parseFileSource(source string) (keyName, filePath string, err error) {
// parseLiteralSource parses the source key=val pair
func parseLiteralSource(source string) (keyName, value string, err error) {
- items := strings.Split(source, "=")
+ // leading equal is invalid
+ if strings.Index(source, "=") == 0 {
+ return "", "", fmt.Errorf("invalid literal source %v, expected key=value", source)
+ }
+ // split after the first equal (so values can have the = character)
+ items := strings.SplitN(source, "=", 2)
if len(items) != 2 {
return "", "", fmt.Errorf("invalid literal source %v, expected key=value", source)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/namespace.go b/vendor/k8s.io/kubernetes/pkg/kubectl/namespace.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/namespace.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/namespace.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/proxy_server.go b/vendor/k8s.io/kubernetes/pkg/kubectl/proxy_server.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/proxy_server.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/proxy_server.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/builder.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/builder.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/builder.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/builder.go
index 7b7bc150402f2f7378d473e93d89569a761b684f..ae19557fd9af417eff2f6dc67a92df7b4204a744 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/builder.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/builder.go
@@ -36,6 +36,8 @@ import (
var FileExtensions = []string{".json", ".yaml", ".yml"}
var InputExtensions = append(FileExtensions, "stdin")
+const defaultHttpGetAttempts int = 3
+
// Builder provides convenience functions for taking arguments and parameters
// from the command line and converting them to a list of resources to iterate
// over using the Visitor interface.
@@ -69,6 +71,8 @@ type Builder struct {
singleResourceType bool
continueOnError bool
+ singular bool
+
export bool
schema validation.Schema
@@ -98,7 +102,7 @@ func (b *Builder) Schema(schema validation.Schema) *Builder {
// will cause an error.
// If ContinueOnError() is set prior to this method, objects on the path that are not
// recognized will be ignored (but logged at V(2)).
-func (b *Builder) FilenameParam(enforceNamespace bool, paths ...string) *Builder {
+func (b *Builder) FilenameParam(enforceNamespace, recursive bool, paths ...string) *Builder {
for _, s := range paths {
switch {
case s == "-":
@@ -109,9 +113,12 @@ func (b *Builder) FilenameParam(enforceNamespace bool, paths ...string) *Builder
b.errs = append(b.errs, fmt.Errorf("the URL passed to filename %q is not valid: %v", s, err))
continue
}
- b.URL(url)
+ b.URL(defaultHttpGetAttempts, url)
default:
- b.Path(s)
+ if !recursive {
+ b.singular = true
+ }
+ b.Path(recursive, s)
}
}
@@ -123,11 +130,12 @@ func (b *Builder) FilenameParam(enforceNamespace bool, paths ...string) *Builder
}
// URL accepts a number of URLs directly.
-func (b *Builder) URL(urls ...*url.URL) *Builder {
+func (b *Builder) URL(httpAttemptCount int, urls ...*url.URL) *Builder {
for _, u := range urls {
b.paths = append(b.paths, &URLVisitor{
- URL: u,
- StreamVisitor: NewStreamVisitor(nil, b.mapper, u.String(), b.schema),
+ URL: u,
+ StreamVisitor: NewStreamVisitor(nil, b.mapper, u.String(), b.schema),
+ HttpAttemptCount: httpAttemptCount,
})
}
return b
@@ -157,7 +165,7 @@ func (b *Builder) Stream(r io.Reader, name string) *Builder {
// FileVisitor is streaming the content to a StreamVisitor. If ContinueOnError() is set
// prior to this method being called, objects on the path that are unrecognized will be
// ignored (but logged at V(2)).
-func (b *Builder) Path(paths ...string) *Builder {
+func (b *Builder) Path(recursive bool, paths ...string) *Builder {
for _, p := range paths {
_, err := os.Stat(p)
if os.IsNotExist(err) {
@@ -169,7 +177,7 @@ func (b *Builder) Path(paths ...string) *Builder {
continue
}
- visitors, err := ExpandPathsToFileVisitors(b.mapper, p, false, FileExtensions, b.schema)
+ visitors, err := ExpandPathsToFileVisitors(b.mapper, p, recursive, FileExtensions, b.schema)
if err != nil {
b.errs = append(b.errs, fmt.Errorf("error reading %q: %v", p, err))
}
@@ -543,7 +551,12 @@ func (b *Builder) visitorResult() *Result {
// visit items specified by resource and name
if len(b.resourceTuples) != 0 {
- isSingular := len(b.resourceTuples) == 1
+ // if b.singular is false, this could be by default, so double-check length
+ // of resourceTuples to determine if in fact it is singular or not
+ isSingular := b.singular
+ if !isSingular {
+ isSingular = len(b.resourceTuples) == 1
+ }
if len(b.paths) != 0 {
return &Result{singular: isSingular, err: fmt.Errorf("when paths, URLs, or stdin is provided as input, you may not specify a resource by arguments as well")}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/doc.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/doc.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/helper.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/helper.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/helper.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/helper.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go
index 25fd97d90bd998773f5cbfc95e3094f6ccf1dc0f..1ca922a0517eec98e87aea2e418467be1256fed3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/mapper.go
@@ -22,6 +22,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata"
"k8s.io/kubernetes/pkg/runtime"
)
@@ -53,6 +54,20 @@ func (m *Mapper) InfoForData(data []byte, source string) (*Info, error) {
if err != nil {
return nil, fmt.Errorf("unable to decode %q: %v", source, err)
}
+ var obj runtime.Object
+ var versioned runtime.Object
+ if isThirdParty, gvkOut, err := thirdpartyresourcedata.IsThirdPartyObject(data, gvk); err != nil {
+ return nil, err
+ } else if isThirdParty {
+ obj, err = runtime.Decode(thirdpartyresourcedata.NewDecoder(nil, gvkOut.Kind), data)
+ versioned = obj
+ gvk = gvkOut
+ } else {
+ obj, versioned = versions.Last(), versions.First()
+ }
+ if err != nil {
+ return nil, fmt.Errorf("unable to decode %q: %v [%v]", source, err, gvk)
+ }
mapping, err := m.RESTMapping(gvk.GroupKind(), gvk.Version)
if err != nil {
return nil, fmt.Errorf("unable to recognize %q: %v", source, err)
@@ -63,10 +78,6 @@ func (m *Mapper) InfoForData(data []byte, source string) (*Info, error) {
return nil, fmt.Errorf("unable to connect to a server to handle %q: %v", mapping.Resource, err)
}
- // TODO: decoding the version object is convenient, but questionable. This is used by apply
- // and rolling-update today, but both of those cases should probably be requesting the raw
- // object and performing their own decoding.
- obj, versioned := versions.Last(), versions.First()
name, _ := mapping.MetadataAccessor.Name(obj)
namespace, _ := mapping.MetadataAccessor.Namespace(obj)
resourceVersion, _ := mapping.MetadataAccessor.ResourceVersion(obj)
@@ -87,7 +98,7 @@ func (m *Mapper) InfoForData(data []byte, source string) (*Info, error) {
// if the object cannot be introspected. Name and namespace will be set into Info
// if the mapping's MetadataAccessor can retrieve them.
func (m *Mapper) InfoForObject(obj runtime.Object, preferredGVKs []unversioned.GroupVersionKind) (*Info, error) {
- groupVersionKinds, err := m.ObjectKinds(obj)
+ groupVersionKinds, _, err := m.ObjectKinds(obj)
if err != nil {
return nil, fmt.Errorf("unable to get type info from the object %q: %v", reflect.TypeOf(obj), err)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/result.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/result.go
index 8d726ab7b732bb6cc60698114e0b833055b0da6e..562fc0cc3596e6069c5db41b5c2b73440fab6d59 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/result.go
@@ -24,6 +24,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/runtime"
utilerrors "k8s.io/kubernetes/pkg/util/errors"
"k8s.io/kubernetes/pkg/util/sets"
@@ -210,7 +211,7 @@ func (r *Result) Watch(resourceVersion string) (watch.Interface, error) {
// the objects as children, or if only a single Object is present, as that object. The provided
// version will be preferred as the conversion target, but the Object's mapping version will be
// used if that version is not present.
-func AsVersionedObject(infos []*Info, forceList bool, version string, encoder runtime.Encoder) (runtime.Object, error) {
+func AsVersionedObject(infos []*Info, forceList bool, version unversioned.GroupVersion, encoder runtime.Encoder) (runtime.Object, error) {
objects, err := AsVersionedObjects(infos, version, encoder)
if err != nil {
return nil, err
@@ -221,7 +222,7 @@ func AsVersionedObject(infos []*Info, forceList bool, version string, encoder ru
object = objects[0]
} else {
object = &api.List{Items: objects}
- converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion.Version)
+ converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion)
if err != nil {
return nil, err
}
@@ -233,7 +234,7 @@ func AsVersionedObject(infos []*Info, forceList bool, version string, encoder ru
// AsVersionedObjects converts a list of infos into versioned objects. The provided
// version will be preferred as the conversion target, but the Object's mapping version will be
// used if that version is not present.
-func AsVersionedObjects(infos []*Info, version string, encoder runtime.Encoder) ([]runtime.Object, error) {
+func AsVersionedObjects(infos []*Info, version unversioned.GroupVersion, encoder runtime.Encoder) ([]runtime.Object, error) {
objects := []runtime.Object{}
for _, info := range infos {
if info.Object == nil {
@@ -241,22 +242,28 @@ func AsVersionedObjects(infos []*Info, version string, encoder runtime.Encoder)
}
// TODO: use info.VersionedObject as the value?
+ switch obj := info.Object.(type) {
+ case *extensions.ThirdPartyResourceData:
+ objects = append(objects, &runtime.Unknown{Raw: obj.Data})
+ continue
+ }
// objects that are not part of api.Scheme must be converted to JSON
// TODO: convert to map[string]interface{}, attach to runtime.Unknown?
- if len(version) > 0 {
- if _, err := api.Scheme.ObjectKind(info.Object); runtime.IsNotRegisteredError(err) {
+ if !version.IsEmpty() {
+ if _, _, err := api.Scheme.ObjectKinds(info.Object); runtime.IsNotRegisteredError(err) {
// TODO: ideally this would encode to version, but we don't expose multiple codecs here.
data, err := runtime.Encode(encoder, info.Object)
if err != nil {
return nil, err
}
- objects = append(objects, &runtime.Unknown{RawJSON: data})
+ // TODO: Set ContentEncoding and ContentType.
+ objects = append(objects, &runtime.Unknown{Raw: data})
continue
}
}
- converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion().String())
+ converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion())
if err != nil {
return nil, err
}
@@ -267,10 +274,10 @@ func AsVersionedObjects(infos []*Info, version string, encoder runtime.Encoder)
// tryConvert attempts to convert the given object to the provided versions in order. This function assumes
// the object is in internal version.
-func tryConvert(convertor runtime.ObjectConvertor, object runtime.Object, versions ...string) (runtime.Object, error) {
+func tryConvert(convertor runtime.ObjectConvertor, object runtime.Object, versions ...unversioned.GroupVersion) (runtime.Object, error) {
var last error
for _, version := range versions {
- if len(version) == 0 {
+ if version.IsEmpty() {
return object, nil
}
obj, err := convertor.ConvertToVersion(object, version)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/selector.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/selector.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/selector.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/selector.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go
index 76569389c7dd62543e32fd042031b91bdc72506d..2430b312dc93856d2719ea56d9748157f9719372 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/resource/visitor.go
@@ -24,6 +24,7 @@ import (
"net/url"
"os"
"path/filepath"
+ "time"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
@@ -221,20 +222,67 @@ func ValidateSchema(data []byte, schema validation.Schema) error {
type URLVisitor struct {
URL *url.URL
*StreamVisitor
+ HttpAttemptCount int
}
func (v *URLVisitor) Visit(fn VisitorFunc) error {
- res, err := http.Get(v.URL.String())
+ body, err := readHttpWithRetries(httpgetImpl, time.Second, v.URL.String(), v.HttpAttemptCount)
if err != nil {
return err
}
- defer res.Body.Close()
- if res.StatusCode != 200 {
- return fmt.Errorf("unable to read URL %q, server reported %d %s", v.URL, res.StatusCode, res.Status)
+ defer body.Close()
+ v.StreamVisitor.Reader = body
+ return v.StreamVisitor.Visit(fn)
+}
+
+// readHttpWithRetries tries to http.Get the v.URL retries times before giving up.
+func readHttpWithRetries(get httpget, duration time.Duration, u string, attempts int) (io.ReadCloser, error) {
+ var err error
+ var body io.ReadCloser
+ if attempts <= 0 {
+ return nil, fmt.Errorf("http attempts must be greater than 0, was %d", attempts)
}
+ for i := 0; i < attempts; i++ {
+ var statusCode int
+ var status string
+ if i > 0 {
+ time.Sleep(duration)
+ }
- v.StreamVisitor.Reader = res.Body
- return v.StreamVisitor.Visit(fn)
+ // Try to get the URL
+ statusCode, status, body, err = get(u)
+
+ // Retry Errors
+ if err != nil {
+ continue
+ }
+
+ // Error - Set the error condition from the StatusCode
+ if statusCode != 200 {
+ err = fmt.Errorf("unable to read URL %q, server reported %s, status code=%d", u, status, statusCode)
+ }
+
+ if statusCode >= 500 && statusCode < 600 {
+ // Retry 500's
+ continue
+ } else {
+ // Don't retry other StatusCodes
+ break
+ }
+ }
+ return body, err
+}
+
+// httpget Defines function to retrieve a url and return the results. Exists for unit test stubbing.
+type httpget func(url string) (int, string, io.ReadCloser, error)
+
+// httpgetImpl Implements a function to retrieve a url and return the results.
+func httpgetImpl(url string) (int, string, io.ReadCloser, error) {
+ resp, err := http.Get(url)
+ if err != nil {
+ return 0, "", nil, err
+ }
+ return resp.StatusCode, resp.Status, resp.Body, nil
}
// DecoratedVisitor will invoke the decorators in order prior to invoking the visitor function
@@ -474,14 +522,15 @@ func (v *StreamVisitor) Visit(fn VisitorFunc) error {
}
return err
}
- ext.RawJSON = bytes.TrimSpace(ext.RawJSON)
- if len(ext.RawJSON) == 0 || bytes.Equal(ext.RawJSON, []byte("null")) {
+ // TODO: This needs to be able to handle object in other encodings and schemas.
+ ext.Raw = bytes.TrimSpace(ext.Raw)
+ if len(ext.Raw) == 0 || bytes.Equal(ext.Raw, []byte("null")) {
continue
}
- if err := ValidateSchema(ext.RawJSON, v.Schema); err != nil {
+ if err := ValidateSchema(ext.Raw, v.Schema); err != nil {
return fmt.Errorf("error validating %q: %v", v.Source, err)
}
- info, err := v.InfoForData(ext.RawJSON, v.Source)
+ info, err := v.InfoForData(ext.Raw, v.Source)
if err != nil {
if fnErr := fn(info, err); fnErr != nil {
return fnErr
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource_printer.go b/vendor/k8s.io/kubernetes/pkg/kubectl/resource_printer.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource_printer.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/resource_printer.go
index 7f9d4ab0ef7312855dd9d087228faddd19481e9b..54bc7b4e5dc9fd9a981c92342a927823c1ec8d39 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource_printer.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/resource_printer.go
@@ -32,10 +32,15 @@ import (
"github.com/ghodss/yaml"
"github.com/golang/glog"
+ "k8s.io/kubernetes/federation/apis/federation"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/apps"
+ "k8s.io/kubernetes/pkg/apis/autoscaling"
+ "k8s.io/kubernetes/pkg/apis/batch"
"k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/rbac"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/runtime"
utilerrors "k8s.io/kubernetes/pkg/util/errors"
@@ -49,6 +54,7 @@ const (
tabwriterPadding = 3
tabwriterPadChar = ' '
tabwriterFlags = 0
+ loadBalancerWidth = 16
)
// GetPrinter takes a format type, an optional format argument. It will return true
@@ -65,7 +71,8 @@ func GetPrinter(format, formatArgument string) (ResourcePrinter, bool, error) {
printer = &YAMLPrinter{}
case "name":
printer = &NamePrinter{
- Typer: runtime.ObjectTyperToTyper(api.Scheme),
+ // TODO: this is wrong, these should be provided as an argument to GetPrinter
+ Typer: api.Scheme,
Decoder: api.Codecs.UniversalDecoder(),
}
case "template", "go-template":
@@ -179,7 +186,7 @@ func (p *VersionedPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
if version.IsEmpty() {
continue
}
- converted, err := p.convertor.ConvertToVersion(obj, version.String())
+ converted, err := p.convertor.ConvertToVersion(obj, version)
if runtime.IsNotRegisteredError(err) {
continue
}
@@ -199,14 +206,12 @@ func (p *VersionedPrinter) HandledResources() []string {
// NamePrinter is an implementation of ResourcePrinter which outputs "resource/name" pair of an object.
type NamePrinter struct {
Decoder runtime.Decoder
- Typer runtime.Typer
+ Typer runtime.ObjectTyper
}
// PrintObj is an implementation of ResourcePrinter.PrintObj which decodes the object
// and print "resource/name" pair. If the object is a List, print all items in it.
func (p *NamePrinter) PrintObj(obj runtime.Object, w io.Writer) error {
- gvk, _, _ := p.Typer.ObjectKind(obj)
-
if meta.IsListType(obj) {
items, err := meta.ExtractList(obj)
if err != nil {
@@ -232,10 +237,9 @@ func (p *NamePrinter) PrintObj(obj runtime.Object, w io.Writer) error {
}
}
- if gvk != nil {
+ if gvks, _, err := p.Typer.ObjectKinds(obj); err == nil {
// TODO: this is wrong, it assumes that meta knows about all Kinds - should take a RESTMapper
- _, resource := meta.KindToResource(*gvk)
-
+ _, resource := meta.KindToResource(gvks[0])
fmt.Fprintf(w, "%s/%s\n", resource.Resource, name)
} else {
fmt.Fprintf(w, "<unknown>/%s\n", name)
@@ -255,6 +259,12 @@ type JSONPrinter struct {
// PrintObj is an implementation of ResourcePrinter.PrintObj which simply writes the object to the Writer.
func (p *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
+ switch obj := obj.(type) {
+ case *runtime.Unknown:
+ _, err := w.Write(obj.Raw)
+ return err
+ }
+
data, err := json.Marshal(obj)
if err != nil {
return err
@@ -281,6 +291,16 @@ type YAMLPrinter struct {
// PrintObj prints the data as YAML.
func (p *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
+ switch obj := obj.(type) {
+ case *runtime.Unknown:
+ data, err := yaml.JSONToYAML(obj.Raw)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data)
+ return err
+ }
+
output, err := yaml.Marshal(obj)
if err != nil {
return err
@@ -400,11 +420,12 @@ var replicationControllerColumns = []string{"NAME", "DESIRED", "CURRENT", "AGE"}
var replicaSetColumns = []string{"NAME", "DESIRED", "CURRENT", "AGE"}
var jobColumns = []string{"NAME", "DESIRED", "SUCCESSFUL", "AGE"}
var serviceColumns = []string{"NAME", "CLUSTER-IP", "EXTERNAL-IP", "PORT(S)", "AGE"}
-var ingressColumns = []string{"NAME", "RULE", "BACKEND", "ADDRESS", "AGE"}
+var ingressColumns = []string{"NAME", "HOSTS", "ADDRESS", "PORTS", "AGE"}
+var petSetColumns = []string{"NAME", "DESIRED", "CURRENT", "AGE"}
var endpointColumns = []string{"NAME", "ENDPOINTS", "AGE"}
var nodeColumns = []string{"NAME", "STATUS", "AGE"}
var daemonSetColumns = []string{"NAME", "DESIRED", "CURRENT", "NODE-SELECTOR", "AGE"}
-var eventColumns = []string{"FIRSTSEEN", "LASTSEEN", "COUNT", "NAME", "KIND", "SUBOBJECT", "TYPE", "REASON", "SOURCE", "MESSAGE"}
+var eventColumns = []string{"LASTSEEN", "FIRSTSEEN", "COUNT", "NAME", "KIND", "SUBOBJECT", "TYPE", "REASON", "SOURCE", "MESSAGE"}
var limitRangeColumns = []string{"NAME", "AGE"}
var resourceQuotaColumns = []string{"NAME", "AGE"}
var namespaceColumns = []string{"NAME", "STATUS", "AGE"}
@@ -414,11 +435,20 @@ var persistentVolumeColumns = []string{"NAME", "CAPACITY", "ACCESSMODES", "STATU
var persistentVolumeClaimColumns = []string{"NAME", "STATUS", "VOLUME", "CAPACITY", "ACCESSMODES", "AGE"}
var componentStatusColumns = []string{"NAME", "STATUS", "MESSAGE", "ERROR"}
var thirdPartyResourceColumns = []string{"NAME", "DESCRIPTION", "VERSION(S)"}
+var roleColumns = []string{"NAME", "AGE"}
+var roleBindingColumns = []string{"NAME", "AGE"}
+var clusterRoleColumns = []string{"NAME", "AGE"}
+var clusterRoleBindingColumns = []string{"NAME", "AGE"}
+
+// TODO: consider having 'KIND' for third party resource data
+var thirdPartyResourceDataColumns = []string{"NAME", "LABELS", "DATA"}
var horizontalPodAutoscalerColumns = []string{"NAME", "REFERENCE", "TARGET", "CURRENT", "MINPODS", "MAXPODS", "AGE"}
var withNamespacePrefixColumns = []string{"NAMESPACE"} // TODO(erictune): print cluster name too.
var deploymentColumns = []string{"NAME", "DESIRED", "CURRENT", "UP-TO-DATE", "AVAILABLE", "AGE"}
var configMapColumns = []string{"NAME", "DATA", "AGE"}
var podSecurityPolicyColumns = []string{"NAME", "PRIV", "CAPS", "VOLUMEPLUGINS", "SELINUX", "RUNASUSER"}
+var clusterColumns = []string{"NAME", "STATUS", "VERSION", "AGE"}
+var networkPolicyColumns = []string{"NAME", "POD-SELECTOR", "AGE"}
// addDefaultHandlers adds print handlers for default Kubernetes types.
func (h *HumanReadablePrinter) addDefaultHandlers() {
@@ -438,6 +468,8 @@ func (h *HumanReadablePrinter) addDefaultHandlers() {
h.Handler(serviceColumns, printServiceList)
h.Handler(ingressColumns, printIngress)
h.Handler(ingressColumns, printIngressList)
+ h.Handler(petSetColumns, printPetSet)
+ h.Handler(petSetColumns, printPetSetList)
h.Handler(endpointColumns, printEndpoints)
h.Handler(endpointColumns, printEndpointsList)
h.Handler(nodeColumns, printNode)
@@ -470,6 +502,20 @@ func (h *HumanReadablePrinter) addDefaultHandlers() {
h.Handler(configMapColumns, printConfigMapList)
h.Handler(podSecurityPolicyColumns, printPodSecurityPolicy)
h.Handler(podSecurityPolicyColumns, printPodSecurityPolicyList)
+ h.Handler(thirdPartyResourceDataColumns, printThirdPartyResourceData)
+ h.Handler(thirdPartyResourceDataColumns, printThirdPartyResourceDataList)
+ h.Handler(clusterColumns, printCluster)
+ h.Handler(clusterColumns, printClusterList)
+ h.Handler(networkPolicyColumns, printNetworkPolicy)
+ h.Handler(networkPolicyColumns, printNetworkPolicyList)
+ h.Handler(roleColumns, printRole)
+ h.Handler(roleColumns, printRoleList)
+ h.Handler(roleBindingColumns, printRoleBinding)
+ h.Handler(roleBindingColumns, printRoleBindingList)
+ h.Handler(clusterRoleColumns, printClusterRole)
+ h.Handler(clusterRoleColumns, printClusterRoleList)
+ h.Handler(clusterRoleBindingColumns, printClusterRoleBinding)
+ h.Handler(clusterRoleBindingColumns, printClusterRoleBindingList)
}
func (h *HumanReadablePrinter) unknown(data []byte, w io.Writer) error {
@@ -567,22 +613,51 @@ func printPodBase(pod *api.Pod, w io.Writer, options PrintOptions) error {
reason = pod.Status.Reason
}
- for i := len(pod.Status.ContainerStatuses) - 1; i >= 0; i-- {
- container := pod.Status.ContainerStatuses[i]
-
- restarts += container.RestartCount
- if container.State.Waiting != nil && container.State.Waiting.Reason != "" {
- reason = container.State.Waiting.Reason
- } else if container.State.Terminated != nil && container.State.Terminated.Reason != "" {
- reason = container.State.Terminated.Reason
- } else if container.State.Terminated != nil && container.State.Terminated.Reason == "" {
- if container.State.Terminated.Signal != 0 {
- reason = fmt.Sprintf("Signal:%d", container.State.Terminated.Signal)
+ initializing := false
+ for i := range pod.Status.InitContainerStatuses {
+ container := pod.Status.InitContainerStatuses[i]
+ switch {
+ case container.State.Terminated != nil && container.State.Terminated.ExitCode == 0:
+ continue
+ case container.State.Terminated != nil:
+ // initialization is failed
+ if len(container.State.Terminated.Reason) == 0 {
+ if container.State.Terminated.Signal != 0 {
+ reason = fmt.Sprintf("Init:Signal:%d", container.State.Terminated.Signal)
+ } else {
+ reason = fmt.Sprintf("Init:ExitCode:%d", container.State.Terminated.ExitCode)
+ }
} else {
- reason = fmt.Sprintf("ExitCode:%d", container.State.Terminated.ExitCode)
+ reason = "Init:" + container.State.Terminated.Reason
+ }
+ initializing = true
+ case container.State.Waiting != nil && len(container.State.Waiting.Reason) > 0 && container.State.Waiting.Reason != "PodInitializing":
+ reason = "Init:" + container.State.Waiting.Reason
+ initializing = true
+ default:
+ reason = fmt.Sprintf("Init:%d/%d", i, len(pod.Spec.InitContainers))
+ initializing = true
+ }
+ break
+ }
+ if !initializing {
+ for i := len(pod.Status.ContainerStatuses) - 1; i >= 0; i-- {
+ container := pod.Status.ContainerStatuses[i]
+
+ restarts += int(container.RestartCount)
+ if container.State.Waiting != nil && container.State.Waiting.Reason != "" {
+ reason = container.State.Waiting.Reason
+ } else if container.State.Terminated != nil && container.State.Terminated.Reason != "" {
+ reason = container.State.Terminated.Reason
+ } else if container.State.Terminated != nil && container.State.Terminated.Reason == "" {
+ if container.State.Terminated.Signal != 0 {
+ reason = fmt.Sprintf("Signal:%d", container.State.Terminated.Signal)
+ } else {
+ reason = fmt.Sprintf("ExitCode:%d", container.State.Terminated.ExitCode)
+ }
+ } else if container.Ready && container.State.Running != nil {
+ readyContainers++
}
- } else if container.Ready && container.State.Running != nil {
- readyContainers++
}
}
if pod.DeletionTimestamp != nil {
@@ -607,17 +682,22 @@ func printPodBase(pod *api.Pod, w io.Writer, options PrintOptions) error {
if options.Wide {
nodeName := pod.Spec.NodeName
- if _, err := fmt.Fprintf(w, "\t%s",
+ podIP := pod.Status.PodIP
+ if podIP == "" {
+ podIP = "<none>"
+ }
+ if _, err := fmt.Fprintf(w, "\t%s\t%s",
+ podIP,
nodeName,
); err != nil {
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(pod.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(pod.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, pod.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, pod.Labels)); err != nil {
return err
}
@@ -653,10 +733,10 @@ func printPodTemplate(pod *api.PodTemplate, w io.Writer, options PrintOptions) e
if _, err := fmt.Fprintf(w, "\t%s", labels.FormatLabels(pod.Template.Labels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(pod.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(pod.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, pod.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, pod.Labels)); err != nil {
return err
}
@@ -703,10 +783,10 @@ func printReplicationController(controller *api.ReplicationController, w io.Writ
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(controller.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(controller.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, controller.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, controller.Labels)); err != nil {
return err
}
@@ -751,10 +831,10 @@ func printReplicaSet(rs *extensions.ReplicaSet, w io.Writer, options PrintOption
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(rs.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(rs.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, rs.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, rs.Labels)); err != nil {
return err
}
@@ -770,7 +850,38 @@ func printReplicaSetList(list *extensions.ReplicaSetList, w io.Writer, options P
return nil
}
-func printJob(job *extensions.Job, w io.Writer, options PrintOptions) error {
+func printCluster(c *federation.Cluster, w io.Writer, options PrintOptions) error {
+ var statuses []string
+ for _, condition := range c.Status.Conditions {
+ if condition.Status == api.ConditionTrue {
+ statuses = append(statuses, string(condition.Type))
+ } else {
+ statuses = append(statuses, "Not"+string(condition.Type))
+ }
+ }
+ if len(statuses) == 0 {
+ statuses = append(statuses, "Unknown")
+ }
+
+ if _, err := fmt.Fprintf(w, "%s\t%s\t%s\n",
+ c.Name,
+ strings.Join(statuses, ","),
+ translateTimestamp(c.CreationTimestamp),
+ ); err != nil {
+ return err
+ }
+ return nil
+}
+func printClusterList(list *federation.ClusterList, w io.Writer, options PrintOptions) error {
+ for _, rs := range list.Items {
+ if err := printCluster(&rs, w, options); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func printJob(job *batch.Job, w io.Writer, options PrintOptions) error {
name := job.Name
namespace := job.Namespace
containers := job.Spec.Template.Spec.Containers
@@ -813,17 +924,17 @@ func printJob(job *extensions.Job, w io.Writer, options PrintOptions) error {
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(job.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(job.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, job.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, job.Labels)); err != nil {
return err
}
return nil
}
-func printJobList(list *extensions.JobList, w io.Writer, options PrintOptions) error {
+func printJobList(list *batch.JobList, w io.Writer, options PrintOptions) error {
for _, job := range list.Items {
if err := printJob(&job, w, options); err != nil {
return err
@@ -832,19 +943,26 @@ func printJobList(list *extensions.JobList, w io.Writer, options PrintOptions) e
return nil
}
-// loadBalancerStatusStringer behaves just like a string interface and converts the given status to a string.
-func loadBalancerStatusStringer(s api.LoadBalancerStatus) string {
+// loadBalancerStatusStringer behaves mostly like a string interface and converts the given status to a string.
+// `wide` indicates whether the returned value is meant for --o=wide output. If not, it's clipped to 16 bytes.
+func loadBalancerStatusStringer(s api.LoadBalancerStatus, wide bool) string {
ingress := s.Ingress
result := []string{}
for i := range ingress {
if ingress[i].IP != "" {
result = append(result, ingress[i].IP)
+ } else if ingress[i].Hostname != "" {
+ result = append(result, ingress[i].Hostname)
}
}
- return strings.Join(result, ",")
+ r := strings.Join(result, ",")
+ if !wide && len(r) > loadBalancerWidth {
+ r = r[0:(loadBalancerWidth-3)] + "..."
+ }
+ return r
}
-func getServiceExternalIP(svc *api.Service) string {
+func getServiceExternalIP(svc *api.Service, wide bool) string {
switch svc.Spec.Type {
case api.ServiceTypeClusterIP:
if len(svc.Spec.ExternalIPs) > 0 {
@@ -855,16 +973,19 @@ func getServiceExternalIP(svc *api.Service) string {
if len(svc.Spec.ExternalIPs) > 0 {
return strings.Join(svc.Spec.ExternalIPs, ",")
}
- return "nodes"
+ return "<nodes>"
case api.ServiceTypeLoadBalancer:
- lbIps := loadBalancerStatusStringer(svc.Status.LoadBalancer)
+ lbIps := loadBalancerStatusStringer(svc.Status.LoadBalancer, wide)
if len(svc.Spec.ExternalIPs) > 0 {
result := append(strings.Split(lbIps, ","), svc.Spec.ExternalIPs...)
return strings.Join(result, ",")
}
- return lbIps
+ if len(lbIps) > 0 {
+ return lbIps
+ }
+ return "<pending>"
}
- return "unknown"
+ return "<unknown>"
}
func makePortString(ports []api.ServicePort) string {
@@ -881,7 +1002,7 @@ func printService(svc *api.Service, w io.Writer, options PrintOptions) error {
namespace := svc.Namespace
internalIP := svc.Spec.ClusterIP
- externalIP := getServiceExternalIP(svc)
+ externalIP := getServiceExternalIP(svc, options.Wide)
if options.WithNamespace {
if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
@@ -902,10 +1023,10 @@ func printService(svc *api.Service, w io.Writer, options PrintOptions) error {
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(svc.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(svc.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, svc.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, svc.Labels))
return err
}
@@ -926,11 +1047,39 @@ func backendStringer(backend *extensions.IngressBackend) string {
return fmt.Sprintf("%v:%v", backend.ServiceName, backend.ServicePort.String())
}
+func formatHosts(rules []extensions.IngressRule) string {
+ list := []string{}
+ max := 3
+ more := false
+ for _, rule := range rules {
+ if len(list) == max {
+ more = true
+ }
+ if !more && len(rule.Host) != 0 {
+ list = append(list, rule.Host)
+ }
+ }
+ if len(list) == 0 {
+ return "*"
+ }
+ ret := strings.Join(list, ",")
+ if more {
+ return fmt.Sprintf("%s + %d more...", ret, len(rules)-max)
+ }
+ return ret
+}
+
+func formatPorts(tls []extensions.IngressTLS) string {
+ if len(tls) != 0 {
+ return "80, 443"
+ }
+ return "80"
+}
+
func printIngress(ingress *extensions.Ingress, w io.Writer, options PrintOptions) error {
name := ingress.Name
namespace := ingress.Namespace
- hostRules := ingress.Spec.Rules
if options.WithNamespace {
if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
return err
@@ -939,55 +1088,73 @@ func printIngress(ingress *extensions.Ingress, w io.Writer, options PrintOptions
if _, err := fmt.Fprintf(w, "%s\t%v\t%v\t%v\t%s",
name,
- "-",
- backendStringer(ingress.Spec.Backend),
- loadBalancerStatusStringer(ingress.Status.LoadBalancer),
+ formatHosts(ingress.Spec.Rules),
+ loadBalancerStatusStringer(ingress.Status.LoadBalancer, options.Wide),
+ formatPorts(ingress.Spec.TLS),
translateTimestamp(ingress.CreationTimestamp),
); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(ingress.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(ingress.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, ingress.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, ingress.Labels)); err != nil {
return err
}
+ return nil
+}
- // Lay out all the rules on separate lines if use wide output.
- // TODO(AdoHe): improve ingress output
- extraLinePrefix := ""
- if options.WithNamespace {
- extraLinePrefix = "\t"
- }
- for _, rules := range hostRules {
- if rules.HTTP == nil {
- continue
+func printIngressList(ingressList *extensions.IngressList, w io.Writer, options PrintOptions) error {
+ for _, ingress := range ingressList.Items {
+ if err := printIngress(&ingress, w, options); err != nil {
+ return err
}
- _, err := fmt.Fprintf(w, "%s\t%v\t", extraLinePrefix, rules.Host)
- if err != nil {
+ }
+ return nil
+}
+
+func printPetSet(ps *apps.PetSet, w io.Writer, options PrintOptions) error {
+ name := ps.Name
+ namespace := ps.Namespace
+ containers := ps.Spec.Template.Spec.Containers
+
+ if options.WithNamespace {
+ if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabelTabs(options.ColumnLabels)); err != nil {
+ }
+ desiredReplicas := ps.Spec.Replicas
+ currentReplicas := ps.Status.Replicas
+ if _, err := fmt.Fprintf(w, "%s\t%d\t%d\t%s",
+ name,
+ desiredReplicas,
+ currentReplicas,
+ translateTimestamp(ps.CreationTimestamp),
+ ); err != nil {
+ return err
+ }
+ if options.Wide {
+ if err := layoutContainers(containers, w); err != nil {
return err
}
- for _, rule := range rules.HTTP.Paths {
- _, err := fmt.Fprintf(w, "%s\t%v\t%v", extraLinePrefix, rule.Path, backendStringer(&rule.Backend))
- if err != nil {
- return err
- }
- if _, err := fmt.Fprint(w, appendLabelTabs(options.ColumnLabels)); err != nil {
- return err
- }
+ if _, err := fmt.Fprintf(w, "\t%s", unversioned.FormatLabelSelector(ps.Spec.Selector)); err != nil {
+ return err
}
}
+ if _, err := fmt.Fprint(w, AppendLabels(ps.Labels, options.ColumnLabels)); err != nil {
+ return err
+ }
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, ps.Labels)); err != nil {
+ return err
+ }
return nil
}
-func printIngressList(ingressList *extensions.IngressList, w io.Writer, options PrintOptions) error {
- for _, ingress := range ingressList.Items {
- if err := printIngress(&ingress, w, options); err != nil {
+func printPetSetList(petSetList *apps.PetSetList, w io.Writer, options PrintOptions) error {
+ for _, ps := range petSetList.Items {
+ if err := printPetSet(&ps, w, options); err != nil {
return err
}
}
@@ -1030,10 +1197,10 @@ func printDaemonSet(ds *extensions.DaemonSet, w io.Writer, options PrintOptions)
return err
}
}
- if _, err := fmt.Fprint(w, appendLabels(ds.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(ds.Labels, options.ColumnLabels)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, ds.Labels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, ds.Labels)); err != nil {
return err
}
@@ -1061,10 +1228,10 @@ func printEndpoints(endpoints *api.Endpoints, w io.Writer, options PrintOptions)
if _, err := fmt.Fprintf(w, "%s\t%s\t%s", name, formatEndpoints(endpoints, nil), translateTimestamp(endpoints.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(endpoints.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(endpoints.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, endpoints.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, endpoints.Labels))
return err
}
@@ -1085,10 +1252,10 @@ func printNamespace(item *api.Namespace, w io.Writer, options PrintOptions) erro
if _, err := fmt.Fprintf(w, "%s\t%s\t%s", item.Name, item.Status.Phase, translateTimestamp(item.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(item.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(item.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, item.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, item.Labels))
return err
}
@@ -1113,10 +1280,10 @@ func printSecret(item *api.Secret, w io.Writer, options PrintOptions) error {
if _, err := fmt.Fprintf(w, "%s\t%s\t%v\t%s", name, item.Type, len(item.Data), translateTimestamp(item.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(item.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(item.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, item.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, item.Labels))
return err
}
@@ -1142,10 +1309,10 @@ func printServiceAccount(item *api.ServiceAccount, w io.Writer, options PrintOpt
if _, err := fmt.Fprintf(w, "%s\t%d\t%s", name, len(item.Secrets), translateTimestamp(item.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(item.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(item.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, item.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, item.Labels))
return err
}
@@ -1190,10 +1357,10 @@ func printNode(node *api.Node, w io.Writer, options PrintOptions) error {
return err
}
// Display caller specify column labels first.
- if _, err := fmt.Fprint(w, appendLabels(node.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(node.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, node.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, node.Labels))
return err
}
@@ -1234,10 +1401,10 @@ func printPersistentVolume(pv *api.PersistentVolume, w io.Writer, options PrintO
); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(pv.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(pv.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, pv.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, pv.Labels))
return err
}
@@ -1273,10 +1440,10 @@ func printPersistentVolumeClaim(pvc *api.PersistentVolumeClaim, w io.Writer, opt
if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s", name, phase, pvc.Spec.VolumeName, capacity, accessModes, translateTimestamp(pvc.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(pvc.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(pvc.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, pvc.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, pvc.Labels))
return err
}
@@ -1309,8 +1476,8 @@ func printEvent(event *api.Event, w io.Writer, options PrintOptions) error {
if _, err := fmt.Fprintf(
w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
- FirstTimestamp,
LastTimestamp,
+ FirstTimestamp,
event.Count,
event.InvolvedObject.Name,
event.InvolvedObject.Kind,
@@ -1322,10 +1489,10 @@ func printEvent(event *api.Event, w io.Writer, options PrintOptions) error {
); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(event.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(event.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, event.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, event.Labels))
return err
}
@@ -1341,67 +1508,105 @@ func printEventList(list *api.EventList, w io.Writer, options PrintOptions) erro
}
func printLimitRange(limitRange *api.LimitRange, w io.Writer, options PrintOptions) error {
- name := limitRange.Name
- namespace := limitRange.Namespace
+ return printObjectMeta(limitRange.ObjectMeta, w, options, true)
+}
- if options.WithNamespace {
- if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
+// Prints the LimitRangeList in a human-friendly format.
+func printLimitRangeList(list *api.LimitRangeList, w io.Writer, options PrintOptions) error {
+ for i := range list.Items {
+ if err := printLimitRange(&list.Items[i], w, options); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// printObjectMeta prints the object metadata of a given resource.
+func printObjectMeta(meta api.ObjectMeta, w io.Writer, options PrintOptions, namespaced bool) error {
+ if namespaced && options.WithNamespace {
+ if _, err := fmt.Fprintf(w, "%s\t", meta.Namespace); err != nil {
return err
}
}
if _, err := fmt.Fprintf(
w, "%s\t%s",
- name,
- translateTimestamp(limitRange.CreationTimestamp),
+ meta.Name,
+ translateTimestamp(meta.CreationTimestamp),
); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(limitRange.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(meta.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, limitRange.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, meta.Labels))
return err
}
-// Prints the LimitRangeList in a human-friendly format.
-func printLimitRangeList(list *api.LimitRangeList, w io.Writer, options PrintOptions) error {
+func printResourceQuota(resourceQuota *api.ResourceQuota, w io.Writer, options PrintOptions) error {
+ return printObjectMeta(resourceQuota.ObjectMeta, w, options, true)
+}
+
+// Prints the ResourceQuotaList in a human-friendly format.
+func printResourceQuotaList(list *api.ResourceQuotaList, w io.Writer, options PrintOptions) error {
for i := range list.Items {
- if err := printLimitRange(&list.Items[i], w, options); err != nil {
+ if err := printResourceQuota(&list.Items[i], w, options); err != nil {
return err
}
}
return nil
}
-func printResourceQuota(resourceQuota *api.ResourceQuota, w io.Writer, options PrintOptions) error {
- name := resourceQuota.Name
- namespace := resourceQuota.Namespace
+func printRole(role *rbac.Role, w io.Writer, options PrintOptions) error {
+ return printObjectMeta(role.ObjectMeta, w, options, true)
+}
- if options.WithNamespace {
- if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
+// Prints the Role in a human-friendly format.
+func printRoleList(list *rbac.RoleList, w io.Writer, options PrintOptions) error {
+ for i := range list.Items {
+ if err := printRole(&list.Items[i], w, options); err != nil {
return err
}
}
+ return nil
+}
- if _, err := fmt.Fprintf(
- w, "%s\t%s",
- name,
- translateTimestamp(resourceQuota.CreationTimestamp),
- ); err != nil {
- return err
+func printRoleBinding(roleBinding *rbac.RoleBinding, w io.Writer, options PrintOptions) error {
+ return printObjectMeta(roleBinding.ObjectMeta, w, options, true)
+}
+
+// Prints the RoleBinding in a human-friendly format.
+func printRoleBindingList(list *rbac.RoleBindingList, w io.Writer, options PrintOptions) error {
+ for i := range list.Items {
+ if err := printRoleBinding(&list.Items[i], w, options); err != nil {
+ return err
+ }
}
- if _, err := fmt.Fprint(w, appendLabels(resourceQuota.Labels, options.ColumnLabels)); err != nil {
- return err
+ return nil
+}
+
+func printClusterRole(clusterRole *rbac.ClusterRole, w io.Writer, options PrintOptions) error {
+ return printObjectMeta(clusterRole.ObjectMeta, w, options, false)
+}
+
+// Prints the ClusterRole in a human-friendly format.
+func printClusterRoleList(list *rbac.ClusterRoleList, w io.Writer, options PrintOptions) error {
+ for i := range list.Items {
+ if err := printClusterRole(&list.Items[i], w, options); err != nil {
+ return err
+ }
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, resourceQuota.Labels))
- return err
+ return nil
}
-// Prints the ResourceQuotaList in a human-friendly format.
-func printResourceQuotaList(list *api.ResourceQuotaList, w io.Writer, options PrintOptions) error {
+func printClusterRoleBinding(clusterRoleBinding *rbac.ClusterRoleBinding, w io.Writer, options PrintOptions) error {
+ return printObjectMeta(clusterRoleBinding.ObjectMeta, w, options, false)
+}
+
+// Prints the ClusterRoleBinding in a human-friendly format.
+func printClusterRoleBindingList(list *rbac.ClusterRoleBindingList, w io.Writer, options PrintOptions) error {
for i := range list.Items {
- if err := printResourceQuota(&list.Items[i], w, options); err != nil {
+ if err := printClusterRoleBinding(&list.Items[i], w, options); err != nil {
return err
}
}
@@ -1431,10 +1636,10 @@ func printComponentStatus(item *api.ComponentStatus, w io.Writer, options PrintO
if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s", item.Name, status, message, error); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(item.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(item.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, item.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, item.Labels))
return err
}
@@ -1452,7 +1657,7 @@ func printThirdPartyResource(rsrc *extensions.ThirdPartyResource, w io.Writer, o
versions := make([]string, len(rsrc.Versions))
for ix := range rsrc.Versions {
version := &rsrc.Versions[ix]
- versions[ix] = fmt.Sprintf("%s/%s", version.APIGroup, version.Name)
+ versions[ix] = fmt.Sprintf("%s", version.Name)
}
versionsString := strings.Join(versions, ",")
if _, err := fmt.Fprintf(w, "%s\t%s\t%s\n", rsrc.Name, rsrc.Description, versionsString); err != nil {
@@ -1471,6 +1676,35 @@ func printThirdPartyResourceList(list *extensions.ThirdPartyResourceList, w io.W
return nil
}
+func truncate(str string, maxLen int) string {
+ if len(str) > maxLen {
+ return str[0:maxLen] + "..."
+ }
+ return str
+}
+
+func printThirdPartyResourceData(rsrc *extensions.ThirdPartyResourceData, w io.Writer, options PrintOptions) error {
+ l := labels.FormatLabels(rsrc.Labels)
+ truncateCols := 50
+ if options.Wide {
+ truncateCols = 100
+ }
+ if _, err := fmt.Fprintf(w, "%s\t%s\t%s\n", rsrc.Name, l, truncate(string(rsrc.Data), truncateCols)); err != nil {
+ return err
+ }
+ return nil
+}
+
+func printThirdPartyResourceDataList(list *extensions.ThirdPartyResourceDataList, w io.Writer, options PrintOptions) error {
+ for _, item := range list.Items {
+ if err := printThirdPartyResourceData(&item, w, options); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
func printDeployment(deployment *extensions.Deployment, w io.Writer, options PrintOptions) error {
if options.WithNamespace {
if _, err := fmt.Fprintf(w, "%s\t", deployment.Namespace); err != nil {
@@ -1486,10 +1720,10 @@ func printDeployment(deployment *extensions.Deployment, w io.Writer, options Pri
if _, err := fmt.Fprintf(w, "%s\t%d\t%d\t%d\t%d\t%s", deployment.Name, desiredReplicas, currentReplicas, updatedReplicas, availableReplicas, age); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(deployment.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(deployment.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, deployment.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, deployment.Labels))
return err
}
@@ -1502,16 +1736,15 @@ func printDeploymentList(list *extensions.DeploymentList, w io.Writer, options P
return nil
}
-func printHorizontalPodAutoscaler(hpa *extensions.HorizontalPodAutoscaler, w io.Writer, options PrintOptions) error {
+func printHorizontalPodAutoscaler(hpa *autoscaling.HorizontalPodAutoscaler, w io.Writer, options PrintOptions) error {
namespace := hpa.Namespace
name := hpa.Name
- reference := fmt.Sprintf("%s/%s/%s",
- hpa.Spec.ScaleRef.Kind,
- hpa.Spec.ScaleRef.Name,
- hpa.Spec.ScaleRef.Subresource)
+ reference := fmt.Sprintf("%s/%s",
+ hpa.Spec.ScaleTargetRef.Kind,
+ hpa.Spec.ScaleTargetRef.Name)
target := "<unset>"
- if hpa.Spec.CPUUtilization != nil {
- target = fmt.Sprintf("%d%%", hpa.Spec.CPUUtilization.TargetPercentage)
+ if hpa.Spec.TargetCPUUtilizationPercentage != nil {
+ target = fmt.Sprintf("%d%%", *hpa.Spec.TargetCPUUtilizationPercentage)
}
current := "<waiting>"
if hpa.Status.CurrentCPUUtilizationPercentage != nil {
@@ -1539,14 +1772,14 @@ func printHorizontalPodAutoscaler(hpa *extensions.HorizontalPodAutoscaler, w io.
); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(hpa.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(hpa.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, hpa.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, hpa.Labels))
return err
}
-func printHorizontalPodAutoscalerList(list *extensions.HorizontalPodAutoscalerList, w io.Writer, options PrintOptions) error {
+func printHorizontalPodAutoscalerList(list *autoscaling.HorizontalPodAutoscalerList, w io.Writer, options PrintOptions) error {
for i := range list.Items {
if err := printHorizontalPodAutoscaler(&list.Items[i], w, options); err != nil {
return err
@@ -1567,10 +1800,10 @@ func printConfigMap(configMap *api.ConfigMap, w io.Writer, options PrintOptions)
if _, err := fmt.Fprintf(w, "%s\t%v\t%s", name, len(configMap.Data), translateTimestamp(configMap.CreationTimestamp)); err != nil {
return err
}
- if _, err := fmt.Fprint(w, appendLabels(configMap.Labels, options.ColumnLabels)); err != nil {
+ if _, err := fmt.Fprint(w, AppendLabels(configMap.Labels, options.ColumnLabels)); err != nil {
return err
}
- _, err := fmt.Fprint(w, appendAllLabels(options.ShowLabels, configMap.Labels))
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, configMap.Labels))
return err
}
@@ -1584,9 +1817,9 @@ func printConfigMapList(list *api.ConfigMapList, w io.Writer, options PrintOptio
}
func printPodSecurityPolicy(item *extensions.PodSecurityPolicy, w io.Writer, options PrintOptions) error {
- _, err := fmt.Fprintf(w, "%s\t%t\t%v\t%t\t%s\t%s\n", item.Name, item.Spec.Privileged,
- item.Spec.Capabilities, item.Spec.Volumes, item.Spec.SELinux.Rule,
- item.Spec.RunAsUser.Rule)
+ _, err := fmt.Fprintf(w, "%s\t%t\t%v\t%s\t%s\t%s\t%s\t%t\t%v\n", item.Name, item.Spec.Privileged,
+ item.Spec.AllowedCapabilities, item.Spec.SELinux.Rule,
+ item.Spec.RunAsUser.Rule, item.Spec.FSGroup.Rule, item.Spec.SupplementalGroups.Rule, item.Spec.ReadOnlyRootFilesystem, item.Spec.Volumes)
return err
}
@@ -1600,7 +1833,35 @@ func printPodSecurityPolicyList(list *extensions.PodSecurityPolicyList, w io.Wri
return nil
}
-func appendLabels(itemLabels map[string]string, columnLabels []string) string {
+func printNetworkPolicy(networkPolicy *extensions.NetworkPolicy, w io.Writer, options PrintOptions) error {
+ name := networkPolicy.Name
+ namespace := networkPolicy.Namespace
+
+ if options.WithNamespace {
+ if _, err := fmt.Fprintf(w, "%s\t", namespace); err != nil {
+ return err
+ }
+ }
+ if _, err := fmt.Fprintf(w, "%s\t%v\t%s", name, unversioned.FormatLabelSelector(&networkPolicy.Spec.PodSelector), translateTimestamp(networkPolicy.CreationTimestamp)); err != nil {
+ return err
+ }
+ if _, err := fmt.Fprint(w, AppendLabels(networkPolicy.Labels, options.ColumnLabels)); err != nil {
+ return err
+ }
+ _, err := fmt.Fprint(w, AppendAllLabels(options.ShowLabels, networkPolicy.Labels))
+ return err
+}
+
+func printNetworkPolicyList(list *extensions.NetworkPolicyList, w io.Writer, options PrintOptions) error {
+ for i := range list.Items {
+ if err := printNetworkPolicy(&list.Items[i], w, options); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func AppendLabels(itemLabels map[string]string, columnLabels []string) string {
var buffer bytes.Buffer
for _, cl := range columnLabels {
@@ -1617,7 +1878,7 @@ func appendLabels(itemLabels map[string]string, columnLabels []string) string {
// Append all labels to a single column. We need this even when show-labels flag* is
// false, since this adds newline delimiter to the end of each row.
-func appendAllLabels(showLabels bool, itemLabels map[string]string) string {
+func AppendAllLabels(showLabels bool, itemLabels map[string]string) string {
var buffer bytes.Buffer
if showLabels {
@@ -1631,13 +1892,10 @@ func appendAllLabels(showLabels bool, itemLabels map[string]string) string {
// Append a set of tabs for each label column. We need this in the case where
// we have extra lines so that the tabwriter will still line things up.
-func appendLabelTabs(columnLabels []string) string {
+func AppendLabelTabs(columnLabels []string) string {
var buffer bytes.Buffer
- for i := range columnLabels {
- // NB: This odd dance is to make the loop both compatible with go 1.3 and
- // pass `gofmt -s`
- _ = i
+ for range columnLabels {
buffer.WriteString("\t")
}
buffer.WriteString("\n")
@@ -1678,12 +1936,12 @@ func formatLabelHeaders(columnLabels []string) []string {
func formatWideHeaders(wide bool, t reflect.Type) []string {
if wide {
if t.String() == "*api.Pod" || t.String() == "*api.PodList" {
- return []string{"NODE"}
+ return []string{"IP", "NODE"}
}
if t.String() == "*api.ReplicationController" || t.String() == "*api.ReplicationControllerList" {
return []string{"CONTAINER(S)", "IMAGE(S)", "SELECTOR"}
}
- if t.String() == "*extensions.Job" || t.String() == "*extensions.JobList" {
+ if t.String() == "*batch.Job" || t.String() == "*batch.JobList" {
return []string{"CONTAINER(S)", "IMAGE(S)", "SELECTOR"}
}
if t.String() == "*api.Service" || t.String() == "*api.ServiceList" {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go b/vendor/k8s.io/kubernetes/pkg/kubectl/rollback.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/rollback.go
index 9f53b25af6f381c350d7d4b75ca5993b67ecedba..2e4f92b3050f94671315bdee2626fe0a01d67652 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/rollback.go
@@ -49,6 +49,10 @@ type DeploymentRollbacker struct {
}
func (r *DeploymentRollbacker) Rollback(namespace, name string, updatedAnnotations map[string]string, toRevision int64, obj runtime.Object) (string, error) {
+ d := obj.(*extensions.Deployment)
+ if d.Spec.Paused {
+ return "", fmt.Errorf("you cannot rollback a paused deployment; resume it first with 'kubectl rollout resume' and try again")
+ }
deploymentRollback := &extensions.DeploymentRollback{
Name: name,
UpdatedAnnotations: updatedAnnotations,
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go b/vendor/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go
similarity index 80%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go
index e69d889a73f4d4a9b12dd78a289d6f8551c9b6da..0af1253ad618e9fdfd05f63381f970fcca7099a3 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/rolling_updater.go
@@ -83,6 +83,10 @@ type RollingUpdaterConfig struct {
// further, ensuring that total number of pods running at any time during
// the update is atmost 130% of desired pods.
MaxSurge intstr.IntOrString
+ // OnProgress is invoked if set during each scale cycle, to allow the caller to perform additional logic or
+ // abort the scale. If an error is returned the cleanup method will not be invoked. The percentage value
+ // is a synthetic "progress" calculation that represents the approximate percentage completion.
+ OnProgress func(oldRc, newRc *api.ReplicationController, percentage int) error
}
// RollingUpdaterCleanupPolicy is a cleanup action to take after the
@@ -114,7 +118,7 @@ type RollingUpdater struct {
// cleanup performs post deployment cleanup tasks for newRc and oldRc.
cleanup func(oldRc, newRc *api.ReplicationController, config *RollingUpdaterConfig) error
// getReadyPods returns the amount of old and new ready pods.
- getReadyPods func(oldRc, newRc *api.ReplicationController) (int, int, error)
+ getReadyPods func(oldRc, newRc *api.ReplicationController) (int32, int32, error)
}
// NewRollingUpdater creates a RollingUpdater from a client.
@@ -169,11 +173,12 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
fmt.Fprintf(out, "Created %s\n", newRc.Name)
}
// Extract the desired replica count from the controller.
- desired, err := strconv.Atoi(newRc.Annotations[desiredReplicasAnnotation])
+ desiredAnnotation, err := strconv.Atoi(newRc.Annotations[desiredReplicasAnnotation])
if err != nil {
return fmt.Errorf("Unable to parse annotation for %s: %s=%s",
newRc.Name, desiredReplicasAnnotation, newRc.Annotations[desiredReplicasAnnotation])
}
+ desired := int32(desiredAnnotation)
// Extract the original replica count from the old controller, adding the
// annotation if it doesn't yet exist.
_, hasOriginalAnnotation := oldRc.Annotations[originalReplicasAnnotation]
@@ -182,15 +187,16 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
if err != nil {
return err
}
- if existing.Annotations == nil {
- existing.Annotations = map[string]string{}
+ originReplicas := strconv.Itoa(int(existing.Spec.Replicas))
+ applyUpdate := func(rc *api.ReplicationController) {
+ if rc.Annotations == nil {
+ rc.Annotations = map[string]string{}
+ }
+ rc.Annotations[originalReplicasAnnotation] = originReplicas
}
- existing.Annotations[originalReplicasAnnotation] = strconv.Itoa(existing.Spec.Replicas)
- updated, err := r.c.ReplicationControllers(existing.Namespace).Update(existing)
- if err != nil {
+ if oldRc, err = updateRcWithRetries(r.c, existing.Namespace, existing, applyUpdate); err != nil {
return err
}
- oldRc = updated
}
// maxSurge is the maximum scaling increment and maxUnavailable are the maximum pods
// that can be unavailable during a rollout.
@@ -204,7 +210,7 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
}
// The minumum pods which must remain available througout the update
// calculated for internal convenience.
- minAvailable := integer.IntMax(0, desired-maxUnavailable)
+ minAvailable := int32(integer.IntMax(0, int(desired-maxUnavailable)))
// If the desired new scale is 0, then the max unavailable is necessarily
// the effective scale of the old RC regardless of the configuration
// (equivalent to 100% maxUnavailable).
@@ -216,6 +222,26 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
fmt.Fprintf(out, "Scaling up %s from %d to %d, scaling down %s from %d to 0 (keep %d pods available, don't exceed %d pods)\n",
newRc.Name, newRc.Spec.Replicas, desired, oldRc.Name, oldRc.Spec.Replicas, minAvailable, desired+maxSurge)
+ // give a caller incremental notification and allow them to exit early
+ goal := desired - newRc.Spec.Replicas
+ if goal < 0 {
+ goal = -goal
+ }
+ progress := func(complete bool) error {
+ if config.OnProgress == nil {
+ return nil
+ }
+ progress := desired - newRc.Spec.Replicas
+ if progress < 0 {
+ progress = -progress
+ }
+ percentage := 100
+ if !complete && goal > 0 {
+ percentage = int((goal - progress) * 100 / goal)
+ }
+ return config.OnProgress(oldRc, newRc, percentage)
+ }
+
// Scale newRc and oldRc until newRc has the desired number of replicas and
// oldRc has 0 replicas.
progressDeadline := time.Now().UnixNano() + config.Timeout.Nanoseconds()
@@ -231,6 +257,11 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
}
newRc = scaledRc
+ // notify the caller if necessary
+ if err := progress(false); err != nil {
+ return err
+ }
+
// Wait between scaling operations for things to settle.
time.Sleep(config.UpdatePeriod)
@@ -241,6 +272,11 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
}
oldRc = scaledRc
+ // notify the caller if necessary
+ if err := progress(false); err != nil {
+ return err
+ }
+
// If we are making progress, continue to advance the progress deadline.
// Otherwise, time out with an error.
progressMade := (newRc.Spec.Replicas != newReplicas) || (oldRc.Spec.Replicas != oldReplicas)
@@ -251,6 +287,11 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
}
}
+ // notify the caller if necessary
+ if err := progress(true); err != nil {
+ return err
+ }
+
// Housekeeping and cleanup policy execution.
return r.cleanup(oldRc, newRc, config)
}
@@ -258,7 +299,7 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error {
// scaleUp scales up newRc to desired by whatever increment is possible given
// the configured surge threshold. scaleUp will safely no-op as necessary when
// it detects redundancy or other relevant conditions.
-func (r *RollingUpdater) scaleUp(newRc, oldRc *api.ReplicationController, desired, maxSurge, maxUnavailable int, scaleRetryParams *RetryParams, config *RollingUpdaterConfig) (*api.ReplicationController, error) {
+func (r *RollingUpdater) scaleUp(newRc, oldRc *api.ReplicationController, desired, maxSurge, maxUnavailable int32, scaleRetryParams *RetryParams, config *RollingUpdaterConfig) (*api.ReplicationController, error) {
// If we're already at the desired, do nothing.
if newRc.Spec.Replicas == desired {
return newRc, nil
@@ -291,7 +332,7 @@ func (r *RollingUpdater) scaleUp(newRc, oldRc *api.ReplicationController, desire
// scaleDown scales down oldRc to 0 at whatever decrement possible given the
// thresholds defined on the config. scaleDown will safely no-op as necessary
// when it detects redundancy or other relevant conditions.
-func (r *RollingUpdater) scaleDown(newRc, oldRc *api.ReplicationController, desired, minAvailable, maxUnavailable, maxSurge int, config *RollingUpdaterConfig) (*api.ReplicationController, error) {
+func (r *RollingUpdater) scaleDown(newRc, oldRc *api.ReplicationController, desired, minAvailable, maxUnavailable, maxSurge int32, config *RollingUpdaterConfig) (*api.ReplicationController, error) {
// Already scaled down; do nothing.
if oldRc.Spec.Replicas == 0 {
return oldRc, nil
@@ -356,10 +397,10 @@ func (r *RollingUpdater) scaleAndWaitWithScaler(rc *api.ReplicationController, r
// readyPods returns the old and new ready counts for their pods.
// If a pod is observed as being ready, it's considered ready even
// if it later becomes notReady.
-func (r *RollingUpdater) readyPods(oldRc, newRc *api.ReplicationController) (int, int, error) {
+func (r *RollingUpdater) readyPods(oldRc, newRc *api.ReplicationController) (int32, int32, error) {
controllers := []*api.ReplicationController{oldRc, newRc}
- oldReady := 0
- newReady := 0
+ oldReady := int32(0)
+ newReady := int32(0)
for i := range controllers {
controller := controllers[i]
@@ -442,13 +483,14 @@ func (r *RollingUpdater) cleanupWithClients(oldRc, newRc *api.ReplicationControl
if err != nil {
return err
}
- delete(newRc.Annotations, sourceIdAnnotation)
- delete(newRc.Annotations, desiredReplicasAnnotation)
-
- newRc, err = r.c.ReplicationControllers(r.ns).Update(newRc)
- if err != nil {
+ applyUpdate := func(rc *api.ReplicationController) {
+ delete(rc.Annotations, sourceIdAnnotation)
+ delete(rc.Annotations, desiredReplicasAnnotation)
+ }
+ if newRc, err = updateRcWithRetries(r.c, r.ns, newRc, applyUpdate); err != nil {
return err
}
+
if err = wait.Poll(config.Interval, config.Timeout, client.ControllerHasDesiredReplicas(r.c, newRc)); err != nil {
return err
}
@@ -504,19 +546,28 @@ func LoadExistingNextReplicationController(c client.ReplicationControllersNamesp
return newRc, err
}
-func CreateNewControllerFromCurrentController(c client.Interface, codec runtime.Codec, namespace, oldName, newName, image, container, deploymentKey string) (*api.ReplicationController, error) {
+type NewControllerConfig struct {
+ Namespace string
+ OldName, NewName string
+ Image string
+ Container string
+ DeploymentKey string
+ PullPolicy api.PullPolicy
+}
+
+func CreateNewControllerFromCurrentController(c client.Interface, codec runtime.Codec, cfg *NewControllerConfig) (*api.ReplicationController, error) {
containerIndex := 0
// load the old RC into the "new" RC
- newRc, err := c.ReplicationControllers(namespace).Get(oldName)
+ newRc, err := c.ReplicationControllers(cfg.Namespace).Get(cfg.OldName)
if err != nil {
return nil, err
}
- if len(container) != 0 {
+ if len(cfg.Container) != 0 {
containerFound := false
for i, c := range newRc.Spec.Template.Spec.Containers {
- if c.Name == container {
+ if c.Name == cfg.Container {
containerIndex = i
containerFound = true
break
@@ -524,31 +575,34 @@ func CreateNewControllerFromCurrentController(c client.Interface, codec runtime.
}
if !containerFound {
- return nil, fmt.Errorf("container %s not found in pod", container)
+ return nil, fmt.Errorf("container %s not found in pod", cfg.Container)
}
}
- if len(newRc.Spec.Template.Spec.Containers) > 1 && len(container) == 0 {
+ if len(newRc.Spec.Template.Spec.Containers) > 1 && len(cfg.Container) == 0 {
return nil, goerrors.New("Must specify container to update when updating a multi-container pod")
}
if len(newRc.Spec.Template.Spec.Containers) == 0 {
return nil, goerrors.New(fmt.Sprintf("Pod has no containers! (%v)", newRc))
}
- newRc.Spec.Template.Spec.Containers[containerIndex].Image = image
+ newRc.Spec.Template.Spec.Containers[containerIndex].Image = cfg.Image
+ if len(cfg.PullPolicy) != 0 {
+ newRc.Spec.Template.Spec.Containers[containerIndex].ImagePullPolicy = cfg.PullPolicy
+ }
newHash, err := api.HashObject(newRc, codec)
if err != nil {
return nil, err
}
- if len(newName) == 0 {
- newName = fmt.Sprintf("%s-%s", newRc.Name, newHash)
+ if len(cfg.NewName) == 0 {
+ cfg.NewName = fmt.Sprintf("%s-%s", newRc.Name, newHash)
}
- newRc.Name = newName
+ newRc.Name = cfg.NewName
- newRc.Spec.Selector[deploymentKey] = newHash
- newRc.Spec.Template.Labels[deploymentKey] = newHash
+ newRc.Spec.Selector[cfg.DeploymentKey] = newHash
+ newRc.Spec.Template.Labels[cfg.DeploymentKey] = newHash
// Clear resource version after hashing so that identical updates get different hashes.
newRc.ResourceVersion = ""
return newRc, nil
@@ -591,27 +645,29 @@ func SetNextControllerAnnotation(rc *api.ReplicationController, name string) {
}
func UpdateExistingReplicationController(c client.Interface, oldRc *api.ReplicationController, namespace, newName, deploymentKey, deploymentValue string, out io.Writer) (*api.ReplicationController, error) {
- SetNextControllerAnnotation(oldRc, newName)
if _, found := oldRc.Spec.Selector[deploymentKey]; !found {
+ SetNextControllerAnnotation(oldRc, newName)
return AddDeploymentKeyToReplicationController(oldRc, c, deploymentKey, deploymentValue, namespace, out)
} else {
// If we didn't need to update the controller for the deployment key, we still need to write
// the "next" controller.
- return c.ReplicationControllers(namespace).Update(oldRc)
+ applyUpdate := func(rc *api.ReplicationController) {
+ SetNextControllerAnnotation(rc, newName)
+ }
+ return updateRcWithRetries(c, namespace, oldRc, applyUpdate)
}
}
-const MaxRetries = 3
-
func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, client client.Interface, deploymentKey, deploymentValue, namespace string, out io.Writer) (*api.ReplicationController, error) {
var err error
// First, update the template label. This ensures that any newly created pods will have the new label
- if oldRc, err = updateWithRetries(client.ReplicationControllers(namespace), oldRc, func(rc *api.ReplicationController) {
+ applyUpdate := func(rc *api.ReplicationController) {
if rc.Spec.Template.Labels == nil {
rc.Spec.Template.Labels = map[string]string{}
}
rc.Spec.Template.Labels[deploymentKey] = deploymentValue
- }); err != nil {
+ }
+ if oldRc, err = updateRcWithRetries(client, namespace, oldRc, applyUpdate); err != nil {
return nil, err
}
@@ -625,26 +681,16 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c
}
for ix := range podList.Items {
pod := &podList.Items[ix]
- if pod.Labels == nil {
- pod.Labels = map[string]string{
- deploymentKey: deploymentValue,
- }
- } else {
- pod.Labels[deploymentKey] = deploymentValue
- }
- err = nil
- delay := 3
- for i := 0; i < MaxRetries; i++ {
- _, err = client.Pods(namespace).Update(pod)
- if err != nil {
- fmt.Fprintf(out, "Error updating pod (%v), retrying after %d seconds", err, delay)
- time.Sleep(time.Second * time.Duration(delay))
- delay *= delay
+ applyUpdate := func(p *api.Pod) {
+ if p.Labels == nil {
+ p.Labels = map[string]string{
+ deploymentKey: deploymentValue,
+ }
} else {
- break
+ p.Labels[deploymentKey] = deploymentValue
}
}
- if err != nil {
+ if pod, err = updatePodWithRetries(client, namespace, pod, applyUpdate); err != nil {
return nil, err
}
}
@@ -657,12 +703,11 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c
for k, v := range oldRc.Spec.Selector {
selectorCopy[k] = v
}
- oldRc.Spec.Selector[deploymentKey] = deploymentValue
-
- // Update the selector of the rc so it manages all the pods we updated above
- if oldRc, err = updateWithRetries(client.ReplicationControllers(namespace), oldRc, func(rc *api.ReplicationController) {
+ applyUpdate = func(rc *api.ReplicationController) {
rc.Spec.Selector[deploymentKey] = deploymentValue
- }); err != nil {
+ }
+ // Update the selector of the rc so it manages all the pods we updated above
+ if oldRc, err = updateRcWithRetries(client, namespace, oldRc, applyUpdate); err != nil {
return nil, err
}
@@ -684,33 +729,72 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c
return oldRc, nil
}
-type updateFunc func(controller *api.ReplicationController)
+type updateRcFunc func(controller *api.ReplicationController)
-// updateWithRetries updates applies the given rc as an update.
-func updateWithRetries(rcClient client.ReplicationControllerInterface, rc *api.ReplicationController, applyUpdate updateFunc) (*api.ReplicationController, error) {
- var err error
- oldRc := rc
- err = wait.Poll(10*time.Millisecond, 1*time.Minute, func() (bool, error) {
+// updateRcWithRetries retries updating the given rc on conflict with the following steps:
+// 1. Get latest resource
+// 2. applyUpdate
+// 3. Update the resource
+func updateRcWithRetries(c client.Interface, namespace string, rc *api.ReplicationController, applyUpdate updateRcFunc) (*api.ReplicationController, error) {
+ // Deep copy the rc in case we failed on Get during retry loop
+ obj, err := api.Scheme.Copy(rc)
+ if err != nil {
+ return nil, fmt.Errorf("failed to deep copy rc before updating it: %v", err)
+ }
+ oldRc := obj.(*api.ReplicationController)
+ err = client.RetryOnConflict(client.DefaultBackoff, func() (e error) {
// Apply the update, then attempt to push it to the apiserver.
applyUpdate(rc)
- if rc, err = rcClient.Update(rc); err == nil {
+ if rc, e = c.ReplicationControllers(namespace).Update(rc); e == nil {
// rc contains the latest controller post update
- return true, nil
+ return
}
+ updateErr := e
// Update the controller with the latest resource version, if the update failed we
// can't trust rc so use oldRc.Name.
- if rc, err = rcClient.Get(oldRc.Name); err != nil {
+ if rc, e = c.ReplicationControllers(namespace).Get(oldRc.Name); e != nil {
// The Get failed: Value in rc cannot be trusted.
rc = oldRc
}
- // The Get passed: rc contains the latest controller, expect a poll for the update.
- return false, nil
+ // Only return the error from update
+ return updateErr
})
// If the error is non-nil the returned controller cannot be trusted, if it is nil, the returned
// controller contains the applied update.
return rc, err
}
+type updatePodFunc func(controller *api.Pod)
+
+// updatePodWithRetries retries updating the given pod on conflict with the following steps:
+// 1. Get latest resource
+// 2. applyUpdate
+// 3. Update the resource
+func updatePodWithRetries(c client.Interface, namespace string, pod *api.Pod, applyUpdate updatePodFunc) (*api.Pod, error) {
+ // Deep copy the pod in case we failed on Get during retry loop
+ obj, err := api.Scheme.Copy(pod)
+ if err != nil {
+ return nil, fmt.Errorf("failed to deep copy pod before updating it: %v", err)
+ }
+ oldPod := obj.(*api.Pod)
+ err = client.RetryOnConflict(client.DefaultBackoff, func() (e error) {
+ // Apply the update, then attempt to push it to the apiserver.
+ applyUpdate(pod)
+ if pod, e = c.Pods(namespace).Update(pod); e == nil {
+ return
+ }
+ updateErr := e
+ if pod, e = c.Pods(namespace).Get(oldPod.Name); e != nil {
+ pod = oldPod
+ }
+ // Only return the error from update
+ return updateErr
+ })
+ // If the error is non-nil the returned pod cannot be trusted, if it is nil, the returned
+ // controller contains the applied update.
+ return pod, err
+}
+
func FindSourceController(r client.ReplicationControllersNamespacer, namespace, name string) (*api.ReplicationController, error) {
list, err := r.ReplicationControllers(namespace).List(api.ListOptions{})
if err != nil {
diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/rollout_status.go b/vendor/k8s.io/kubernetes/pkg/kubectl/rollout_status.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc39865d450d81692d5d3a04a6c05c108cb1329c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/rollout_status.go
@@ -0,0 +1,57 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 kubectl
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ client "k8s.io/kubernetes/pkg/client/unversioned"
+)
+
+// StatusViewer provides an interface for resources that provides rollout status.
+type StatusViewer interface {
+ Status(namespace, name string) (string, bool, error)
+}
+
+func StatusViewerFor(kind unversioned.GroupKind, c client.Interface) (StatusViewer, error) {
+ switch kind {
+ case extensions.Kind("Deployment"):
+ return &DeploymentStatusViewer{c.Extensions()}, nil
+ }
+ return nil, fmt.Errorf("no status viewer has been implemented for %v", kind)
+}
+
+type DeploymentStatusViewer struct {
+ c client.ExtensionsInterface
+}
+
+// Status returns a message describing deployment status, and a bool value indicating if the status is considered done
+func (s *DeploymentStatusViewer) Status(namespace, name string) (string, bool, error) {
+ deployment, err := s.c.Deployments(namespace).Get(name)
+ if err != nil {
+ return "", false, err
+ }
+ if deployment.Generation <= deployment.Status.ObservedGeneration {
+ if deployment.Status.UpdatedReplicas == deployment.Spec.Replicas {
+ return fmt.Sprintf("deployment %s successfully rolled out\n", name), true, nil
+ }
+ return fmt.Sprintf("Waiting for rollout to finish: %d out of %d new replicas have been updated...\n", deployment.Status.UpdatedReplicas, deployment.Spec.Replicas), false, nil
+ }
+ return fmt.Sprintf("Waiting for deployment spec update to be observed...\n"), false, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/run.go b/vendor/k8s.io/kubernetes/pkg/kubectl/run.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/run.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/run.go
index 688b570e7d18251f83e4ff10e6c68af6ffefa61b..4e076c07195fdeb691c54ef74dd2bef9807864dc 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/run.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/run.go
@@ -25,6 +25,7 @@ import (
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apis/batch"
batchv1 "k8s.io/kubernetes/pkg/apis/batch/v1"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/runtime"
@@ -104,7 +105,7 @@ func (DeploymentV1Beta1) Generate(genericParams map[string]interface{}) (runtime
Labels: labels,
},
Spec: extensions.DeploymentSpec{
- Replicas: count,
+ Replicas: int32(count),
Selector: &unversioned.LabelSelector{MatchLabels: labels},
Template: api.PodTemplateSpec{
ObjectMeta: api.ObjectMeta{
@@ -280,12 +281,12 @@ func (JobV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object
}
podSpec.RestartPolicy = restartPolicy
- job := extensions.Job{
+ job := batch.Job{
ObjectMeta: api.ObjectMeta{
Name: name,
Labels: labels,
},
- Spec: extensions.JobSpec{
+ Spec: batch.JobSpec{
Selector: &unversioned.LabelSelector{
MatchLabels: labels,
},
@@ -433,7 +434,7 @@ func populateResourceList(spec string) (api.ResourceList, error) {
if err != nil {
return nil, err
}
- result[resourceName] = *resourceQuantity
+ result[resourceName] = resourceQuantity
}
return result, nil
}
@@ -457,7 +458,7 @@ func populateV1ResourceList(spec string) (v1.ResourceList, error) {
if err != nil {
return nil, err
}
- result[resourceName] = *resourceQuantity
+ result[resourceName] = resourceQuantity
}
return result, nil
}
@@ -604,7 +605,7 @@ func (BasicReplicationController) Generate(genericParams map[string]interface{})
Labels: labels,
},
Spec: api.ReplicationControllerSpec{
- Replicas: count,
+ Replicas: int32(count),
Selector: labels,
Template: &api.PodTemplateSpec{
ObjectMeta: api.ObjectMeta{
@@ -679,11 +680,11 @@ func updatePodPorts(params map[string]string, podSpec *api.PodSpec) (err error)
if port > 0 {
podSpec.Containers[0].Ports = []api.ContainerPort{
{
- ContainerPort: port,
+ ContainerPort: int32(port),
},
}
if hostPort > 0 {
- podSpec.Containers[0].Ports[0].HostPort = hostPort
+ podSpec.Containers[0].Ports[0].HostPort = int32(hostPort)
}
}
return nil
@@ -826,7 +827,7 @@ func (BasicPod) Generate(genericParams map[string]interface{}) (runtime.Object,
}
func parseEnvs(envArray []string) ([]api.EnvVar, error) {
- envs := []api.EnvVar{}
+ envs := make([]api.EnvVar, 0, len(envArray))
for _, env := range envArray {
pos := strings.Index(env, "=")
if pos == -1 {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/scale.go b/vendor/k8s.io/kubernetes/pkg/kubectl/scale.go
similarity index 93%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/scale.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/scale.go
index 14951c028733146a84aedfa827737e3d7037cd0c..bef93d9909bfa3661d68b157866a206bc4077bf5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/scale.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/scale.go
@@ -48,7 +48,7 @@ func ScalerFor(kind unversioned.GroupKind, c client.Interface) (Scaler, error) {
case extensions.Kind("ReplicaSet"):
return &ReplicaSetScaler{c.Extensions()}, nil
case extensions.Kind("Job"), batch.Kind("Job"):
- return &JobScaler{c.Extensions()}, nil // Either kind of job can be scaled with Extensions interface.
+ return &JobScaler{c.Batch()}, nil // Either kind of job can be scaled with Batch interface.
case extensions.Kind("Deployment"):
return &DeploymentScaler{c.Extensions()}, nil
}
@@ -129,8 +129,8 @@ func ScaleCondition(r Scaler, precondition *ScalePrecondition, namespace, name s
// ValidateReplicationController ensures that the preconditions match. Returns nil if they are valid, an error otherwise
func (precondition *ScalePrecondition) ValidateReplicationController(controller *api.ReplicationController) error {
- if precondition.Size != -1 && controller.Spec.Replicas != precondition.Size {
- return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(controller.Spec.Replicas)}
+ if precondition.Size != -1 && int(controller.Spec.Replicas) != precondition.Size {
+ return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(controller.Spec.Replicas))}
}
if len(precondition.ResourceVersion) != 0 && controller.ResourceVersion != precondition.ResourceVersion {
return PreconditionError{"resource version", precondition.ResourceVersion, controller.ResourceVersion}
@@ -152,7 +152,7 @@ func (scaler *ReplicationControllerScaler) ScaleSimple(namespace, name string, p
return err
}
}
- controller.Spec.Replicas = int(newSize)
+ controller.Spec.Replicas = int32(newSize)
// TODO: do retry on 409 errors here?
if _, err := scaler.c.ReplicationControllers(namespace).Update(controller); err != nil {
if errors.IsInvalid(err) {
@@ -191,8 +191,8 @@ func (scaler *ReplicationControllerScaler) Scale(namespace, name string, newSize
// ValidateReplicaSet ensures that the preconditions match. Returns nil if they are valid, an error otherwise
func (precondition *ScalePrecondition) ValidateReplicaSet(replicaSet *extensions.ReplicaSet) error {
- if precondition.Size != -1 && replicaSet.Spec.Replicas != precondition.Size {
- return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(replicaSet.Spec.Replicas)}
+ if precondition.Size != -1 && int(replicaSet.Spec.Replicas) != precondition.Size {
+ return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(replicaSet.Spec.Replicas))}
}
if len(precondition.ResourceVersion) != 0 && replicaSet.ResourceVersion != precondition.ResourceVersion {
return PreconditionError{"resource version", precondition.ResourceVersion, replicaSet.ResourceVersion}
@@ -214,7 +214,7 @@ func (scaler *ReplicaSetScaler) ScaleSimple(namespace, name string, precondition
return err
}
}
- rs.Spec.Replicas = int(newSize)
+ rs.Spec.Replicas = int32(newSize)
// TODO: do retry on 409 errors here?
if _, err := scaler.c.ReplicaSets(namespace).Update(rs); err != nil {
if errors.IsInvalid(err) {
@@ -252,12 +252,12 @@ func (scaler *ReplicaSetScaler) Scale(namespace, name string, newSize uint, prec
}
// ValidateJob ensures that the preconditions match. Returns nil if they are valid, an error otherwise.
-func (precondition *ScalePrecondition) ValidateJob(job *extensions.Job) error {
+func (precondition *ScalePrecondition) ValidateJob(job *batch.Job) error {
if precondition.Size != -1 && job.Spec.Parallelism == nil {
return PreconditionError{"parallelism", strconv.Itoa(precondition.Size), "nil"}
}
- if precondition.Size != -1 && *job.Spec.Parallelism != precondition.Size {
- return PreconditionError{"parallelism", strconv.Itoa(precondition.Size), strconv.Itoa(*job.Spec.Parallelism)}
+ if precondition.Size != -1 && int(*job.Spec.Parallelism) != precondition.Size {
+ return PreconditionError{"parallelism", strconv.Itoa(precondition.Size), strconv.Itoa(int(*job.Spec.Parallelism))}
}
if len(precondition.ResourceVersion) != 0 && job.ResourceVersion != precondition.ResourceVersion {
return PreconditionError{"resource version", precondition.ResourceVersion, job.ResourceVersion}
@@ -266,7 +266,7 @@ func (precondition *ScalePrecondition) ValidateJob(job *extensions.Job) error {
}
type JobScaler struct {
- c client.ExtensionsInterface
+ c client.BatchInterface
}
// ScaleSimple is responsible for updating job's parallelism.
@@ -280,7 +280,7 @@ func (scaler *JobScaler) ScaleSimple(namespace, name string, preconditions *Scal
return err
}
}
- parallelism := int(newSize)
+ parallelism := int32(newSize)
job.Spec.Parallelism = ¶llelism
if _, err := scaler.c.Jobs(namespace).Update(job); err != nil {
if errors.IsInvalid(err) {
@@ -319,8 +319,8 @@ func (scaler *JobScaler) Scale(namespace, name string, newSize uint, preconditio
// ValidateDeployment ensures that the preconditions match. Returns nil if they are valid, an error otherwise.
func (precondition *ScalePrecondition) ValidateDeployment(deployment *extensions.Deployment) error {
- if precondition.Size != -1 && deployment.Spec.Replicas != precondition.Size {
- return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(deployment.Spec.Replicas)}
+ if precondition.Size != -1 && int(deployment.Spec.Replicas) != precondition.Size {
+ return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(deployment.Spec.Replicas))}
}
if len(precondition.ResourceVersion) != 0 && deployment.ResourceVersion != precondition.ResourceVersion {
return PreconditionError{"resource version", precondition.ResourceVersion, deployment.ResourceVersion}
@@ -346,7 +346,7 @@ func (scaler *DeploymentScaler) ScaleSimple(namespace, name string, precondition
// TODO(madhusudancs): Fix this when Scale group issues are resolved (see issue #18528).
// For now I'm falling back to regular Deployment update operation.
- deployment.Spec.Replicas = int(newSize)
+ deployment.Spec.Replicas = int32(newSize)
if _, err := scaler.c.Deployments(namespace).Update(deployment); err != nil {
if errors.IsInvalid(err) {
return ScaleError{ScaleUpdateInvalidFailure, deployment.ResourceVersion, err}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/secret.go b/vendor/k8s.io/kubernetes/pkg/kubectl/secret.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/secret.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/secret.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/secret_for_docker_registry.go b/vendor/k8s.io/kubernetes/pkg/kubectl/secret_for_docker_registry.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/secret_for_docker_registry.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/secret_for_docker_registry.go
diff --git a/vendor/k8s.io/kubernetes/pkg/kubectl/secret_for_tls.go b/vendor/k8s.io/kubernetes/pkg/kubectl/secret_for_tls.go
new file mode 100644
index 0000000000000000000000000000000000000000..05061d25974b29a41f5cde67bf25ca7b92ffa82c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/secret_for_tls.go
@@ -0,0 +1,124 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 kubectl
+
+import (
+ "crypto/tls"
+ "fmt"
+ "io/ioutil"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// SecretForTLSGeneratorV1 supports stable generation of a TLS secret.
+type SecretForTLSGeneratorV1 struct {
+ // Name is the name of this TLS secret.
+ Name string
+ // Key is the path to the user's private key.
+ Key string
+ // Cert is the path to the user's public key certificate.
+ Cert string
+}
+
+// Ensure it supports the generator pattern that uses parameter injection
+var _ Generator = &SecretForTLSGeneratorV1{}
+
+// Ensure it supports the generator pattern that uses parameters specified during construction
+var _ StructuredGenerator = &SecretForTLSGeneratorV1{}
+
+// Generate returns a secret using the specified parameters
+func (s SecretForTLSGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+ err := ValidateParams(s.ParamNames(), genericParams)
+ if err != nil {
+ return nil, err
+ }
+ params := map[string]string{}
+ for key, value := range genericParams {
+ strVal, isString := value.(string)
+ if !isString {
+ return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+ }
+ params[key] = strVal
+ }
+ delegate := &SecretForTLSGeneratorV1{
+ Name: params["name"],
+ Key: params["key"],
+ Cert: params["cert"],
+ }
+ return delegate.StructuredGenerate()
+}
+
+// StructuredGenerate outputs a secret object using the configured fields
+func (s SecretForTLSGeneratorV1) StructuredGenerate() (runtime.Object, error) {
+ if err := s.validate(); err != nil {
+ return nil, err
+ }
+ tlsCrt, err := readFile(s.Cert)
+ if err != nil {
+ return nil, err
+ }
+ tlsKey, err := readFile(s.Key)
+ if err != nil {
+ return nil, err
+ }
+ secret := &api.Secret{}
+ secret.Name = s.Name
+ secret.Type = api.SecretTypeTLS
+ secret.Data = map[string][]byte{}
+ secret.Data[api.TLSCertKey] = []byte(tlsCrt)
+ secret.Data[api.TLSPrivateKeyKey] = []byte(tlsKey)
+ return secret, nil
+}
+
+// readFile just reads a file into a byte array.
+func readFile(file string) ([]byte, error) {
+ b, err := ioutil.ReadFile(file)
+ if err != nil {
+ return []byte{}, fmt.Errorf("Cannot read file %v, %v", file, err)
+ }
+ return b, nil
+}
+
+// ParamNames returns the set of supported input parameters when using the parameter injection generator pattern
+func (s SecretForTLSGeneratorV1) ParamNames() []GeneratorParam {
+ return []GeneratorParam{
+ {"name", true},
+ {"key", true},
+ {"cert", true},
+ }
+}
+
+// validate validates required fields are set to support structured generation
+func (s SecretForTLSGeneratorV1) validate() error {
+ // TODO: This is not strictly necessary. We can generate a self signed cert
+ // if no key/cert is given. The only requiredment is that we either get both
+ // or none. See test/e2e/ingress_utils for self signed cert generation.
+ if len(s.Key) == 0 {
+ return fmt.Errorf("key must be specified.")
+ }
+ if len(s.Cert) == 0 {
+ return fmt.Errorf("certificate must be specified.")
+ }
+ if _, err := tls.LoadX509KeyPair(s.Cert, s.Key); err != nil {
+ return fmt.Errorf("failed to load key pair %v", err)
+ }
+ // TODO: Add more validation.
+ // 1. If the certificate contains intermediates, it is a valid chain.
+ // 2. Format etc.
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/service.go b/vendor/k8s.io/kubernetes/pkg/kubectl/service.go
similarity index 83%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/service.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/service.go
index 57249e463a1bf041f915dba1b18b0850094b0d58..f67b3a11b49a6bba18c81db0d3df9ca96d454fb5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/service.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/service.go
@@ -65,6 +65,9 @@ func paramNames() []GeneratorParam {
{"load-balancer-ip", false},
{"type", false},
{"protocol", false},
+ // protocols will be used to keep port-protocol mapping derived from
+ // exposed object
+ {"protocols", false},
{"container-port", false}, // alias of target-port
{"target-port", false},
{"port-name", false},
@@ -112,6 +115,15 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
// Leave the port unnamed.
servicePortName = ""
}
+
+ protocolsString, found := params["protocols"]
+ var portProtocolMap map[string]string
+ if found && len(protocolsString) > 0 {
+ portProtocolMap, err = ParseProtocols(protocolsString)
+ if err != nil {
+ return nil, err
+ }
+ }
// ports takes precedence over port since it will be
// specified only when the user hasn't specified a port
// via --port and the exposed object has multiple ports.
@@ -122,6 +134,7 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
return nil, fmt.Errorf("'port' is a required parameter.")
}
}
+
portStringSlice := strings.Split(portString, ",")
for i, stillPortString := range portStringSlice {
port, err := strconv.Atoi(stillPortString)
@@ -134,10 +147,26 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
if len(portStringSlice) > 1 {
name = fmt.Sprintf("port-%d", i+1)
}
+ protocol := params["protocol"]
+
+ switch {
+ case len(protocol) == 0 && len(portProtocolMap) == 0:
+ // Default to TCP, what the flag was doing previously.
+ protocol = "TCP"
+ case len(protocol) > 0 && len(portProtocolMap) > 0:
+ // User has specified the --protocol while exposing a multiprotocol resource
+ // We should stomp multiple protocols with the one specified ie. do nothing
+ case len(protocol) == 0 && len(portProtocolMap) > 0:
+ // no --protocol and we expose a multiprotocol resource
+ protocol = "TCP" // have the default so we can stay sane
+ if exposeProtocol, found := portProtocolMap[stillPortString]; found {
+ protocol = exposeProtocol
+ }
+ }
ports = append(ports, api.ServicePort{
Name: name,
- Port: port,
- Protocol: api.Protocol(params["protocol"]),
+ Port: int32(port),
+ Protocol: api.Protocol(protocol),
})
}
@@ -171,7 +200,7 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
// should be the same as Port
for i := range service.Spec.Ports {
port := service.Spec.Ports[i].Port
- service.Spec.Ports[i].TargetPort = intstr.FromInt(port)
+ service.Spec.Ports[i].TargetPort = intstr.FromInt(int(port))
}
}
if params["create-external-load-balancer"] == "true" {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/serviceaccount.go b/vendor/k8s.io/kubernetes/pkg/kubectl/serviceaccount.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/serviceaccount.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/serviceaccount.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorted_event_list.go b/vendor/k8s.io/kubernetes/pkg/kubectl/sorted_event_list.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorted_event_list.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/sorted_event_list.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go b/vendor/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go
similarity index 63%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go
index ffaa08ee46f38cc0d52c7ccf8b86c00a461d910d..98c67344a3e35e5e5b1c6e1679a406fdfec3fafe 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/sorted_resource_name_list.go
@@ -17,7 +17,10 @@ limitations under the License.
package kubectl
import (
+ "sort"
+
"k8s.io/kubernetes/pkg/api"
+ qosutil "k8s.io/kubernetes/pkg/kubelet/qos/util"
)
type SortableResourceNames []api.ResourceName
@@ -34,6 +37,16 @@ func (list SortableResourceNames) Less(i, j int) bool {
return list[i] < list[j]
}
+// SortedResourceNames returns the sorted resource names of a resource list.
+func SortedResourceNames(list api.ResourceList) []api.ResourceName {
+ resources := make([]api.ResourceName, 0, len(list))
+ for res := range list {
+ resources = append(resources, res)
+ }
+ sort.Sort(SortableResourceNames(resources))
+ return resources
+}
+
type SortableResourceQuotas []api.ResourceQuota
func (list SortableResourceQuotas) Len() int {
@@ -47,3 +60,13 @@ func (list SortableResourceQuotas) Swap(i, j int) {
func (list SortableResourceQuotas) Less(i, j int) bool {
return list[i].Name < list[j].Name
}
+
+// SortedQoSResourceNames returns the sorted resource names of a QoS list.
+func SortedQoSResourceNames(list qosutil.QoSList) []api.ResourceName {
+ resources := make([]api.ResourceName, 0, len(list))
+ for res := range list {
+ resources = append(resources, res)
+ }
+ sort.Sort(SortableResourceNames(resources))
+ return resources
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go b/vendor/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go
index 49e36b882e9b1d7d6217717227040fff97a4a579..e95b8a1e74c4827cd3d7092578b4cd9a20faaf5e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/sorting_printer.go
@@ -23,8 +23,10 @@ import (
"sort"
"k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/integer"
"k8s.io/kubernetes/pkg/util/jsonpath"
"github.com/golang/glog"
@@ -97,7 +99,7 @@ func SortObjects(decoder runtime.Decoder, objs []runtime.Object, fieldInput stri
switch u := item.(type) {
case *runtime.Unknown:
var err error
- if objs[ix], _, err = decoder.Decode(u.RawJSON, nil, nil); err != nil {
+ if objs[ix], _, err = decoder.Decode(u.Raw, nil, nil); err != nil {
return nil, err
}
}
@@ -153,6 +155,29 @@ func isLess(i, j reflect.Value) (bool, error) {
return i.String() < j.String(), nil
case reflect.Ptr:
return isLess(i.Elem(), j.Elem())
+ case reflect.Struct:
+ // sort unversioned.Time
+ in := i.Interface()
+ if t, ok := in.(unversioned.Time); ok {
+ return t.Before(j.Interface().(unversioned.Time)), nil
+ }
+ // fallback to the fields comparison
+ for idx := 0; idx < i.NumField(); idx++ {
+ less, err := isLess(i.Field(idx), j.Field(idx))
+ if err != nil || !less {
+ return less, err
+ }
+ }
+ return true, nil
+ case reflect.Array, reflect.Slice:
+ // note: the length of i and j may be different
+ for idx := 0; idx < integer.IntMin(i.Len(), j.Len()); idx++ {
+ less, err := isLess(i.Index(idx), j.Index(idx))
+ if err != nil || !less {
+ return less, err
+ }
+ }
+ return true, nil
default:
return false, fmt.Errorf("unsortable type: %v", i.Kind())
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/stop.go b/vendor/k8s.io/kubernetes/pkg/kubectl/stop.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/stop.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/stop.go
index 9112decf7ed5ff1a830c1fb106111e801f2bdaaa..d784ef24ce2b7363a0133da3a8f2039bcf1797ec 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/stop.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubectl/stop.go
@@ -314,9 +314,9 @@ func (reaper *DaemonSetReaper) Stop(namespace, name string, timeout time.Duratio
}
func (reaper *JobReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error {
- jobs := reaper.Extensions().Jobs(namespace)
+ jobs := reaper.Batch().Jobs(namespace)
pods := reaper.Pods(namespace)
- scaler, err := ScalerFor(extensions.Kind("Job"), *reaper)
+ scaler, err := ScalerFor(batch.Kind("Job"), *reaper)
if err != nil {
return err
}
@@ -367,7 +367,7 @@ func (reaper *DeploymentReaper) Stop(namespace, name string, timeout time.Durati
deployment, err := reaper.updateDeploymentWithRetries(namespace, name, func(d *extensions.Deployment) {
// set deployment's history and scale to 0
// TODO replace with patch when available: https://github.com/kubernetes/kubernetes/issues/20527
- d.Spec.RevisionHistoryLimit = util.IntPtr(0)
+ d.Spec.RevisionHistoryLimit = util.Int32Ptr(0)
d.Spec.Replicas = 0
d.Spec.Paused = true
})
@@ -378,7 +378,7 @@ func (reaper *DeploymentReaper) Stop(namespace, name string, timeout time.Durati
// Use observedGeneration to determine if the deployment controller noticed the pause.
if err := deploymentutil.WaitForObservedDeployment(func() (*extensions.Deployment, error) {
return deployments.Get(name)
- }, deployment.Generation, 10*time.Millisecond, 1*time.Minute); err != nil {
+ }, deployment.Generation, 1*time.Second, 1*time.Minute); err != nil {
return err
}
@@ -396,7 +396,8 @@ func (reaper *DeploymentReaper) Stop(namespace, name string, timeout time.Durati
errList := []error{}
for _, rc := range rsList.Items {
if err := rsReaper.Stop(rc.Namespace, rc.Name, timeout, gracePeriod); err != nil {
- if !errors.IsNotFound(err) {
+ scaleGetErr, ok := err.(*ScaleError)
+ if !errors.IsNotFound(err) || ok && !errors.IsNotFound(scaleGetErr.ActualError) {
errList = append(errList, err)
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/version.go b/vendor/k8s.io/kubernetes/pkg/kubectl/version.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/version.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/version.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/watchloop.go b/vendor/k8s.io/kubernetes/pkg/kubectl/watchloop.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/watchloop.go
rename to vendor/k8s.io/kubernetes/pkg/kubectl/watchloop.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/doc.go b/vendor/k8s.io/kubernetes/pkg/kubelet/qos/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/doc.go
rename to vendor/k8s.io/kubernetes/pkg/kubelet/qos/doc.go
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/qos/policy.go b/vendor/k8s.io/kubernetes/pkg/kubelet/qos/policy.go
new file mode 100644
index 0000000000000000000000000000000000000000..511e629fadfee931c223bde73a15c54452fdbd36
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/qos/policy.go
@@ -0,0 +1,67 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 qos
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/kubelet/qos/util"
+)
+
+const (
+ PodInfraOOMAdj int = -999
+ KubeletOOMScoreAdj int = -999
+ KubeProxyOOMScoreAdj int = -999
+ guaranteedOOMScoreAdj int = -998
+ besteffortOOMScoreAdj int = 1000
+)
+
+// GetContainerOOMAdjust returns the amount by which the OOM score of all processes in the
+// container should be adjusted.
+// The OOM score of a process is the percentage of memory it consumes
+// multiplied by 10 (barring exceptional cases) + a configurable quantity which is between -1000
+// and 1000. Containers with higher OOM scores are killed if the system runs out of memory.
+// See https://lwn.net/Articles/391222/ for more information.
+func GetContainerOOMScoreAdjust(pod *api.Pod, container *api.Container, memoryCapacity int64) int {
+ switch util.GetPodQos(pod) {
+ case util.Guaranteed:
+ // Guaranteed containers should be the last to get killed.
+ return guaranteedOOMScoreAdj
+ case util.BestEffort:
+ return besteffortOOMScoreAdj
+ }
+
+ // Burstable containers are a middle tier, between Guaranteed and Best-Effort. Ideally,
+ // we want to protect Burstable containers that consume less memory than requested.
+ // The formula below is a heuristic. A container requesting for 10% of a system's
+ // memory will have an OOM score adjust of 900. If a process in container Y
+ // uses over 10% of memory, its OOM score will be 1000. The idea is that containers
+ // which use more than their request will have an OOM score of 1000 and will be prime
+ // targets for OOM kills.
+ // Note that this is a heuristic, it won't work if a container has many small processes.
+ memoryRequest := container.Resources.Requests.Memory().Value()
+ oomScoreAdjust := 1000 - (1000*memoryRequest)/memoryCapacity
+ // A guaranteed pod using 100% of memory can have an OOM score of 1. Ensure
+ // that burstable pods have a higher OOM score adjustment.
+ if oomScoreAdjust < 2 {
+ return 2
+ }
+ // Give burstable pods a higher chance of survival over besteffort pods.
+ if int(oomScoreAdjust) == besteffortOOMScoreAdj {
+ return int(oomScoreAdjust - 1)
+ }
+ return int(oomScoreAdjust)
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go b/vendor/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go
similarity index 57%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go
rename to vendor/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go
index af415c2acb40f8117aefd1705a5509cdad63a4b0..9d7a5786a3b3dd77c5fc70dcb9696410656115e6 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go
@@ -18,6 +18,7 @@ package util
import (
"k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/resource"
)
const (
@@ -46,9 +47,70 @@ func isResourceBestEffort(container *api.Container, resource api.ResourceName) b
return !hasReq || req.Value() == 0
}
-// GetQos returns a mapping of resource name to QoS class of a container
-func GetQoS(container *api.Container) map[api.ResourceName]string {
- resourceToQoS := map[api.ResourceName]string{}
+// GetPodQos returns the QoS class of a pod.
+// A pod is besteffort if none of its containers have specified any requests or limits.
+// A pod is guaranteed only when requests and limits are specified for all the containers and they are equal.
+// A pod is burstable if limits and requests do not match across all containers.
+func GetPodQos(pod *api.Pod) string {
+ requests := api.ResourceList{}
+ limits := api.ResourceList{}
+ zeroQuantity := resource.MustParse("0")
+ isGuaranteed := true
+ for _, container := range pod.Spec.Containers {
+ // process requests
+ for name, quantity := range container.Resources.Requests {
+ if quantity.Cmp(zeroQuantity) == 1 {
+ delta := quantity.Copy()
+ if _, exists := requests[name]; !exists {
+ requests[name] = *delta
+ } else {
+ delta.Add(requests[name])
+ requests[name] = *delta
+ }
+ }
+ }
+ // process limits
+ for name, quantity := range container.Resources.Limits {
+ if quantity.Cmp(zeroQuantity) == 1 {
+ delta := quantity.Copy()
+ if _, exists := limits[name]; !exists {
+ limits[name] = *delta
+ } else {
+ delta.Add(limits[name])
+ limits[name] = *delta
+ }
+ }
+ }
+ if len(container.Resources.Limits) != len(supportedComputeResources) {
+ isGuaranteed = false
+ }
+ }
+ if len(requests) == 0 && len(limits) == 0 {
+ return BestEffort
+ }
+ // Check is requests match limits for all resources.
+ if isGuaranteed {
+ for name, req := range requests {
+ if lim, exists := limits[name]; !exists || lim.Cmp(req) != 0 {
+ isGuaranteed = false
+ break
+ }
+ }
+ }
+ if isGuaranteed &&
+ len(requests) == len(limits) &&
+ len(limits) == len(supportedComputeResources) {
+ return Guaranteed
+ }
+ return Burstable
+}
+
+// QoSList is a set of (resource name, QoS class) pairs.
+type QoSList map[api.ResourceName]string
+
+// GetQoS returns a mapping of resource name to QoS class of a container
+func GetQoS(container *api.Container) QoSList {
+ resourceToQoS := QoSList{}
for resource := range allResources(container) {
switch {
case isResourceGuaranteed(container, resource):
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/attach.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/attach.go
new file mode 100644
index 0000000000000000000000000000000000000000..0f9ba7ff5e30a2ad7f43796b91521267aa8eafef
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/attach.go
@@ -0,0 +1,53 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+
+ "k8s.io/kubernetes/pkg/types"
+ "k8s.io/kubernetes/pkg/util/runtime"
+)
+
+// Attacher knows how to attach to a running container in a pod.
+type Attacher interface {
+ // AttachContainer attaches to the running container in the pod, copying data between in/out/err
+ // and the container's stdin/stdout/stderr.
+ AttachContainer(name string, uid types.UID, container string, in io.Reader, out, err io.WriteCloser, tty bool) error
+}
+
+// ServeAttach handles requests to attach to a container. After creating/receiving the required
+// streams, it delegates the actual attaching to attacher.
+func ServeAttach(w http.ResponseWriter, req *http.Request, attacher Attacher, podName string, uid types.UID, container string, idleTimeout, streamCreationTimeout time.Duration, supportedProtocols []string) {
+ ctx, ok := createStreams(req, w, supportedProtocols, idleTimeout, streamCreationTimeout)
+ if !ok {
+ // error is handled by createStreams
+ return
+ }
+ defer ctx.conn.Close()
+
+ err := attacher.AttachContainer(podName, uid, container, ctx.stdinStream, ctx.stdoutStream, ctx.stderrStream, ctx.tty)
+ if err != nil {
+ msg := fmt.Sprintf("error attaching to container: %v", err)
+ runtime.HandleError(errors.New(msg))
+ fmt.Fprint(ctx.errorStream, msg)
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/contants.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/contants.go
new file mode 100644
index 0000000000000000000000000000000000000000..f45cc644032a18c626e38e32ed459033ff061620
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/contants.go
@@ -0,0 +1,36 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand
+
+import "time"
+
+const (
+ DefaultStreamCreationTimeout = 30 * time.Second
+
+ // The SPDY subprotocol "channel.k8s.io" is used for remote command
+ // attachment/execution. This represents the initial unversioned subprotocol,
+ // which has the known bugs http://issues.k8s.io/13394 and
+ // http://issues.k8s.io/13395.
+ StreamProtocolV1Name = "channel.k8s.io"
+
+ // The SPDY subprotocol "v2.channel.k8s.io" is used for remote command
+ // attachment/execution. It is the second version of the subprotocol and
+ // resolves the issues present in the first version.
+ StreamProtocolV2Name = "v2.channel.k8s.io"
+)
+
+var SupportedStreamingProtocols = []string{StreamProtocolV2Name, StreamProtocolV1Name}
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/doc.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..482e9afc1f622d96a4237224ba6a503684d3d8ee
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand contains functions related to executing commands in and attaching to pods.
+package remotecommand
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/exec.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/exec.go
new file mode 100644
index 0000000000000000000000000000000000000000..df9a4b5854e0a4783d486191409f44c22c5ffb74
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/exec.go
@@ -0,0 +1,57 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/types"
+ "k8s.io/kubernetes/pkg/util/runtime"
+)
+
+// Executor knows how to execute a command in a container in a pod.
+type Executor interface {
+ // ExecInContainer executes a command in a container in the pod, copying data
+ // between in/out/err and the container's stdin/stdout/stderr.
+ ExecInContainer(name string, uid types.UID, container string, cmd []string, in io.Reader, out, err io.WriteCloser, tty bool) error
+}
+
+// ServeExec handles requests to execute a command in a container. After
+// creating/receiving the required streams, it delegates the actual execution
+// to the executor.
+func ServeExec(w http.ResponseWriter, req *http.Request, executor Executor, podName string, uid types.UID, container string, idleTimeout, streamCreationTimeout time.Duration, supportedProtocols []string) {
+ ctx, ok := createStreams(req, w, supportedProtocols, idleTimeout, streamCreationTimeout)
+ if !ok {
+ // error is handled by createStreams
+ return
+ }
+ defer ctx.conn.Close()
+
+ cmd := req.URL.Query()[api.ExecCommandParamm]
+
+ err := executor.ExecInContainer(podName, uid, container, cmd, ctx.stdinStream, ctx.stdoutStream, ctx.stderrStream, ctx.tty)
+ if err != nil {
+ msg := fmt.Sprintf("error executing command in container: %v", err)
+ runtime.HandleError(errors.New(msg))
+ fmt.Fprint(ctx.errorStream, msg)
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/httpstream.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/httpstream.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b0c588e9fa7ac5bac550bccd23f9f6d3f532959
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/httpstream.go
@@ -0,0 +1,277 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/util/httpstream"
+ "k8s.io/kubernetes/pkg/util/httpstream/spdy"
+ "k8s.io/kubernetes/pkg/util/runtime"
+ "k8s.io/kubernetes/pkg/util/wsstream"
+
+ "github.com/golang/glog"
+)
+
+// options contains details about which streams are required for
+// remote command execution.
+type options struct {
+ stdin bool
+ stdout bool
+ stderr bool
+ tty bool
+ expectedStreams int
+}
+
+// newOptions creates a new options from the Request.
+func newOptions(req *http.Request) (*options, error) {
+ tty := req.FormValue(api.ExecTTYParam) == "1"
+ stdin := req.FormValue(api.ExecStdinParam) == "1"
+ stdout := req.FormValue(api.ExecStdoutParam) == "1"
+ stderr := req.FormValue(api.ExecStderrParam) == "1"
+ if tty && stderr {
+ // TODO: make this an error before we reach this method
+ glog.V(4).Infof("Access to exec with tty and stderr is not supported, bypassing stderr")
+ stderr = false
+ }
+
+ // count the streams client asked for, starting with 1
+ expectedStreams := 1
+ if stdin {
+ expectedStreams++
+ }
+ if stdout {
+ expectedStreams++
+ }
+ if stderr {
+ expectedStreams++
+ }
+
+ if expectedStreams == 1 {
+ return nil, fmt.Errorf("you must specify at least 1 of stdin, stdout, stderr")
+ }
+
+ return &options{
+ stdin: stdin,
+ stdout: stdout,
+ stderr: stderr,
+ tty: tty,
+ expectedStreams: expectedStreams,
+ }, nil
+}
+
+// context contains the connection and streams used when
+// forwarding an attach or execute session into a container.
+type context struct {
+ conn io.Closer
+ stdinStream io.ReadCloser
+ stdoutStream io.WriteCloser
+ stderrStream io.WriteCloser
+ errorStream io.WriteCloser
+ tty bool
+}
+
+// streamAndReply holds both a Stream and a channel that is closed when the stream's reply frame is
+// enqueued. Consumers can wait for replySent to be closed prior to proceeding, to ensure that the
+// replyFrame is enqueued before the connection's goaway frame is sent (e.g. if a stream was
+// received and right after, the connection gets closed).
+type streamAndReply struct {
+ httpstream.Stream
+ replySent <-chan struct{}
+}
+
+// waitStreamReply waits until either replySent or stop is closed. If replySent is closed, it sends
+// an empty struct to the notify channel.
+func waitStreamReply(replySent <-chan struct{}, notify chan<- struct{}, stop <-chan struct{}) {
+ select {
+ case <-replySent:
+ notify <- struct{}{}
+ case <-stop:
+ }
+}
+
+func createStreams(req *http.Request, w http.ResponseWriter, supportedStreamProtocols []string, idleTimeout, streamCreationTimeout time.Duration) (*context, bool) {
+ opts, err := newOptions(req)
+ if err != nil {
+ runtime.HandleError(err)
+ w.WriteHeader(http.StatusBadRequest)
+ fmt.Fprint(w, err.Error())
+ return nil, false
+ }
+
+ if wsstream.IsWebSocketRequest(req) {
+ return createWebSocketStreams(req, w, opts, idleTimeout)
+ }
+
+ protocol, err := httpstream.Handshake(req, w, supportedStreamProtocols)
+ if err != nil {
+ w.WriteHeader(http.StatusBadRequest)
+ fmt.Fprint(w, err.Error())
+ return nil, false
+ }
+
+ streamCh := make(chan streamAndReply)
+
+ upgrader := spdy.NewResponseUpgrader()
+ conn := upgrader.UpgradeResponse(w, req, func(stream httpstream.Stream, replySent <-chan struct{}) error {
+ streamCh <- streamAndReply{Stream: stream, replySent: replySent}
+ return nil
+ })
+ // from this point on, we can no longer call methods on response
+ if conn == nil {
+ // The upgrader is responsible for notifying the client of any errors that
+ // occurred during upgrading. All we can do is return here at this point
+ // if we weren't successful in upgrading.
+ return nil, false
+ }
+
+ conn.SetIdleTimeout(idleTimeout)
+
+ var handler protocolHandler
+ switch protocol {
+ case StreamProtocolV2Name:
+ handler = &v2ProtocolHandler{}
+ case "":
+ glog.V(4).Infof("Client did not request protocol negotiaion. Falling back to %q", StreamProtocolV1Name)
+ fallthrough
+ case StreamProtocolV1Name:
+ handler = &v1ProtocolHandler{}
+ }
+
+ expired := time.NewTimer(streamCreationTimeout)
+
+ ctx, err := handler.waitForStreams(streamCh, opts.expectedStreams, expired.C)
+ if err != nil {
+ runtime.HandleError(err)
+ return nil, false
+ }
+
+ ctx.conn = conn
+ ctx.tty = opts.tty
+ return ctx, true
+}
+
+type protocolHandler interface {
+ // waitForStreams waits for the expected streams or a timeout, returning a
+ // remoteCommandContext if all the streams were received, or an error if not.
+ waitForStreams(streams <-chan streamAndReply, expectedStreams int, expired <-chan time.Time) (*context, error)
+}
+
+// v2ProtocolHandler implements the V2 protocol version for streaming command execution.
+type v2ProtocolHandler struct{}
+
+func (*v2ProtocolHandler) waitForStreams(streams <-chan streamAndReply, expectedStreams int, expired <-chan time.Time) (*context, error) {
+ ctx := &context{}
+ receivedStreams := 0
+ replyChan := make(chan struct{})
+ stop := make(chan struct{})
+ defer close(stop)
+WaitForStreams:
+ for {
+ select {
+ case stream := <-streams:
+ streamType := stream.Headers().Get(api.StreamType)
+ switch streamType {
+ case api.StreamTypeError:
+ ctx.errorStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStdin:
+ ctx.stdinStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStdout:
+ ctx.stdoutStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStderr:
+ ctx.stderrStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ default:
+ runtime.HandleError(fmt.Errorf("Unexpected stream type: %q", streamType))
+ }
+ case <-replyChan:
+ receivedStreams++
+ if receivedStreams == expectedStreams {
+ break WaitForStreams
+ }
+ case <-expired:
+ // TODO find a way to return the error to the user. Maybe use a separate
+ // stream to report errors?
+ return nil, errors.New("timed out waiting for client to create streams")
+ }
+ }
+
+ return ctx, nil
+}
+
+// v1ProtocolHandler implements the V1 protocol version for streaming command execution.
+type v1ProtocolHandler struct{}
+
+func (*v1ProtocolHandler) waitForStreams(streams <-chan streamAndReply, expectedStreams int, expired <-chan time.Time) (*context, error) {
+ ctx := &context{}
+ receivedStreams := 0
+ replyChan := make(chan struct{})
+ stop := make(chan struct{})
+ defer close(stop)
+WaitForStreams:
+ for {
+ select {
+ case stream := <-streams:
+ streamType := stream.Headers().Get(api.StreamType)
+ switch streamType {
+ case api.StreamTypeError:
+ ctx.errorStream = stream
+
+ // This defer statement shouldn't be here, but due to previous refactoring, it ended up in
+ // here. This is what 1.0.x kubelets do, so we're retaining that behavior. This is fixed in
+ // the v2ProtocolHandler.
+ defer stream.Reset()
+
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStdin:
+ ctx.stdinStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStdout:
+ ctx.stdoutStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ case api.StreamTypeStderr:
+ ctx.stderrStream = stream
+ go waitStreamReply(stream.replySent, replyChan, stop)
+ default:
+ runtime.HandleError(fmt.Errorf("Unexpected stream type: %q", streamType))
+ }
+ case <-replyChan:
+ receivedStreams++
+ if receivedStreams == expectedStreams {
+ break WaitForStreams
+ }
+ case <-expired:
+ // TODO find a way to return the error to the user. Maybe use a separate
+ // stream to report errors?
+ return nil, errors.New("timed out waiting for client to create streams")
+ }
+ }
+
+ if ctx.stdinStream != nil {
+ ctx.stdinStream.Close()
+ }
+
+ return ctx, nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/websocket.go b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/websocket.go
new file mode 100644
index 0000000000000000000000000000000000000000..06a84c8e7d9eb57c49db57d9e4eec2e72414ee05
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/kubelet/server/remotecommand/websocket.go
@@ -0,0 +1,77 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 remotecommand
+
+import (
+ "net/http"
+ "time"
+
+ "k8s.io/kubernetes/pkg/httplog"
+ "k8s.io/kubernetes/pkg/util/wsstream"
+
+ "github.com/golang/glog"
+)
+
+// standardShellChannels returns the standard channel types for a shell connection (STDIN 0, STDOUT 1, STDERR 2)
+// along with the approximate duplex value. Supported subprotocols are "channel.k8s.io" and
+// "base64.channel.k8s.io".
+func standardShellChannels(stdin, stdout, stderr bool) []wsstream.ChannelType {
+ // open three half-duplex channels
+ channels := []wsstream.ChannelType{wsstream.ReadChannel, wsstream.WriteChannel, wsstream.WriteChannel}
+ if !stdin {
+ channels[0] = wsstream.IgnoreChannel
+ }
+ if !stdout {
+ channels[1] = wsstream.IgnoreChannel
+ }
+ if !stderr {
+ channels[2] = wsstream.IgnoreChannel
+ }
+ return channels
+}
+
+// createWebSocketStreams returns a remoteCommandContext containing the websocket connection and
+// streams needed to perform an exec or an attach.
+func createWebSocketStreams(req *http.Request, w http.ResponseWriter, opts *options, idleTimeout time.Duration) (*context, bool) {
+ // open the requested channels, and always open the error channel
+ channels := append(standardShellChannels(opts.stdin, opts.stdout, opts.stderr), wsstream.WriteChannel)
+ conn := wsstream.NewConn(channels...)
+ conn.SetIdleTimeout(idleTimeout)
+ streams, err := conn.Open(httplog.Unlogged(w), req)
+ if err != nil {
+ glog.Errorf("Unable to upgrade websocket connection: %v", err)
+ return nil, false
+ }
+ // Send an empty message to the lowest writable channel to notify the client the connection is established
+ // TODO: make generic to SPDY and WebSockets and do it outside of this method?
+ switch {
+ case opts.stdout:
+ streams[1].Write([]byte{})
+ case opts.stderr:
+ streams[2].Write([]byte{})
+ default:
+ streams[3].Write([]byte{})
+ }
+ return &context{
+ conn: conn,
+ stdinStream: streams[0],
+ stdoutStream: streams[1],
+ stderrStream: streams[2],
+ errorStream: streams[3],
+ tty: opts.tty,
+ }, true
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/doc.go b/vendor/k8s.io/kubernetes/pkg/labels/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/doc.go
rename to vendor/k8s.io/kubernetes/pkg/labels/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/labels.go b/vendor/k8s.io/kubernetes/pkg/labels/labels.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/labels.go
rename to vendor/k8s.io/kubernetes/pkg/labels/labels.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/selector.go b/vendor/k8s.io/kubernetes/pkg/labels/selector.go
similarity index 96%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/selector.go
rename to vendor/k8s.io/kubernetes/pkg/labels/selector.go
index fb48b10e9e00577637ab4bc2d69f2d9c28c40aef..ab64ecc80904cf7990f3ffab3554b51b1979ddca 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/labels/selector.go
+++ b/vendor/k8s.io/kubernetes/pkg/labels/selector.go
@@ -764,19 +764,16 @@ func parse(selector string) (internalSelector, error) {
return internalSelector(items), err
}
-var qualifiedNameErrorMsg string = fmt.Sprintf(`must be a qualified name (at most %d characters, matching regex %s), with an optional DNS subdomain prefix (at most %d characters, matching regex %s) and slash (/): e.g. "MyName" or "example.com/MyName"`, validation.QualifiedNameMaxLength, validation.QualifiedNameFmt, validation.DNS1123SubdomainMaxLength, validation.DNS1123SubdomainFmt)
-var labelValueErrorMsg string = fmt.Sprintf(`must have at most %d characters, matching regex %s: e.g. "MyValue" or ""`, validation.LabelValueMaxLength, validation.LabelValueFmt)
-
func validateLabelKey(k string) error {
- if !validation.IsQualifiedName(k) {
- return fmt.Errorf("invalid label key: %s", qualifiedNameErrorMsg)
+ if errs := validation.IsQualifiedName(k); len(errs) != 0 {
+ return fmt.Errorf("invalid label key %q: %s", k, strings.Join(errs, "; "))
}
return nil
}
func validateLabelValue(v string) error {
- if !validation.IsValidLabelValue(v) {
- return fmt.Errorf("invalid label value: %s", labelValueErrorMsg)
+ if errs := validation.IsValidLabelValue(v); len(errs) != 0 {
+ return fmt.Errorf("invalid label value: %q: %s", v, strings.Join(errs, "; "))
}
return nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/master/ports/doc.go b/vendor/k8s.io/kubernetes/pkg/master/ports/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/master/ports/doc.go
rename to vendor/k8s.io/kubernetes/pkg/master/ports/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/master/ports/ports.go b/vendor/k8s.io/kubernetes/pkg/master/ports/ports.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/master/ports/ports.go
rename to vendor/k8s.io/kubernetes/pkg/master/ports/ports.go
index 3e36603acaec912ff257edc7e458af03adbc1047..246a1a562d3a6feeff4f6948ec773cfdbcab13ef 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/master/ports/ports.go
+++ b/vendor/k8s.io/kubernetes/pkg/master/ports/ports.go
@@ -18,7 +18,7 @@ package ports
const (
// ProxyPort is the default port for the proxy healthz server.
- // May be overriden by a flag at startup.
+ // May be overridden by a flag at startup.
ProxyStatusPort = 10249
// KubeletPort is the default port for the kubelet server on each host machine.
// May be overridden by a flag at startup.
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/generic/doc.go b/vendor/k8s.io/kubernetes/pkg/registry/generic/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..2486e9b74266714dc8ea8a13e054b9168b127bd5
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/generic/doc.go
@@ -0,0 +1,19 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 generic provides a generic object store interface and a
+// generic label/field matching type.
+package generic
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/generic/matcher.go b/vendor/k8s.io/kubernetes/pkg/registry/generic/matcher.go
new file mode 100644
index 0000000000000000000000000000000000000000..08e2df7b4563953365d3aabae73c228c687a49af
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/generic/matcher.go
@@ -0,0 +1,142 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 generic
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/fields"
+ "k8s.io/kubernetes/pkg/labels"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// AttrFunc returns label and field sets for List or Watch to compare against, or an error.
+type AttrFunc func(obj runtime.Object) (label labels.Set, field fields.Set, err error)
+
+// ObjectMetaFieldsSet returns a fields set that represents the ObjectMeta.
+func ObjectMetaFieldsSet(objectMeta api.ObjectMeta, hasNamespaceField bool) fields.Set {
+ if !hasNamespaceField {
+ return fields.Set{
+ "metadata.name": objectMeta.Name,
+ }
+ }
+ return fields.Set{
+ "metadata.name": objectMeta.Name,
+ "metadata.namespace": objectMeta.Namespace,
+ }
+}
+
+// MergeFieldsSets merges a fields'set from fragment into the source.
+func MergeFieldsSets(source fields.Set, fragment fields.Set) fields.Set {
+ for k, value := range fragment {
+ source[k] = value
+ }
+ return source
+}
+
+// SelectionPredicate implements a generic predicate that can be passed to
+// GenericRegistry's List or Watch methods. Implements the Matcher interface.
+type SelectionPredicate struct {
+ Label labels.Selector
+ Field fields.Selector
+ GetAttrs AttrFunc
+}
+
+// Matches returns true if the given object's labels and fields (as
+// returned by s.GetAttrs) match s.Label and s.Field. An error is
+// returned if s.GetAttrs fails.
+func (s *SelectionPredicate) Matches(obj runtime.Object) (bool, error) {
+ if s.Label.Empty() && s.Field.Empty() {
+ return true, nil
+ }
+ labels, fields, err := s.GetAttrs(obj)
+ if err != nil {
+ return false, err
+ }
+ return s.Label.Matches(labels) && s.Field.Matches(fields), nil
+}
+
+// MatchesSingle will return (name, true) if and only if s.Field matches on the object's
+// name.
+func (s *SelectionPredicate) MatchesSingle() (string, bool) {
+ // TODO: should be namespace.name
+ if name, ok := s.Field.RequiresExactMatch("metadata.name"); ok {
+ return name, true
+ }
+ return "", false
+}
+
+// Matcher can return true if an object matches the Matcher's selection
+// criteria. If it is known that the matcher will match only a single object
+// then MatchesSingle should return the key of that object and true. This is an
+// optimization only--Matches() should continue to work.
+type Matcher interface {
+ // Matches should return true if obj matches this matcher's requirements.
+ Matches(obj runtime.Object) (matchesThisObject bool, err error)
+
+ // If this matcher matches a single object, return the key for that
+ // object and true here. This will greatly increase efficiency. You
+ // must still implement Matches(). Note that key does NOT need to
+ // include the object's namespace.
+ MatchesSingle() (key string, matchesSingleObject bool)
+
+ // TODO: when we start indexing objects, add something like the below:
+ // MatchesIndices() (indexName []string, indexValue []string)
+ // where indexName/indexValue are the same length.
+}
+
+// MatcherFunc makes a matcher from the provided function. For easy definition
+// of matchers for testing. Note: use SelectionPredicate above for real code!
+func MatcherFunc(f func(obj runtime.Object) (bool, error)) Matcher {
+ return matcherFunc(f)
+}
+
+type matcherFunc func(obj runtime.Object) (bool, error)
+
+// Matches calls the embedded function.
+func (m matcherFunc) Matches(obj runtime.Object) (bool, error) {
+ return m(obj)
+}
+
+// MatchesSingle always returns "", false-- because this is a predicate
+// implementation of Matcher.
+func (m matcherFunc) MatchesSingle() (string, bool) {
+ return "", false
+}
+
+// MatchOnKey returns a matcher that will send only the object matching key
+// through the matching function f. For testing!
+// Note: use SelectionPredicate above for real code!
+func MatchOnKey(key string, f func(obj runtime.Object) (bool, error)) Matcher {
+ return matchKey{key, f}
+}
+
+type matchKey struct {
+ key string
+ matcherFunc
+}
+
+// MatchesSingle always returns its key, true.
+func (m matchKey) MatchesSingle() (string, bool) {
+ return m.key, true
+}
+
+var (
+ // Assert implementations match the interface.
+ _ = Matcher(matchKey{})
+ _ = Matcher(&SelectionPredicate{})
+ _ = Matcher(matcherFunc(nil))
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/generic/options.go b/vendor/k8s.io/kubernetes/pkg/registry/generic/options.go
new file mode 100644
index 0000000000000000000000000000000000000000..eea52c995b13cf764d3cab08f977532ad407ef10
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/generic/options.go
@@ -0,0 +1,28 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 generic
+
+import (
+ pkgstorage "k8s.io/kubernetes/pkg/storage"
+)
+
+// RESTOptions is set of configuration options to generic registries.
+type RESTOptions struct {
+ Storage pkgstorage.Interface
+ Decorator StorageDecorator
+ DeleteCollectionWorkers int
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/generic/storage_decorator.go b/vendor/k8s.io/kubernetes/pkg/registry/generic/storage_decorator.go
new file mode 100644
index 0000000000000000000000000000000000000000..70109efe3364194cdbf4b7997c5159305af85794
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/generic/storage_decorator.go
@@ -0,0 +1,44 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 generic
+
+import (
+ "k8s.io/kubernetes/pkg/api/rest"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/storage"
+)
+
+// StorageDecorator is a function signature for producing
+// a storage.Interface from given parameters.
+type StorageDecorator func(
+ storageInterface storage.Interface,
+ capacity int,
+ objectType runtime.Object,
+ resourcePrefix string,
+ scopeStrategy rest.NamespaceScopedStrategy,
+ newListFunc func() runtime.Object) storage.Interface
+
+// Returns given 'storageInterface' without any decoration.
+func UndecoratedStorage(
+ storageInterface storage.Interface,
+ capacity int,
+ objectType runtime.Object,
+ resourcePrefix string,
+ scopeStrategy rest.NamespaceScopedStrategy,
+ newListFunc func() runtime.Object) storage.Interface {
+ return storageInterface
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/codec.go b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/codec.go
new file mode 100644
index 0000000000000000000000000000000000000000..758ffd46625d16b35a2ac2b4adbf020e00af8342
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/codec.go
@@ -0,0 +1,574 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 thirdpartyresourcedata
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/url"
+ "strings"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ apiutil "k8s.io/kubernetes/pkg/api/util"
+ "k8s.io/kubernetes/pkg/api/v1"
+ "k8s.io/kubernetes/pkg/apimachinery/registered"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/sets"
+ "k8s.io/kubernetes/pkg/util/yaml"
+ "k8s.io/kubernetes/pkg/watch/versioned"
+)
+
+type thirdPartyObjectConverter struct {
+ converter runtime.ObjectConvertor
+}
+
+func (t *thirdPartyObjectConverter) ConvertToVersion(in runtime.Object, outVersion unversioned.GroupVersion) (out runtime.Object, err error) {
+ switch in.(type) {
+ // This seems weird, but in this case the ThirdPartyResourceData is really just a wrapper on the raw 3rd party data.
+ // The actual thing printed/sent to server is the actual raw third party resource data, which only has one version.
+ case *extensions.ThirdPartyResourceData:
+ return in, nil
+ default:
+ return t.converter.ConvertToVersion(in, outVersion)
+ }
+}
+
+func (t *thirdPartyObjectConverter) Convert(in, out interface{}) error {
+ return t.converter.Convert(in, out)
+}
+
+func (t *thirdPartyObjectConverter) ConvertFieldLabel(version, kind, label, value string) (string, string, error) {
+ return t.converter.ConvertFieldLabel(version, kind, label, value)
+}
+
+func NewThirdPartyObjectConverter(converter runtime.ObjectConvertor) runtime.ObjectConvertor {
+ return &thirdPartyObjectConverter{converter}
+}
+
+type thirdPartyResourceDataMapper struct {
+ mapper meta.RESTMapper
+ kind string
+ version string
+ group string
+}
+
+var _ meta.RESTMapper = &thirdPartyResourceDataMapper{}
+
+func (t *thirdPartyResourceDataMapper) getResource() unversioned.GroupVersionResource {
+ plural, _ := meta.KindToResource(t.getKind())
+
+ return plural
+}
+
+func (t *thirdPartyResourceDataMapper) getKind() unversioned.GroupVersionKind {
+ return unversioned.GroupVersionKind{Group: t.group, Version: t.version, Kind: t.kind}
+}
+
+func (t *thirdPartyResourceDataMapper) isThirdPartyResource(partialResource unversioned.GroupVersionResource) bool {
+ actualResource := t.getResource()
+ if strings.ToLower(partialResource.Resource) != strings.ToLower(actualResource.Resource) {
+ return false
+ }
+ if len(partialResource.Group) != 0 && partialResource.Group != actualResource.Group {
+ return false
+ }
+ if len(partialResource.Version) != 0 && partialResource.Version != actualResource.Version {
+ return false
+ }
+
+ return true
+}
+
+func (t *thirdPartyResourceDataMapper) ResourcesFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+ if t.isThirdPartyResource(resource) {
+ return []unversioned.GroupVersionResource{t.getResource()}, nil
+ }
+ return t.mapper.ResourcesFor(resource)
+}
+
+func (t *thirdPartyResourceDataMapper) KindsFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
+ if t.isThirdPartyResource(resource) {
+ return []unversioned.GroupVersionKind{t.getKind()}, nil
+ }
+ return t.mapper.KindsFor(resource)
+}
+
+func (t *thirdPartyResourceDataMapper) ResourceFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
+ if t.isThirdPartyResource(resource) {
+ return t.getResource(), nil
+ }
+ return t.mapper.ResourceFor(resource)
+}
+
+func (t *thirdPartyResourceDataMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
+ if t.isThirdPartyResource(resource) {
+ return t.getKind(), nil
+ }
+ return t.mapper.KindFor(resource)
+}
+
+func (t *thirdPartyResourceDataMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*meta.RESTMapping, error) {
+ if len(versions) != 1 {
+ return nil, fmt.Errorf("unexpected set of versions: %v", versions)
+ }
+ if gk.Group != t.group {
+ return nil, fmt.Errorf("unknown group %q expected %s", gk.Group, t.group)
+ }
+ if gk.Kind != "ThirdPartyResourceData" {
+ return nil, fmt.Errorf("unknown kind %s expected %s", gk.Kind, t.kind)
+ }
+ if versions[0] != t.version {
+ return nil, fmt.Errorf("unknown version %q expected %q", versions[0], t.version)
+ }
+
+ // TODO figure out why we're doing this rewriting
+ extensionGK := unversioned.GroupKind{Group: extensions.GroupName, Kind: "ThirdPartyResourceData"}
+
+ mapping, err := t.mapper.RESTMapping(extensionGK, registered.GroupOrDie(extensions.GroupName).GroupVersion.Version)
+ if err != nil {
+ return nil, err
+ }
+ mapping.ObjectConvertor = &thirdPartyObjectConverter{mapping.ObjectConvertor}
+ return mapping, nil
+}
+
+func (t *thirdPartyResourceDataMapper) AliasesForResource(resource string) ([]string, bool) {
+ return t.mapper.AliasesForResource(resource)
+}
+
+func (t *thirdPartyResourceDataMapper) ResourceSingularizer(resource string) (singular string, err error) {
+ return t.mapper.ResourceSingularizer(resource)
+}
+
+func NewMapper(mapper meta.RESTMapper, kind, version, group string) meta.RESTMapper {
+ return &thirdPartyResourceDataMapper{
+ mapper: mapper,
+ kind: kind,
+ version: version,
+ group: group,
+ }
+}
+
+type thirdPartyResourceDataCodecFactory struct {
+ delegate runtime.NegotiatedSerializer
+ kind string
+ encodeGV unversioned.GroupVersion
+ decodeGV unversioned.GroupVersion
+}
+
+func NewNegotiatedSerializer(s runtime.NegotiatedSerializer, kind string, encodeGV, decodeGV unversioned.GroupVersion) runtime.NegotiatedSerializer {
+ return &thirdPartyResourceDataCodecFactory{
+ delegate: s,
+ kind: kind,
+ encodeGV: encodeGV,
+ decodeGV: decodeGV,
+ }
+}
+
+func (t *thirdPartyResourceDataCodecFactory) SupportedMediaTypes() []string {
+ supported := sets.NewString(t.delegate.SupportedMediaTypes()...)
+ return supported.Intersection(sets.NewString("application/json", "application/yaml")).List()
+}
+
+func (t *thirdPartyResourceDataCodecFactory) SerializerForMediaType(mediaType string, params map[string]string) (runtime.SerializerInfo, bool) {
+ switch mediaType {
+ case "application/json", "application/yaml":
+ return t.delegate.SerializerForMediaType(mediaType, params)
+ default:
+ return runtime.SerializerInfo{}, false
+ }
+}
+
+func (t *thirdPartyResourceDataCodecFactory) SupportedStreamingMediaTypes() []string {
+ supported := sets.NewString(t.delegate.SupportedStreamingMediaTypes()...)
+ return supported.Intersection(sets.NewString("application/json", "application/json;stream=watch")).List()
+}
+
+func (t *thirdPartyResourceDataCodecFactory) StreamingSerializerForMediaType(mediaType string, params map[string]string) (runtime.StreamSerializerInfo, bool) {
+ switch mediaType {
+ case "application/json", "application/json;stream=watch":
+ return t.delegate.StreamingSerializerForMediaType(mediaType, params)
+ default:
+ return runtime.StreamSerializerInfo{}, false
+ }
+}
+
+func (t *thirdPartyResourceDataCodecFactory) EncoderForVersion(s runtime.Encoder, gv unversioned.GroupVersion) runtime.Encoder {
+ return &thirdPartyResourceDataEncoder{delegate: t.delegate.EncoderForVersion(s, gv), gvk: gv.WithKind(t.kind)}
+}
+
+func (t *thirdPartyResourceDataCodecFactory) DecoderToVersion(s runtime.Decoder, gv unversioned.GroupVersion) runtime.Decoder {
+ return NewDecoder(t.delegate.DecoderToVersion(s, gv), t.kind)
+}
+
+func NewCodec(delegate runtime.Codec, gvk unversioned.GroupVersionKind) runtime.Codec {
+ return runtime.NewCodec(NewEncoder(delegate, gvk), NewDecoder(delegate, gvk.Kind))
+}
+
+type thirdPartyResourceDataDecoder struct {
+ delegate runtime.Decoder
+ kind string
+}
+
+func NewDecoder(delegate runtime.Decoder, kind string) runtime.Decoder {
+ return &thirdPartyResourceDataDecoder{delegate: delegate, kind: kind}
+}
+
+var _ runtime.Decoder = &thirdPartyResourceDataDecoder{}
+
+func parseObject(data []byte) (map[string]interface{}, error) {
+ var obj interface{}
+ if err := json.Unmarshal(data, &obj); err != nil {
+ return nil, err
+ }
+ mapObj, ok := obj.(map[string]interface{})
+ if !ok {
+ return nil, fmt.Errorf("unexpected object: %#v", obj)
+ }
+ return mapObj, nil
+}
+
+func (t *thirdPartyResourceDataDecoder) populate(data []byte) (runtime.Object, error) {
+ mapObj, err := parseObject(data)
+ if err != nil {
+ return nil, err
+ }
+ return t.populateFromObject(mapObj, data)
+}
+
+func (t *thirdPartyResourceDataDecoder) populateFromObject(mapObj map[string]interface{}, data []byte) (runtime.Object, error) {
+ typeMeta := unversioned.TypeMeta{}
+ if err := json.Unmarshal(data, &typeMeta); err != nil {
+ return nil, err
+ }
+ isList := strings.HasSuffix(typeMeta.Kind, "List")
+ switch {
+ case !isList && (len(t.kind) == 0 || typeMeta.Kind == t.kind):
+ result := &extensions.ThirdPartyResourceData{}
+ if err := t.populateResource(result, mapObj, data); err != nil {
+ return nil, err
+ }
+ return result, nil
+ case isList && (len(t.kind) == 0 || typeMeta.Kind == t.kind+"List"):
+ list := &extensions.ThirdPartyResourceDataList{}
+ if err := t.populateListResource(list, mapObj); err != nil {
+ return nil, err
+ }
+ return list, nil
+ default:
+ return nil, fmt.Errorf("unexpected kind: %s, expected %s", typeMeta.Kind, t.kind)
+ }
+}
+
+func (t *thirdPartyResourceDataDecoder) populateResource(objIn *extensions.ThirdPartyResourceData, mapObj map[string]interface{}, data []byte) error {
+ metadata, ok := mapObj["metadata"].(map[string]interface{})
+ if !ok {
+ return fmt.Errorf("unexpected object for metadata: %#v", mapObj["metadata"])
+ }
+
+ metadataData, err := json.Marshal(metadata)
+ if err != nil {
+ return err
+ }
+
+ if err := json.Unmarshal(metadataData, &objIn.ObjectMeta); err != nil {
+ return err
+ }
+ // Override API Version with the ThirdPartyResourceData value
+ // TODO: fix this hard code
+ objIn.APIVersion = v1beta1.SchemeGroupVersion.String()
+
+ objIn.Data = data
+ return nil
+}
+
+func IsThirdPartyObject(rawData []byte, gvk *unversioned.GroupVersionKind) (isThirdParty bool, gvkOut *unversioned.GroupVersionKind, err error) {
+ var gv unversioned.GroupVersion
+ if gvk == nil {
+ data, err := yaml.ToJSON(rawData)
+ if err != nil {
+ return false, nil, err
+ }
+ metadata := unversioned.TypeMeta{}
+ if err = json.Unmarshal(data, &metadata); err != nil {
+ return false, nil, err
+ }
+ gv, err = unversioned.ParseGroupVersion(metadata.APIVersion)
+ if err != nil {
+ return false, nil, err
+ }
+ gvkOut = &unversioned.GroupVersionKind{
+ Group: gv.Group,
+ Version: gv.Version,
+ Kind: metadata.Kind,
+ }
+ } else {
+ gv = gvk.GroupVersion()
+ gvkOut = gvk
+ }
+ return registered.IsThirdPartyAPIGroupVersion(gv), gvkOut, nil
+}
+
+func (t *thirdPartyResourceDataDecoder) Decode(data []byte, gvk *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ if into == nil {
+ if gvk == nil || gvk.Kind != t.kind {
+ if isThirdParty, _, err := IsThirdPartyObject(data, gvk); err != nil {
+ return nil, nil, err
+ } else if !isThirdParty {
+ return t.delegate.Decode(data, gvk, into)
+ }
+ }
+ obj, err := t.populate(data)
+ if err != nil {
+ return nil, nil, err
+ }
+ return obj, gvk, nil
+ }
+ switch o := into.(type) {
+ case *extensions.ThirdPartyResourceData:
+ break
+ case *runtime.VersionedObjects:
+ // We're not sure that it's third party, we need to test
+ if gvk == nil || gvk.Kind != t.kind {
+ if isThirdParty, _, err := IsThirdPartyObject(data, gvk); err != nil {
+ return nil, nil, err
+ } else if !isThirdParty {
+ return t.delegate.Decode(data, gvk, into)
+ }
+ }
+ obj, err := t.populate(data)
+ if err != nil {
+ return nil, nil, err
+ }
+ o.Objects = []runtime.Object{
+ obj,
+ }
+ return o, gvk, nil
+ default:
+ return t.delegate.Decode(data, gvk, into)
+ }
+
+ thirdParty := into.(*extensions.ThirdPartyResourceData)
+ var dataObj interface{}
+ if err := json.Unmarshal(data, &dataObj); err != nil {
+ return nil, nil, err
+ }
+ mapObj, ok := dataObj.(map[string]interface{})
+ if !ok {
+
+ return nil, nil, fmt.Errorf("unexpected object: %#v", dataObj)
+ }
+ /*if gvk.Kind != "ThirdPartyResourceData" {
+ return nil, nil, fmt.Errorf("unexpected kind: %s", gvk.Kind)
+ }*/
+ actual := &unversioned.GroupVersionKind{}
+ if kindObj, found := mapObj["kind"]; !found {
+ if gvk == nil {
+ return nil, nil, runtime.NewMissingKindErr(string(data))
+ }
+ mapObj["kind"] = gvk.Kind
+ actual.Kind = gvk.Kind
+ } else {
+ kindStr, ok := kindObj.(string)
+ if !ok {
+ return nil, nil, fmt.Errorf("unexpected object for 'kind': %v", kindObj)
+ }
+ if len(t.kind) > 0 && kindStr != t.kind {
+ return nil, nil, fmt.Errorf("kind doesn't match, expecting: %s, got %s", gvk.Kind, kindStr)
+ }
+ actual.Kind = kindStr
+ }
+ if versionObj, found := mapObj["apiVersion"]; !found {
+ if gvk == nil {
+ return nil, nil, runtime.NewMissingVersionErr(string(data))
+ }
+ mapObj["apiVersion"] = gvk.GroupVersion().String()
+ actual.Group, actual.Version = gvk.Group, gvk.Version
+ } else {
+ versionStr, ok := versionObj.(string)
+ if !ok {
+ return nil, nil, fmt.Errorf("unexpected object for 'apiVersion': %v", versionObj)
+ }
+ if gvk != nil && versionStr != gvk.GroupVersion().String() {
+ return nil, nil, fmt.Errorf("version doesn't match, expecting: %v, got %s", gvk.GroupVersion(), versionStr)
+ }
+ gv, err := unversioned.ParseGroupVersion(versionStr)
+ if err != nil {
+ return nil, nil, err
+ }
+ actual.Group, actual.Version = gv.Group, gv.Version
+ }
+
+ mapObj, err := parseObject(data)
+ if err != nil {
+ return nil, actual, err
+ }
+ if err := t.populateResource(thirdParty, mapObj, data); err != nil {
+ return nil, actual, err
+ }
+ return thirdParty, actual, nil
+}
+
+func (t *thirdPartyResourceDataDecoder) populateListResource(objIn *extensions.ThirdPartyResourceDataList, mapObj map[string]interface{}) error {
+ items, ok := mapObj["items"].([]interface{})
+ if !ok {
+ return fmt.Errorf("unexpected object for items: %#v", mapObj["items"])
+ }
+ objIn.Items = make([]extensions.ThirdPartyResourceData, len(items))
+ for ix := range items {
+ objData, err := json.Marshal(items[ix])
+ if err != nil {
+ return err
+ }
+ objMap, err := parseObject(objData)
+ if err != nil {
+ return err
+ }
+ if err := t.populateResource(&objIn.Items[ix], objMap, objData); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+const template = `{
+ "kind": "%s",
+ "apiVersion": "%s",
+ "metadata": {},
+ "items": [ %s ]
+}`
+
+type thirdPartyResourceDataEncoder struct {
+ delegate runtime.Encoder
+ gvk unversioned.GroupVersionKind
+}
+
+func NewEncoder(delegate runtime.Encoder, gvk unversioned.GroupVersionKind) runtime.Encoder {
+ return &thirdPartyResourceDataEncoder{delegate: delegate, gvk: gvk}
+}
+
+var _ runtime.Encoder = &thirdPartyResourceDataEncoder{}
+
+func encodeToJSON(obj *extensions.ThirdPartyResourceData, stream io.Writer) error {
+ var objOut interface{}
+ if err := json.Unmarshal(obj.Data, &objOut); err != nil {
+ return err
+ }
+ objMap, ok := objOut.(map[string]interface{})
+ if !ok {
+ return fmt.Errorf("unexpected type: %v", objOut)
+ }
+ objMap["metadata"] = obj.ObjectMeta
+ encoder := json.NewEncoder(stream)
+ return encoder.Encode(objMap)
+}
+
+func (t *thirdPartyResourceDataEncoder) Encode(obj runtime.Object, stream io.Writer) (err error) {
+ switch obj := obj.(type) {
+ case *extensions.ThirdPartyResourceData:
+ return encodeToJSON(obj, stream)
+ case *extensions.ThirdPartyResourceDataList:
+ // TODO: There must be a better way to do this...
+ dataStrings := make([]string, len(obj.Items))
+ for ix := range obj.Items {
+ buff := &bytes.Buffer{}
+ err := encodeToJSON(&obj.Items[ix], buff)
+ if err != nil {
+ return err
+ }
+ dataStrings[ix] = buff.String()
+ }
+ gv := t.gvk.GroupVersion()
+ fmt.Fprintf(stream, template, t.gvk.Kind+"List", gv.String(), strings.Join(dataStrings, ","))
+ return nil
+ case *versioned.InternalEvent:
+ event := &versioned.Event{}
+ err := versioned.Convert_versioned_InternalEvent_to_versioned_Event(obj, event, nil)
+ if err != nil {
+ return err
+ }
+
+ enc := json.NewEncoder(stream)
+ err = enc.Encode(event)
+ if err != nil {
+ return err
+ }
+
+ return nil
+ case *unversioned.Status, *unversioned.APIResourceList:
+ return t.delegate.Encode(obj, stream)
+ default:
+ return fmt.Errorf("unexpected object to encode: %#v", obj)
+ }
+}
+
+func NewObjectCreator(group, version string, delegate runtime.ObjectCreater) runtime.ObjectCreater {
+ return &thirdPartyResourceDataCreator{group, version, delegate}
+}
+
+type thirdPartyResourceDataCreator struct {
+ group string
+ version string
+ delegate runtime.ObjectCreater
+}
+
+func (t *thirdPartyResourceDataCreator) New(kind unversioned.GroupVersionKind) (out runtime.Object, err error) {
+ switch kind.Kind {
+ case "ThirdPartyResourceData":
+ if apiutil.GetGroupVersion(t.group, t.version) != kind.GroupVersion().String() {
+ return nil, fmt.Errorf("unknown kind %v", kind)
+ }
+ return &extensions.ThirdPartyResourceData{}, nil
+ case "ThirdPartyResourceDataList":
+ if apiutil.GetGroupVersion(t.group, t.version) != kind.GroupVersion().String() {
+ return nil, fmt.Errorf("unknown kind %v", kind)
+ }
+ return &extensions.ThirdPartyResourceDataList{}, nil
+ // TODO: this list needs to be formalized higher in the chain
+ case "ListOptions", "WatchEvent":
+ if apiutil.GetGroupVersion(t.group, t.version) == kind.GroupVersion().String() {
+ // Translate third party group to external group.
+ gvk := registered.EnabledVersionsForGroup(api.GroupName)[0].WithKind(kind.Kind)
+ return t.delegate.New(gvk)
+ }
+ return t.delegate.New(kind)
+ default:
+ return t.delegate.New(kind)
+ }
+}
+
+func NewThirdPartyParameterCodec(p runtime.ParameterCodec) runtime.ParameterCodec {
+ return &thirdPartyParameterCodec{p}
+}
+
+type thirdPartyParameterCodec struct {
+ delegate runtime.ParameterCodec
+}
+
+func (t *thirdPartyParameterCodec) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
+ return t.delegate.DecodeParameters(parameters, v1.SchemeGroupVersion, into)
+}
+
+func (t *thirdPartyParameterCodec) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
+ return t.delegate.EncodeParameters(obj, v1.SchemeGroupVersion)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/doc.go b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..62e2dc1e3eb73f2e267b399676550cd889d31bc8
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/doc.go
@@ -0,0 +1,19 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 thirdpartyresourcedata provides Registry interface and its REST
+// implementation for storing ThirdPartyResourceData api objects.
+package thirdpartyresourcedata
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/registry.go b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/registry.go
new file mode 100644
index 0000000000000000000000000000000000000000..058276d1e2f58ed50f4c1d781e0529c4301f449a
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/registry.go
@@ -0,0 +1,80 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 thirdpartyresourcedata
+
+import (
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/rest"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// Registry is an interface implemented by things that know how to store ThirdPartyResourceData objects.
+type Registry interface {
+ ListThirdPartyResourceData(ctx api.Context, options *api.ListOptions) (*extensions.ThirdPartyResourceDataList, error)
+ WatchThirdPartyResourceData(ctx api.Context, options *api.ListOptions) (watch.Interface, error)
+ GetThirdPartyResourceData(ctx api.Context, name string) (*extensions.ThirdPartyResourceData, error)
+ CreateThirdPartyResourceData(ctx api.Context, resource *extensions.ThirdPartyResourceData) (*extensions.ThirdPartyResourceData, error)
+ UpdateThirdPartyResourceData(ctx api.Context, resource *extensions.ThirdPartyResourceData) (*extensions.ThirdPartyResourceData, error)
+ DeleteThirdPartyResourceData(ctx api.Context, name string) error
+}
+
+// storage puts strong typing around storage calls
+type storage struct {
+ rest.StandardStorage
+}
+
+// NewRegistry returns a new Registry interface for the given Storage. Any mismatched
+// types will panic.
+func NewRegistry(s rest.StandardStorage) Registry {
+ return &storage{s}
+}
+
+func (s *storage) ListThirdPartyResourceData(ctx api.Context, options *api.ListOptions) (*extensions.ThirdPartyResourceDataList, error) {
+ obj, err := s.List(ctx, options)
+ if err != nil {
+ return nil, err
+ }
+ return obj.(*extensions.ThirdPartyResourceDataList), nil
+}
+
+func (s *storage) WatchThirdPartyResourceData(ctx api.Context, options *api.ListOptions) (watch.Interface, error) {
+ return s.Watch(ctx, options)
+}
+
+func (s *storage) GetThirdPartyResourceData(ctx api.Context, name string) (*extensions.ThirdPartyResourceData, error) {
+ obj, err := s.Get(ctx, name)
+ if err != nil {
+ return nil, err
+ }
+ return obj.(*extensions.ThirdPartyResourceData), nil
+}
+
+func (s *storage) CreateThirdPartyResourceData(ctx api.Context, ThirdPartyResourceData *extensions.ThirdPartyResourceData) (*extensions.ThirdPartyResourceData, error) {
+ obj, err := s.Create(ctx, ThirdPartyResourceData)
+ return obj.(*extensions.ThirdPartyResourceData), err
+}
+
+func (s *storage) UpdateThirdPartyResourceData(ctx api.Context, ThirdPartyResourceData *extensions.ThirdPartyResourceData) (*extensions.ThirdPartyResourceData, error) {
+ obj, _, err := s.Update(ctx, ThirdPartyResourceData.Name, rest.DefaultUpdatedObjectInfo(ThirdPartyResourceData, api.Scheme))
+ return obj.(*extensions.ThirdPartyResourceData), err
+}
+
+func (s *storage) DeleteThirdPartyResourceData(ctx api.Context, name string) error {
+ _, err := s.Delete(ctx, name, nil)
+ return err
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/strategy.go b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/strategy.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f7673d7c06e21692f3d9063cbb0ed465adbaa08
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/strategy.go
@@ -0,0 +1,92 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 thirdpartyresourcedata
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/rest"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/apis/extensions/validation"
+ "k8s.io/kubernetes/pkg/fields"
+ "k8s.io/kubernetes/pkg/labels"
+ "k8s.io/kubernetes/pkg/registry/generic"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+// strategy implements behavior for ThirdPartyResource objects
+type strategy struct {
+ runtime.ObjectTyper
+ api.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating ThirdPartyResource
+// objects via the REST API.
+var Strategy = strategy{api.Scheme, api.SimpleNameGenerator}
+
+var _ = rest.RESTCreateStrategy(Strategy)
+
+var _ = rest.RESTUpdateStrategy(Strategy)
+
+func (strategy) NamespaceScoped() bool {
+ return true
+}
+
+func (strategy) PrepareForCreate(obj runtime.Object) {
+}
+
+func (strategy) Validate(ctx api.Context, obj runtime.Object) field.ErrorList {
+ return validation.ValidateThirdPartyResourceData(obj.(*extensions.ThirdPartyResourceData))
+}
+
+// Canonicalize normalizes the object after validation.
+func (strategy) Canonicalize(obj runtime.Object) {
+}
+
+func (strategy) AllowCreateOnUpdate() bool {
+ return false
+}
+
+func (strategy) PrepareForUpdate(obj, old runtime.Object) {
+}
+
+func (strategy) ValidateUpdate(ctx api.Context, obj, old runtime.Object) field.ErrorList {
+ return validation.ValidateThirdPartyResourceDataUpdate(obj.(*extensions.ThirdPartyResourceData), old.(*extensions.ThirdPartyResourceData))
+}
+
+func (strategy) AllowUnconditionalUpdate() bool {
+ return true
+}
+
+// Matcher returns a generic matcher for a given label and field selector.
+func Matcher(label labels.Selector, field fields.Selector) generic.Matcher {
+ return generic.MatcherFunc(func(obj runtime.Object) (bool, error) {
+ sa, ok := obj.(*extensions.ThirdPartyResourceData)
+ if !ok {
+ return false, fmt.Errorf("not a ThirdPartyResourceData")
+ }
+ fields := SelectableFields(sa)
+ return label.Matches(labels.Set(sa.Labels)) && field.Matches(fields), nil
+ })
+}
+
+// SelectableFields returns a label set that can be used for filter selection
+func SelectableFields(obj *extensions.ThirdPartyResourceData) labels.Set {
+ return labels.Set{}
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/util.go b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..120981e85ec247bcebb9fb0e4667b40882570f02
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata/util.go
@@ -0,0 +1,68 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 thirdpartyresourcedata
+
+import (
+ "fmt"
+ "strings"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func ExtractGroupVersionKind(list *extensions.ThirdPartyResourceList) ([]unversioned.GroupVersion, []unversioned.GroupVersionKind, error) {
+ gvs := []unversioned.GroupVersion{}
+ gvks := []unversioned.GroupVersionKind{}
+ for ix := range list.Items {
+ rsrc := &list.Items[ix]
+ kind, group, err := ExtractApiGroupAndKind(rsrc)
+ if err != nil {
+ return nil, nil, err
+ }
+ for _, version := range rsrc.Versions {
+ gv := unversioned.GroupVersion{Group: group, Version: version.Name}
+ gvs = append(gvs, gv)
+ gvks = append(gvks, unversioned.GroupVersionKind{Group: group, Version: version.Name, Kind: kind})
+ }
+ }
+ return gvs, gvks, nil
+}
+
+func convertToCamelCase(input string) string {
+ result := ""
+ toUpper := true
+ for ix := range input {
+ char := input[ix]
+ if toUpper {
+ result = result + string([]byte{(char - 32)})
+ toUpper = false
+ } else if char == '-' {
+ toUpper = true
+ } else {
+ result = result + string([]byte{char})
+ }
+ }
+ return result
+}
+
+func ExtractApiGroupAndKind(rsrc *extensions.ThirdPartyResource) (kind string, group string, err error) {
+ parts := strings.Split(rsrc.Name, ".")
+ if len(parts) < 3 {
+ return "", "", fmt.Errorf("unexpectedly short resource name: %s, expected at least <kind>.<domain>.<tld>", rsrc.Name)
+ }
+ return convertToCamelCase(parts[0]), strings.Join(parts[1:], "."), nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/OWNERS b/vendor/k8s.io/kubernetes/pkg/runtime/OWNERS
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/OWNERS
rename to vendor/k8s.io/kubernetes/pkg/runtime/OWNERS
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/codec.go b/vendor/k8s.io/kubernetes/pkg/runtime/codec.go
similarity index 78%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/codec.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/codec.go
index bde0ae9755d50a89ab201bb8a7e2a2c8a48258f2..9cd7e153682bfd8c2a81aab568595e44fc06860c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/codec.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/codec.go
@@ -18,6 +18,7 @@ package runtime
import (
"bytes"
+ "encoding/base64"
"fmt"
"io"
"net/url"
@@ -39,10 +40,10 @@ func NewCodec(e Encoder, d Decoder) Codec {
}
// Encode is a convenience wrapper for encoding to a []byte from an Encoder
-func Encode(e Encoder, obj Object, overrides ...unversioned.GroupVersion) ([]byte, error) {
+func Encode(e Encoder, obj Object) ([]byte, error) {
// TODO: reuse buffer
buf := &bytes.Buffer{}
- if err := e.EncodeToStream(obj, buf, overrides...); err != nil {
+ if err := e.Encode(obj, buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
@@ -77,13 +78,13 @@ func EncodeOrDie(e Encoder, obj Object) string {
// UseOrCreateObject returns obj if the canonical ObjectKind returned by the provided typer matches gvk, or
// invokes the ObjectCreator to instantiate a new gvk. Returns an error if the typer cannot find the object.
-func UseOrCreateObject(t Typer, c ObjectCreater, gvk unversioned.GroupVersionKind, obj Object) (Object, error) {
+func UseOrCreateObject(t ObjectTyper, c ObjectCreater, gvk unversioned.GroupVersionKind, obj Object) (Object, error) {
if obj != nil {
- into, _, err := t.ObjectKind(obj)
+ into, _, err := t.ObjectKinds(obj)
if err != nil {
return nil, err
}
- if gvk == *into {
+ if gvk == into[0] {
return obj, nil
}
}
@@ -97,7 +98,7 @@ type NoopEncoder struct {
var _ Serializer = NoopEncoder{}
-func (n NoopEncoder) EncodeToStream(obj Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
+func (n NoopEncoder) Encode(obj Object, w io.Writer) error {
return fmt.Errorf("encoding is not allowed for this codec: %v", reflect.TypeOf(n.Decoder))
}
@@ -115,7 +116,7 @@ func (n NoopDecoder) Decode(data []byte, gvk *unversioned.GroupVersionKind, into
// NewParameterCodec creates a ParameterCodec capable of transforming url values into versioned objects and back.
func NewParameterCodec(scheme *Scheme) ParameterCodec {
return ¶meterCodec{
- typer: ObjectTyperToTyper(scheme),
+ typer: scheme,
convertor: scheme,
creator: scheme,
}
@@ -123,7 +124,7 @@ func NewParameterCodec(scheme *Scheme) ParameterCodec {
// parameterCodec implements conversion to and from query parameters and objects.
type parameterCodec struct {
- typer Typer
+ typer ObjectTyper
convertor ObjectConvertor
creator ObjectCreater
}
@@ -136,10 +137,11 @@ func (c *parameterCodec) DecodeParameters(parameters url.Values, from unversione
if len(parameters) == 0 {
return nil
}
- targetGVK, _, err := c.typer.ObjectKind(into)
+ targetGVKs, _, err := c.typer.ObjectKinds(into)
if err != nil {
return err
}
+ targetGVK := targetGVKs[0]
if targetGVK.GroupVersion() == from {
return c.convertor.Convert(¶meters, into)
}
@@ -156,12 +158,13 @@ func (c *parameterCodec) DecodeParameters(parameters url.Values, from unversione
// EncodeParameters converts the provided object into the to version, then converts that object to url.Values.
// Returns an error if conversion is not possible.
func (c *parameterCodec) EncodeParameters(obj Object, to unversioned.GroupVersion) (url.Values, error) {
- gvk, _, err := c.typer.ObjectKind(obj)
+ gvks, _, err := c.typer.ObjectKinds(obj)
if err != nil {
return nil, err
}
+ gvk := gvks[0]
if to != gvk.GroupVersion() {
- out, err := c.convertor.ConvertToVersion(obj, to.String())
+ out, err := c.convertor.ConvertToVersion(obj, to)
if err != nil {
return nil, err
}
@@ -169,3 +172,27 @@ func (c *parameterCodec) EncodeParameters(obj Object, to unversioned.GroupVersio
}
return queryparams.Convert(obj)
}
+
+type base64Serializer struct {
+ Serializer
+}
+
+func NewBase64Serializer(s Serializer) Serializer {
+ return &base64Serializer{s}
+}
+
+func (s base64Serializer) Encode(obj Object, stream io.Writer) error {
+ e := base64.NewEncoder(base64.StdEncoding, stream)
+ err := s.Serializer.Encode(obj, e)
+ e.Close()
+ return err
+}
+
+func (s base64Serializer) Decode(data []byte, defaults *unversioned.GroupVersionKind, into Object) (Object, *unversioned.GroupVersionKind, error) {
+ out := make([]byte, base64.StdEncoding.DecodedLen(len(data)))
+ n, err := base64.StdEncoding.Decode(out, data)
+ if err != nil {
+ return nil, nil, err
+ }
+ return s.Serializer.Decode(out[:n], defaults, into)
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/codec_check.go b/vendor/k8s.io/kubernetes/pkg/runtime/codec_check.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/codec_check.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/codec_check.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion.go b/vendor/k8s.io/kubernetes/pkg/runtime/conversion.go
similarity index 80%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/conversion.go
index c13d9d042d255bf9fb35b094204953840fa780d6..69cf00fea5d6a1065d2e7ac6540c67ca1b0268a1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/conversion.go
@@ -40,13 +40,13 @@ func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, st
// DefaultStringConversions are helpers for converting []string and string to real values.
var DefaultStringConversions = []interface{}{
- convertStringSliceToString,
- convertStringSliceToInt,
- convertStringSliceToBool,
- convertStringSliceToInt64,
+ Convert_Slice_string_To_string,
+ Convert_Slice_string_To_int,
+ Convert_Slice_string_To_bool,
+ Convert_Slice_string_To_int64,
}
-func convertStringSliceToString(input *[]string, out *string, s conversion.Scope) error {
+func Convert_Slice_string_To_string(input *[]string, out *string, s conversion.Scope) error {
if len(*input) == 0 {
*out = ""
}
@@ -54,7 +54,7 @@ func convertStringSliceToString(input *[]string, out *string, s conversion.Scope
return nil
}
-func convertStringSliceToInt(input *[]string, out *int, s conversion.Scope) error {
+func Convert_Slice_string_To_int(input *[]string, out *int, s conversion.Scope) error {
if len(*input) == 0 {
*out = 0
}
@@ -67,10 +67,10 @@ func convertStringSliceToInt(input *[]string, out *int, s conversion.Scope) erro
return nil
}
-// converStringSliceToBool will convert a string parameter to boolean.
+// Conver_Slice_string_To_bool will convert a string parameter to boolean.
// Only the absence of a value, a value of "false", or a value of "0" resolve to false.
// Any other value (including empty string) resolves to true.
-func convertStringSliceToBool(input *[]string, out *bool, s conversion.Scope) error {
+func Convert_Slice_string_To_bool(input *[]string, out *bool, s conversion.Scope) error {
if len(*input) == 0 {
*out = false
return nil
@@ -84,7 +84,7 @@ func convertStringSliceToBool(input *[]string, out *bool, s conversion.Scope) er
return nil
}
-func convertStringSliceToInt64(input *[]string, out *int64, s conversion.Scope) error {
+func Convert_Slice_string_To_int64(input *[]string, out *int64, s conversion.Scope) error {
if len(*input) == 0 {
*out = 0
}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/runtime/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..fad426daa6897fd202f65a73d465193c79818dbb
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/deep_copy_generated.go
@@ -0,0 +1,65 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package runtime
+
+import (
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func DeepCopy_runtime_RawExtension(in RawExtension, out *RawExtension, c *conversion.Cloner) error {
+ if in.Raw != nil {
+ in, out := in.Raw, &out.Raw
+ *out = make([]byte, len(in))
+ copy(*out, in)
+ } else {
+ out.Raw = nil
+ }
+ if in.Object == nil {
+ out.Object = nil
+ } else if newVal, err := c.DeepCopy(in.Object); err != nil {
+ return err
+ } else {
+ out.Object = newVal.(Object)
+ }
+ return nil
+}
+
+func DeepCopy_runtime_TypeMeta(in TypeMeta, out *TypeMeta, c *conversion.Cloner) error {
+ out.APIVersion = in.APIVersion
+ out.Kind = in.Kind
+ return nil
+}
+
+func DeepCopy_runtime_Unknown(in Unknown, out *Unknown, c *conversion.Cloner) error {
+ if err := DeepCopy_runtime_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil {
+ return err
+ }
+ if in.Raw != nil {
+ in, out := in.Raw, &out.Raw
+ *out = make([]byte, len(in))
+ copy(*out, in)
+ } else {
+ out.Raw = nil
+ }
+ out.ContentEncoding = in.ContentEncoding
+ out.ContentType = in.ContentType
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/doc.go b/vendor/k8s.io/kubernetes/pkg/runtime/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/doc.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/embedded.go b/vendor/k8s.io/kubernetes/pkg/runtime/embedded.go
similarity index 65%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/embedded.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/embedded.go
index 0934d6837c2b3cbd65567e306e34e16ecaaed768..a62080e39acadde8a615459fc80fe1423b45653d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/embedded.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/embedded.go
@@ -24,9 +24,9 @@ import (
)
type encodable struct {
- e Encoder `json:"-"`
+ E Encoder `json:"-"`
obj Object
- versions []unversioned.GroupVersion `json:"-"`
+ versions []unversioned.GroupVersion
}
func (e encodable) GetObjectKind() unversioned.ObjectKind { return e.obj.GetObjectKind() }
@@ -47,7 +47,7 @@ func (re encodable) UnmarshalJSON(in []byte) error {
// Marshal may get called on pointers or values, so implement MarshalJSON on value.
// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
func (re encodable) MarshalJSON() ([]byte, error) {
- return Encode(re.e, re.obj)
+ return Encode(re.E, re.obj)
}
// NewEncodableList creates an object that will be encoded with the provided codec on demand.
@@ -69,56 +69,68 @@ func (re *Unknown) UnmarshalJSON(in []byte) error {
return errors.New("runtime.Unknown: UnmarshalJSON on nil pointer")
}
re.TypeMeta = TypeMeta{}
- re.RawJSON = append(re.RawJSON[0:0], in...)
+ re.Raw = append(re.Raw[0:0], in...)
+ re.ContentEncoding = ""
+ re.ContentType = ContentTypeJSON
return nil
}
// Marshal may get called on pointers or values, so implement MarshalJSON on value.
// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
func (re Unknown) MarshalJSON() ([]byte, error) {
- if re.RawJSON == nil {
+ // If ContentType is unset, we assume this is JSON.
+ if re.ContentType != "" && re.ContentType != ContentTypeJSON {
+ return nil, errors.New("runtime.Unknown: MarshalJSON on non-json data")
+ }
+ if re.Raw == nil {
return []byte("null"), nil
}
- return re.RawJSON, nil
+ return re.Raw, nil
+}
+
+func Convert_runtime_Object_To_runtime_RawExtension(in *Object, out *RawExtension, s conversion.Scope) error {
+ if in == nil {
+ out.Raw = []byte("null")
+ return nil
+ }
+ obj := *in
+ if unk, ok := obj.(*Unknown); ok {
+ if unk.Raw != nil {
+ out.Raw = unk.Raw
+ return nil
+ }
+ obj = out.Object
+ }
+ if obj == nil {
+ out.Raw = nil
+ return nil
+ }
+ out.Object = obj
+ return nil
+}
+
+func Convert_runtime_RawExtension_To_runtime_Object(in *RawExtension, out *Object, s conversion.Scope) error {
+ if in.Object != nil {
+ *out = in.Object
+ return nil
+ }
+ data := in.Raw
+ if len(data) == 0 || (len(data) == 4 && string(data) == "null") {
+ *out = nil
+ return nil
+ }
+ *out = &Unknown{
+ Raw: data,
+ // TODO: Set ContentEncoding and ContentType appropriately.
+ // Currently we set ContentTypeJSON to make tests passing.
+ ContentType: ContentTypeJSON,
+ }
+ return nil
}
func DefaultEmbeddedConversions() []interface{} {
return []interface{}{
- func(in *Object, out *RawExtension, s conversion.Scope) error {
- if in == nil {
- out.RawJSON = []byte("null")
- return nil
- }
- obj := *in
- if unk, ok := obj.(*Unknown); ok {
- if unk.RawJSON != nil {
- out.RawJSON = unk.RawJSON
- return nil
- }
- obj = out.Object
- }
- if obj == nil {
- out.RawJSON = nil
- return nil
- }
- out.Object = obj
- return nil
- },
-
- func(in *RawExtension, out *Object, s conversion.Scope) error {
- if in.Object != nil {
- *out = in.Object
- return nil
- }
- data := in.RawJSON
- if len(data) == 0 || (len(data) == 4 && string(data) == "null") {
- *out = nil
- return nil
- }
- *out = &Unknown{
- RawJSON: data,
- }
- return nil
- },
+ Convert_runtime_Object_To_runtime_RawExtension,
+ Convert_runtime_RawExtension_To_runtime_Object,
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/error.go b/vendor/k8s.io/kubernetes/pkg/runtime/error.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/error.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/error.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/extension.go b/vendor/k8s.io/kubernetes/pkg/runtime/extension.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/extension.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/extension.go
index 629f675b69e7770201079948b0d623bc38c22a6a..eca82986eab928a0fdb4ea66cde774b2eb2c773e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/extension.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/extension.go
@@ -25,14 +25,14 @@ func (re *RawExtension) UnmarshalJSON(in []byte) error {
if re == nil {
return errors.New("runtime.RawExtension: UnmarshalJSON on nil pointer")
}
- re.RawJSON = append(re.RawJSON[0:0], in...)
+ re.Raw = append(re.Raw[0:0], in...)
return nil
}
// Marshal may get called on pointers or values, so implement MarshalJSON on value.
// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
func (re RawExtension) MarshalJSON() ([]byte, error) {
- if re.RawJSON == nil {
+ if re.Raw == nil {
// TODO: this is to support legacy behavior of JSONPrinter and YAMLPrinter, which
// expect to call json.Marshal on arbitrary versioned objects (even those not in
// the scheme). pkg/kubectl/resource#AsVersionedObjects and its interaction with
@@ -43,5 +43,6 @@ func (re RawExtension) MarshalJSON() ([]byte, error) {
}
return []byte("null"), nil
}
- return re.RawJSON, nil
+ // TODO: Check whether ContentType is actually JSON before returning it.
+ return re.Raw, nil
}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/runtime/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..289268483632c221fbdf0811d4d7fde4d7e958aa
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/generated.pb.go
@@ -0,0 +1,689 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/runtime/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package runtime is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/runtime/generated.proto
+
+ It has these top-level messages:
+ RawExtension
+ TypeMeta
+ Unknown
+*/
+package runtime
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *RawExtension) Reset() { *m = RawExtension{} }
+func (m *RawExtension) String() string { return proto.CompactTextString(m) }
+func (*RawExtension) ProtoMessage() {}
+
+func (m *TypeMeta) Reset() { *m = TypeMeta{} }
+func (m *TypeMeta) String() string { return proto.CompactTextString(m) }
+func (*TypeMeta) ProtoMessage() {}
+
+func (m *Unknown) Reset() { *m = Unknown{} }
+func (m *Unknown) String() string { return proto.CompactTextString(m) }
+func (*Unknown) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*RawExtension)(nil), "k8s.io.kubernetes.pkg.runtime.RawExtension")
+ proto.RegisterType((*TypeMeta)(nil), "k8s.io.kubernetes.pkg.runtime.TypeMeta")
+ proto.RegisterType((*Unknown)(nil), "k8s.io.kubernetes.pkg.runtime.Unknown")
+}
+func (m *RawExtension) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *RawExtension) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ if m.Raw != nil {
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Raw)))
+ i += copy(data[i:], m.Raw)
+ }
+ return i, nil
+}
+
+func (m *TypeMeta) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *TypeMeta) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.APIVersion)))
+ i += copy(data[i:], m.APIVersion)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Kind)))
+ i += copy(data[i:], m.Kind)
+ return i, nil
+}
+
+func (m *Unknown) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Unknown) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TypeMeta.Size()))
+ n1, err := m.TypeMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ if m.Raw != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Raw)))
+ i += copy(data[i:], m.Raw)
+ }
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContentEncoding)))
+ i += copy(data[i:], m.ContentEncoding)
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContentType)))
+ i += copy(data[i:], m.ContentType)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *RawExtension) Size() (n int) {
+ var l int
+ _ = l
+ if m.Raw != nil {
+ l = len(m.Raw)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ return n
+}
+
+func (m *TypeMeta) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.APIVersion)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.Kind)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func (m *Unknown) Size() (n int) {
+ var l int
+ _ = l
+ l = m.TypeMeta.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ if m.Raw != nil {
+ l = len(m.Raw)
+ n += 1 + l + sovGenerated(uint64(l))
+ }
+ l = len(m.ContentEncoding)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = len(m.ContentType)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *RawExtension) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: RawExtension: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: RawExtension: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ byteLen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Raw = append(m.Raw[:0], data[iNdEx:postIndex]...)
+ if m.Raw == nil {
+ m.Raw = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *TypeMeta) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.APIVersion = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Kind = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Unknown) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Unknown: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Unknown: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TypeMeta", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.TypeMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ byteLen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Raw = append(m.Raw[:0], data[iNdEx:postIndex]...)
+ if m.Raw == nil {
+ m.Raw = []byte{}
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContentEncoding", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContentEncoding = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.ContentType = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/generated.proto b/vendor/k8s.io/kubernetes/pkg/runtime/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..852721228fc33fd05d7dda48e13bd0537ce171d3
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/generated.proto
@@ -0,0 +1,124 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.runtime;
+
+import "k8s.io/kubernetes/pkg/api/resource/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "runtime";
+
+// 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.)
+//
+// +gencopy=true
+// +protobuf=true
+message RawExtension {
+ // Raw is the underlying serialization of this object.
+ //
+ // TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data.
+ optional bytes raw = 1;
+}
+
+// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
+// like this:
+// type MyAwesomeAPIObject struct {
+// runtime.TypeMeta `json:",inline"`
+// ... // other fields
+// }
+// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *unversioned.GroupVersionKind) { unversioned.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
+//
+// TypeMeta is provided here for convenience. You may use it directly from this package or define
+// your own with the same fields.
+//
+// +gencopy=true
+// +protobuf=true
+message TypeMeta {
+ optional string apiVersion = 1;
+
+ optional string kind = 2;
+}
+
+// Unknown allows api objects with unknown types to be passed-through. This can be used
+// to deal with the API objects from a plug-in. Unknown objects still have functioning
+// TypeMeta features-- kind, version, etc.
+// TODO: Make this object have easy access to field based accessors and settors for
+// metadata and field mutatation.
+//
+// +gencopy=true
+// +protobuf=true
+message Unknown {
+ optional TypeMeta typeMeta = 1;
+
+ // Raw will hold the complete serialized object which couldn't be matched
+ // with a registered type. Most likely, nothing should be done with this
+ // except for passing it through the system.
+ optional bytes raw = 2;
+
+ // ContentEncoding is encoding used to encode 'Raw' data.
+ // Unspecified means no encoding.
+ optional string contentEncoding = 3;
+
+ // ContentType is serialization method used to serialize 'Raw'.
+ // Unspecified means ContentTypeJSON.
+ optional string contentType = 4;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/helper.go b/vendor/k8s.io/kubernetes/pkg/runtime/helper.go
new file mode 100644
index 0000000000000000000000000000000000000000..b131fdcd90f436d04e8dec1d2f27fce0b445c53d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/helper.go
@@ -0,0 +1,212 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 runtime
+
+import (
+ "fmt"
+ "io"
+ "reflect"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/util/errors"
+)
+
+// unsafeObjectConvertor implements ObjectConvertor using the unsafe conversion path.
+type unsafeObjectConvertor struct {
+ *Scheme
+}
+
+var _ ObjectConvertor = unsafeObjectConvertor{}
+
+// ConvertToVersion converts in to the provided outVersion without copying the input first, which
+// is only safe if the output object is not mutated or reused.
+func (c unsafeObjectConvertor) ConvertToVersion(in Object, outVersion unversioned.GroupVersion) (Object, error) {
+ return c.Scheme.UnsafeConvertToVersion(in, outVersion)
+}
+
+// UnsafeObjectConvertor performs object conversion without copying the object structure,
+// for use when the converted object will not be reused or mutated. Primarily for use within
+// versioned codecs, which use the external object for serialization but do not return it.
+func UnsafeObjectConvertor(scheme *Scheme) ObjectConvertor {
+ return unsafeObjectConvertor{scheme}
+}
+
+// SetField puts the value of src, into fieldName, which must be a member of v.
+// The value of src must be assignable to the field.
+func SetField(src interface{}, v reflect.Value, fieldName string) error {
+ field := v.FieldByName(fieldName)
+ if !field.IsValid() {
+ return fmt.Errorf("couldn't find %v field in %#v", fieldName, v.Interface())
+ }
+ srcValue := reflect.ValueOf(src)
+ if srcValue.Type().AssignableTo(field.Type()) {
+ field.Set(srcValue)
+ return nil
+ }
+ if srcValue.Type().ConvertibleTo(field.Type()) {
+ field.Set(srcValue.Convert(field.Type()))
+ return nil
+ }
+ return fmt.Errorf("couldn't assign/convert %v to %v", srcValue.Type(), field.Type())
+}
+
+// Field puts the value of fieldName, which must be a member of v, into dest,
+// which must be a variable to which this field's value can be assigned.
+func Field(v reflect.Value, fieldName string, dest interface{}) error {
+ field := v.FieldByName(fieldName)
+ if !field.IsValid() {
+ return fmt.Errorf("couldn't find %v field in %#v", fieldName, v.Interface())
+ }
+ destValue, err := conversion.EnforcePtr(dest)
+ if err != nil {
+ return err
+ }
+ if field.Type().AssignableTo(destValue.Type()) {
+ destValue.Set(field)
+ return nil
+ }
+ if field.Type().ConvertibleTo(destValue.Type()) {
+ destValue.Set(field.Convert(destValue.Type()))
+ return nil
+ }
+ return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), destValue.Type())
+}
+
+// fieldPtr puts the address of fieldName, which must be a member of v,
+// into dest, which must be an address of a variable to which this field's
+// address can be assigned.
+func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error {
+ field := v.FieldByName(fieldName)
+ if !field.IsValid() {
+ return fmt.Errorf("couldn't find %v field in %#v", fieldName, v.Interface())
+ }
+ v, err := conversion.EnforcePtr(dest)
+ if err != nil {
+ return err
+ }
+ field = field.Addr()
+ if field.Type().AssignableTo(v.Type()) {
+ v.Set(field)
+ return nil
+ }
+ if field.Type().ConvertibleTo(v.Type()) {
+ v.Set(field.Convert(v.Type()))
+ return nil
+ }
+ return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), v.Type())
+}
+
+// EncodeList ensures that each object in an array is converted to a Unknown{} in serialized form.
+// TODO: accept a content type.
+func EncodeList(e Encoder, objects []Object) error {
+ var errs []error
+ for i := range objects {
+ data, err := Encode(e, objects[i])
+ if err != nil {
+ errs = append(errs, err)
+ continue
+ }
+ // TODO: Set ContentEncoding and ContentType.
+ objects[i] = &Unknown{Raw: data}
+ }
+ return errors.NewAggregate(errs)
+}
+
+func decodeListItem(obj *Unknown, decoders []Decoder) (Object, error) {
+ for _, decoder := range decoders {
+ // TODO: Decode based on ContentType.
+ obj, err := Decode(decoder, obj.Raw)
+ if err != nil {
+ if IsNotRegisteredError(err) {
+ continue
+ }
+ return nil, err
+ }
+ return obj, nil
+ }
+ // could not decode, so leave the object as Unknown, but give the decoders the
+ // chance to set Unknown.TypeMeta if it is available.
+ for _, decoder := range decoders {
+ if err := DecodeInto(decoder, obj.Raw, obj); err == nil {
+ return obj, nil
+ }
+ }
+ return obj, nil
+}
+
+// DecodeList alters the list in place, attempting to decode any objects found in
+// the list that have the Unknown type. Any errors that occur are returned
+// after the entire list is processed. Decoders are tried in order.
+func DecodeList(objects []Object, decoders ...Decoder) []error {
+ errs := []error(nil)
+ for i, obj := range objects {
+ switch t := obj.(type) {
+ case *Unknown:
+ decoded, err := decodeListItem(t, decoders)
+ if err != nil {
+ errs = append(errs, err)
+ break
+ }
+ objects[i] = decoded
+ }
+ }
+ return errs
+}
+
+// MultiObjectTyper returns the types of objects across multiple schemes in order.
+type MultiObjectTyper []ObjectTyper
+
+var _ ObjectTyper = MultiObjectTyper{}
+
+func (m MultiObjectTyper) ObjectKinds(obj Object) (gvks []unversioned.GroupVersionKind, unversionedType bool, err error) {
+ for _, t := range m {
+ gvks, unversionedType, err = t.ObjectKinds(obj)
+ if err == nil {
+ return
+ }
+ }
+ return
+}
+
+func (m MultiObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
+ for _, t := range m {
+ if t.Recognizes(gvk) {
+ return true
+ }
+ }
+ return false
+}
+
+// SetZeroValue would set the object of objPtr to zero value of its type.
+func SetZeroValue(objPtr Object) error {
+ v, err := conversion.EnforcePtr(objPtr)
+ if err != nil {
+ return err
+ }
+ v.Set(reflect.Zero(v.Type()))
+ return nil
+}
+
+// DefaultFramer is valid for any stream that can read objects serially without
+// any separation in the stream.
+var DefaultFramer = defaultFramer{}
+
+type defaultFramer struct{}
+
+func (defaultFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser { return r }
+func (defaultFramer) NewFrameWriter(w io.Writer) io.Writer { return w }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/interfaces.go b/vendor/k8s.io/kubernetes/pkg/runtime/interfaces.go
similarity index 56%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/interfaces.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/interfaces.go
index 67b37b4401b554bd301fb6d4edf012ad81d63422..7239ac44ce7b5705a5f949eb3a745110fc5456d1 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/interfaces.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/interfaces.go
@@ -30,20 +30,10 @@ const (
APIVersionInternal = "__internal"
)
-// Typer retrieves information about an object's group, version, and kind.
-type Typer interface {
- // ObjectKind returns the version and kind of the provided object, or an
- // error if the object is not recognized (IsNotRegisteredError will return true).
- // It returns whether the object is considered unversioned at the same time.
- // TODO: align the signature of ObjectTyper with this interface
- ObjectKind(Object) (*unversioned.GroupVersionKind, bool, error)
-}
-
type Encoder interface {
- // EncodeToStream writes an object to a stream. Override versions may be provided for each group
- // that enforce a certain versioning. Implementations may return errors if the versions are incompatible,
- // or if no conversion is defined.
- EncodeToStream(obj Object, stream io.Writer, overrides ...unversioned.GroupVersion) error
+ // Encode writes an object to a stream. Implementations may return errors if the versions are
+ // incompatible, or if no conversion is defined.
+ Encode(obj Object, w io.Writer) error
}
type Decoder interface {
@@ -80,20 +70,88 @@ type ParameterCodec interface {
EncodeParameters(obj Object, to unversioned.GroupVersion) (url.Values, error)
}
+// Framer is a factory for creating readers and writers that obey a particular framing pattern.
+type Framer interface {
+ NewFrameReader(r io.ReadCloser) io.ReadCloser
+ NewFrameWriter(w io.Writer) io.Writer
+}
+
+// SerializerInfo contains information about a specific serialization format
+type SerializerInfo struct {
+ Serializer
+ // EncodesAsText indicates this serializer can be encoded to UTF-8 safely.
+ EncodesAsText bool
+ // MediaType is the value that represents this serializer over the wire.
+ MediaType string
+}
+
+// StreamSerializerInfo contains information about a specific stream serialization format
+type StreamSerializerInfo struct {
+ SerializerInfo
+ // Framer is the factory for retrieving streams that separate objects on the wire
+ Framer
+ // Embedded is the type of the nested serialization that should be used.
+ Embedded SerializerInfo
+}
+
// NegotiatedSerializer is an interface used for obtaining encoders, decoders, and serializers
-// for multiple supported media types.
+// for multiple supported media types. This would commonly be accepted by a server component
+// that performs HTTP content negotiation to accept multiple formats.
type NegotiatedSerializer interface {
+ // SupportedMediaTypes is the media types supported for reading and writing single objects.
SupportedMediaTypes() []string
- SerializerForMediaType(mediaType string, options map[string]string) (Serializer, bool)
- EncoderForVersion(serializer Serializer, gv unversioned.GroupVersion) Encoder
- DecoderToVersion(serializer Serializer, gv unversioned.GroupVersion) Decoder
+ // SerializerForMediaType returns a serializer for the provided media type. params is the set of
+ // parameters applied to the media type that may modify the resulting output. ok will be false
+ // if no serializer matched the media type.
+ SerializerForMediaType(mediaType string, params map[string]string) (s SerializerInfo, ok bool)
+
+ // SupportedStreamingMediaTypes returns the media types of the supported streaming serializers.
+ // Streaming serializers control how multiple objects are written to a stream output.
+ SupportedStreamingMediaTypes() []string
+ // StreamingSerializerForMediaType returns a serializer for the provided media type that supports
+ // reading and writing multiple objects to a stream. It returns a framer and serializer, or an
+ // error if no such serializer can be created. Params is the set of parameters applied to the
+ // media type that may modify the resulting output. ok will be false if no serializer matched
+ // the media type.
+ StreamingSerializerForMediaType(mediaType string, params map[string]string) (s StreamSerializerInfo, ok bool)
+
+ // EncoderForVersion returns an encoder that ensures objects being written to the provided
+ // serializer are in the provided group version.
+ // TODO: take multiple group versions
+ EncoderForVersion(serializer Encoder, gv unversioned.GroupVersion) Encoder
+ // DecoderForVersion returns a decoder that ensures objects being read by the provided
+ // serializer are in the provided group version by default.
+ // TODO: take multiple group versions
+ DecoderToVersion(serializer Decoder, gv unversioned.GroupVersion) Decoder
+}
+
+// StorageSerializer is an interface used for obtaining encoders, decoders, and serializers
+// that can read and write data at rest. This would commonly be used by client tools that must
+// read files, or server side storage interfaces that persist restful objects.
+type StorageSerializer interface {
+ // SerializerForMediaType returns a serializer for the provided media type. Options is a set of
+ // parameters applied to the media type that may modify the resulting output.
+ SerializerForMediaType(mediaType string, options map[string]string) (SerializerInfo, bool)
+
+ // UniversalDeserializer returns a Serializer that can read objects in multiple supported formats
+ // by introspecting the data at rest.
+ UniversalDeserializer() Decoder
+
+ // EncoderForVersion returns an encoder that ensures objects being written to the provided
+ // serializer are in the provided group version.
+ // TODO: take multiple group versions
+ EncoderForVersion(serializer Encoder, gv unversioned.GroupVersion) Encoder
+ // DecoderForVersion returns a decoder that ensures objects being read by the provided
+ // serializer are in the provided group version by default.
+ // TODO: take multiple group versions
+ DecoderToVersion(serializer Decoder, gv unversioned.GroupVersion) Decoder
}
///////////////////////////////////////////////////////////////////////////////
// Non-codec interfaces
type ObjectVersioner interface {
- ConvertToVersion(in Object, outVersion string) (out Object, err error)
+ ConvertToVersion(in Object, outVersion unversioned.GroupVersion) (out Object, err error)
}
// ObjectConvertor converts an object to a different version.
@@ -103,27 +161,21 @@ type ObjectConvertor interface {
Convert(in, out interface{}) error
// ConvertToVersion takes the provided object and converts it the provided version. This
// method does not guarantee that the in object is not mutated.
- ConvertToVersion(in Object, outVersion string) (out Object, err error)
+ ConvertToVersion(in Object, outVersion unversioned.GroupVersion) (out Object, err error)
ConvertFieldLabel(version, kind, label, value string) (string, string, error)
}
// ObjectTyper contains methods for extracting the APIVersion and Kind
// of objects.
type ObjectTyper interface {
- // ObjectKind returns the default group,version,kind of the provided object, or an
- // error if the object is not recognized (IsNotRegisteredError will return true).
- ObjectKind(Object) (unversioned.GroupVersionKind, error)
- // ObjectKinds returns the all possible group,version,kind of the provided object, or an
- // error if the object is not recognized (IsNotRegisteredError will return true).
- ObjectKinds(Object) ([]unversioned.GroupVersionKind, error)
+ // ObjectKinds returns the all possible group,version,kind of the provided object, true if
+ // the object is unversioned, or an error if the object is not recognized
+ // (IsNotRegisteredError will return true).
+ ObjectKinds(Object) ([]unversioned.GroupVersionKind, bool, error)
// Recognizes returns true if the scheme is able to handle the provided version and kind,
// or more precisely that the provided version is a possible conversion or decoding
// target.
Recognizes(gvk unversioned.GroupVersionKind) bool
- // IsUnversioned returns true if the provided object is considered unversioned and thus
- // should have Version and Group suppressed in the output. If the object is not recognized
- // in the scheme, ok is false.
- IsUnversioned(Object) (unversioned bool, ok bool)
}
// ObjectCreater contains methods for instantiating an object by kind and version.
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/register.go b/vendor/k8s.io/kubernetes/pkg/runtime/register.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/register.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/register.go
index ec58b345de5f362a55acce610a9ee854217aa9f0..5201a15ffd5fea4334489db64252fe96752cdae5 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/register.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/register.go
@@ -21,18 +21,19 @@ import (
)
// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) SetGroupVersionKind(gvk *unversioned.GroupVersionKind) {
+func (obj *TypeMeta) SetGroupVersionKind(gvk unversioned.GroupVersionKind) {
obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
}
// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) GroupVersionKind() *unversioned.GroupVersionKind {
+func (obj *TypeMeta) GroupVersionKind() unversioned.GroupVersionKind {
return unversioned.FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
}
-func (obj *Unknown) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *Unstructured) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
-func (obj *UnstructuredList) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
+func (obj *Unknown) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
+
+func (obj *Unstructured) GetObjectKind() unversioned.ObjectKind { return obj }
+func (obj *UnstructuredList) GetObjectKind() unversioned.ObjectKind { return obj }
// GetObjectKind implements Object for VersionedObjects, returning an empty ObjectKind
// interface if no objects are provided, or the ObjectKind interface of the object in the
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/scheme.go b/vendor/k8s.io/kubernetes/pkg/runtime/scheme.go
similarity index 79%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/scheme.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/scheme.go
index 9a4a708963fb7ae9ab5069ddfa8b4217dde4cdf4..c49c43e93ffde8fed47a0e8e2cb528bf681e2a34 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/scheme.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/scheme.go
@@ -124,11 +124,8 @@ func (s *Scheme) nameFunc(t reflect.Type) string {
// fromScope gets the input version, desired output version, and desired Scheme
// from a conversion.Scope.
-func (s *Scheme) fromScope(scope conversion.Scope) (inVersion, outVersion string, scheme *Scheme) {
- scheme = s
- inVersion = scope.Meta().SrcVersion
- outVersion = scope.Meta().DestVersion
- return inVersion, outVersion, scheme
+func (s *Scheme) fromScope(scope conversion.Scope) *Scheme {
+ return s
}
// Converter allows access to the converter for the scheme
@@ -214,31 +211,32 @@ func (s *Scheme) KnownTypes(gv unversioned.GroupVersion) map[string]reflect.Type
return types
}
-// ObjectKind returns the group,version,kind of the go object,
-// or an error if it's not a pointer or is unregistered.
-func (s *Scheme) ObjectKind(obj Object) (unversioned.GroupVersionKind, error) {
- gvks, err := s.ObjectKinds(obj)
+// ObjectKind returns the group,version,kind of the go object and true if this object
+// is considered unversioned, or an error if it's not a pointer or is unregistered.
+func (s *Scheme) ObjectKind(obj Object) (unversioned.GroupVersionKind, bool, error) {
+ gvks, unversionedType, err := s.ObjectKinds(obj)
if err != nil {
- return unversioned.GroupVersionKind{}, err
+ return unversioned.GroupVersionKind{}, false, err
}
- return gvks[0], nil
+ return gvks[0], unversionedType, nil
}
-// ObjectKinds returns all possible group,version,kind of the go object,
-// or an error if it's not a pointer or is unregistered.
-func (s *Scheme) ObjectKinds(obj Object) ([]unversioned.GroupVersionKind, error) {
+// ObjectKinds returns all possible group,version,kind of the go object, true if the
+// object is considered unversioned, or an error if it's not a pointer or is unregistered.
+func (s *Scheme) ObjectKinds(obj Object) ([]unversioned.GroupVersionKind, bool, error) {
v, err := conversion.EnforcePtr(obj)
if err != nil {
- return nil, err
+ return nil, false, err
}
t := v.Type()
gvks, ok := s.typeToGVK[t]
if !ok {
- return nil, ¬RegisteredErr{t: t}
+ return nil, false, ¬RegisteredErr{t: t}
}
+ _, unversionedType := s.unversionedTypes[t]
- return gvks, nil
+ return gvks, unversionedType, nil
}
// Recognizes returns true if the scheme is able to handle the provided group,version,kind
@@ -275,6 +273,14 @@ func (s *Scheme) New(kind unversioned.GroupVersionKind) (Object, error) {
return nil, ¬RegisteredErr{gvk: kind}
}
+// AddGenericConversionFunc adds a function that accepts the ConversionFunc call pattern
+// (for two conversion types) to the converter. These functions are checked first during
+// a normal conversion, but are otherwise not called. Use AddConversionFuncs when registering
+// typed conversions.
+func (s *Scheme) AddGenericConversionFunc(fn conversion.GenericConversionFunc) {
+ s.converter.AddGenericConversionFunc(fn)
+}
+
// Log sets a logger on the scheme. For test purposes only
func (s *Scheme) Log(l conversion.DebugLogger) {
s.converter.Debug = l
@@ -434,13 +440,13 @@ func (s *Scheme) Convert(in, out interface{}) error {
inVersion := unversioned.GroupVersion{Group: "unknown", Version: "unknown"}
outVersion := unversioned.GroupVersion{Group: "unknown", Version: "unknown"}
if inObj, ok := in.(Object); ok {
- if gvk, err := s.ObjectKind(inObj); err == nil {
- inVersion = gvk.GroupVersion()
+ if gvks, _, err := s.ObjectKinds(inObj); err == nil {
+ inVersion = gvks[0].GroupVersion()
}
}
if outObj, ok := out.(Object); ok {
- if gvk, err := s.ObjectKind(outObj); err == nil {
- outVersion = gvk.GroupVersion()
+ if gvks, _, err := s.ObjectKinds(outObj); err == nil {
+ outVersion = gvks[0].GroupVersion()
}
}
flags, meta := s.generateConvertMeta(inVersion, outVersion, in)
@@ -468,16 +474,12 @@ func (s *Scheme) ConvertFieldLabel(version, kind, label, value string) (string,
// contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also
// return an error if the conversion does not result in a valid Object being
// returned. The serializer handles loading/serializing nested objects.
-func (s *Scheme) ConvertToVersion(in Object, outVersion string) (Object, error) {
- gv, err := unversioned.ParseGroupVersion(outVersion)
- if err != nil {
- return nil, err
- }
+func (s *Scheme) ConvertToVersion(in Object, outVersion unversioned.GroupVersion) (Object, error) {
switch in.(type) {
case *Unknown, *Unstructured, *UnstructuredList:
old := in.GetObjectKind().GroupVersionKind()
defer in.GetObjectKind().SetGroupVersionKind(old)
- setTargetVersion(in, s, gv)
+ setTargetVersion(in, s, outVersion)
return in, nil
}
t := reflect.TypeOf(in)
@@ -501,9 +503,9 @@ func (s *Scheme) ConvertToVersion(in Object, outVersion string) (Object, error)
kind = kinds[0]
}
- outKind := gv.WithKind(kind.Kind)
+ outKind := outVersion.WithKind(kind.Kind)
- inKind, err := s.ObjectKind(in)
+ inKinds, _, err := s.ObjectKinds(in)
if err != nil {
return nil, err
}
@@ -513,29 +515,109 @@ func (s *Scheme) ConvertToVersion(in Object, outVersion string) (Object, error)
return nil, err
}
- flags, meta := s.generateConvertMeta(inKind.GroupVersion(), gv, in)
+ flags, meta := s.generateConvertMeta(inKinds[0].GroupVersion(), outVersion, in)
+ if err := s.converter.Convert(in, out, flags, meta); err != nil {
+ return nil, err
+ }
+
+ setTargetVersion(out, s, outVersion)
+ return out, nil
+}
+
+// UnsafeConvertToVersion will convert in to the provided outVersion if such a conversion is possible,
+// but does not guarantee the output object does not share fields with the input object. It attempts to be as
+// efficient as possible when doing conversion.
+func (s *Scheme) UnsafeConvertToVersion(in Object, outVersion unversioned.GroupVersion) (Object, error) {
+ switch t := in.(type) {
+ case *Unknown:
+ t.APIVersion = outVersion.String()
+ return t, nil
+ case *Unstructured:
+ t.SetAPIVersion(outVersion.String())
+ return t, nil
+ case *UnstructuredList:
+ t.SetAPIVersion(outVersion.String())
+ return t, nil
+ }
+
+ // determine the incoming kinds with as few allocations as possible.
+ t := reflect.TypeOf(in)
+ if t.Kind() != reflect.Ptr {
+ return nil, fmt.Errorf("only pointer types may be converted: %v", t)
+ }
+ t = t.Elem()
+ if t.Kind() != reflect.Struct {
+ return nil, fmt.Errorf("only pointers to struct types may be converted: %v", t)
+ }
+ kinds, ok := s.typeToGVK[t]
+ if !ok || len(kinds) == 0 {
+ return nil, fmt.Errorf("%v is not a registered type and cannot be converted into version %q", t, outVersion)
+ }
+
+ // if the Go type is also registered to the destination kind, no conversion is necessary
+ for i := range kinds {
+ if kinds[i].Version == outVersion.Version && kinds[i].Group == outVersion.Group {
+ setTargetKind(in, kinds[i])
+ return in, nil
+ }
+ }
+
+ // type is unversioned, no conversion necessary
+ // it should be possible to avoid this allocation
+ if unversionedKind, ok := s.unversionedTypes[t]; ok {
+ kind := unversionedKind
+ outKind := outVersion.WithKind(kind.Kind)
+ setTargetKind(in, outKind)
+ return in, nil
+ }
+
+ // allocate a new object as the target using the target kind
+ // TODO: this should look in the target group version and find the first kind that matches, rather than the
+ // first kind registered in typeToGVK
+ kind := kinds[0]
+ kind.Version = outVersion.Version
+ kind.Group = outVersion.Group
+ out, err := s.New(kind)
+ if err != nil {
+ return nil, err
+ }
+
+ // TODO: try to avoid the allocations here - in fast paths we are not likely to need these flags or meta
+ flags, meta := s.converter.DefaultMeta(t)
if err := s.converter.Convert(in, out, flags, meta); err != nil {
return nil, err
}
- setTargetVersion(out, s, gv)
+ setTargetKind(out, kind)
return out, nil
}
// generateConvertMeta constructs the meta value we pass to Convert.
func (s *Scheme) generateConvertMeta(srcGroupVersion, destGroupVersion unversioned.GroupVersion, in interface{}) (conversion.FieldMatchingFlags, *conversion.Meta) {
- flags, meta := s.converter.DefaultMeta(reflect.TypeOf(in))
- meta.SrcVersion = srcGroupVersion.String()
- meta.DestVersion = destGroupVersion.String()
- return flags, meta
+ return s.converter.DefaultMeta(reflect.TypeOf(in))
}
+// setTargetVersion is deprecated and should be replaced by use of setTargetKind
func setTargetVersion(obj Object, raw *Scheme, gv unversioned.GroupVersion) {
if gv.Version == APIVersionInternal {
// internal is a special case
- obj.GetObjectKind().SetGroupVersionKind(nil)
+ obj.GetObjectKind().SetGroupVersionKind(unversioned.GroupVersionKind{})
+ return
+ }
+ if gvks, _, _ := raw.ObjectKinds(obj); len(gvks) > 0 {
+ obj.GetObjectKind().SetGroupVersionKind(unversioned.GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: gvks[0].Kind})
} else {
- gvk, _ := raw.ObjectKind(obj)
- obj.GetObjectKind().SetGroupVersionKind(&unversioned.GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: gvk.Kind})
+ obj.GetObjectKind().SetGroupVersionKind(unversioned.GroupVersionKind{Group: gv.Group, Version: gv.Version})
+ }
+}
+
+// setTargetKind sets the kind on an object, taking into account whether the target kind is the internal version.
+func setTargetKind(obj Object, kind unversioned.GroupVersionKind) {
+ if kind.Version == APIVersionInternal {
+ // internal is a special case
+ // TODO: look at removing the need to special case this
+ obj.GetObjectKind().SetGroupVersionKind(unversioned.GroupVersionKind{})
+ return
}
+ obj.GetObjectKind().SetGroupVersionKind(kind)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go
new file mode 100644
index 0000000000000000000000000000000000000000..4432e489603f3a0fb22942e57fc07ac3c3d84061
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/codec_factory.go
@@ -0,0 +1,364 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 serializer
+
+import (
+ "io"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer/json"
+ "k8s.io/kubernetes/pkg/runtime/serializer/recognizer"
+ "k8s.io/kubernetes/pkg/runtime/serializer/versioning"
+)
+
+// serializerExtensions are for serializers that are conditionally compiled in
+var serializerExtensions = []func(*runtime.Scheme) (serializerType, bool){}
+
+type serializerType struct {
+ AcceptContentTypes []string
+ ContentType string
+ FileExtensions []string
+ // EncodesAsText should be true if this content type can be represented safely in UTF-8
+ EncodesAsText bool
+
+ Serializer runtime.Serializer
+ PrettySerializer runtime.Serializer
+ // RawSerializer serializes an object without adding a type wrapper. Some serializers, like JSON
+ // automatically include identifying type information with the JSON. Others, like Protobuf, need
+ // a wrapper object that includes type information. This serializer should be set if the serializer
+ // can serialize / deserialize objects without type info. Note that this serializer will always
+ // be expected to pass into or a gvk to Decode, since no type information will be available on
+ // the object itself.
+ RawSerializer runtime.Serializer
+ // Specialize gives the type the opportunity to return a different serializer implementation if
+ // the content type contains alternate operations. Here it is used to implement "pretty" as an
+ // option to application/json, but could also be used to allow serializers to perform type
+ // defaulting or alter output.
+ Specialize func(map[string]string) (runtime.Serializer, bool)
+
+ AcceptStreamContentTypes []string
+ StreamContentType string
+
+ Framer runtime.Framer
+ StreamSerializer runtime.Serializer
+ StreamSpecialize func(map[string]string) (runtime.Serializer, bool)
+}
+
+func newSerializersForScheme(scheme *runtime.Scheme, mf json.MetaFactory) []serializerType {
+ jsonSerializer := json.NewSerializer(mf, scheme, scheme, false)
+ jsonPrettySerializer := json.NewSerializer(mf, scheme, scheme, true)
+ yamlSerializer := json.NewYAMLSerializer(mf, scheme, scheme)
+
+ serializers := []serializerType{
+ {
+ AcceptContentTypes: []string{"application/json"},
+ ContentType: "application/json",
+ FileExtensions: []string{"json"},
+ EncodesAsText: true,
+ Serializer: jsonSerializer,
+ PrettySerializer: jsonPrettySerializer,
+
+ AcceptStreamContentTypes: []string{"application/json", "application/json;stream=watch"},
+ StreamContentType: "application/json",
+ Framer: json.Framer,
+ StreamSerializer: jsonSerializer,
+ },
+ {
+ AcceptContentTypes: []string{"application/yaml"},
+ ContentType: "application/yaml",
+ FileExtensions: []string{"yaml"},
+ EncodesAsText: true,
+ Serializer: yamlSerializer,
+
+ // TODO: requires runtime.RawExtension to properly distinguish when the nested content is
+ // yaml, because the yaml encoder invokes MarshalJSON first
+ //AcceptStreamContentTypes: []string{"application/yaml", "application/yaml;stream=watch"},
+ //StreamContentType: "application/yaml;stream=watch",
+ //Framer: json.YAMLFramer,
+ //StreamSerializer: yamlSerializer,
+ },
+ }
+
+ for _, fn := range serializerExtensions {
+ if serializer, ok := fn(scheme); ok {
+ serializers = append(serializers, serializer)
+ }
+ }
+ return serializers
+}
+
+// CodecFactory provides methods for retrieving codecs and serializers for specific
+// versions and content types.
+type CodecFactory struct {
+ scheme *runtime.Scheme
+ serializers []serializerType
+ universal runtime.Decoder
+ accepts []string
+ streamingAccepts []string
+
+ legacySerializer runtime.Serializer
+}
+
+// NewCodecFactory provides methods for retrieving serializers for the supported wire formats
+// and conversion wrappers to define preferred internal and external versions. In the future,
+// as the internal version is used less, callers may instead use a defaulting serializer and
+// only convert objects which are shared internally (Status, common API machinery).
+// TODO: allow other codecs to be compiled in?
+// TODO: accept a scheme interface
+func NewCodecFactory(scheme *runtime.Scheme) CodecFactory {
+ serializers := newSerializersForScheme(scheme, json.DefaultMetaFactory)
+ return newCodecFactory(scheme, serializers)
+}
+
+// newCodecFactory is a helper for testing that allows a different metafactory to be specified.
+func newCodecFactory(scheme *runtime.Scheme, serializers []serializerType) CodecFactory {
+ decoders := make([]runtime.Decoder, 0, len(serializers))
+ accepts := []string{}
+ alreadyAccepted := make(map[string]struct{})
+
+ var legacySerializer runtime.Serializer
+ for _, d := range serializers {
+ decoders = append(decoders, d.Serializer)
+ for _, mediaType := range d.AcceptContentTypes {
+ if _, ok := alreadyAccepted[mediaType]; ok {
+ continue
+ }
+ alreadyAccepted[mediaType] = struct{}{}
+ accepts = append(accepts, mediaType)
+ if mediaType == "application/json" {
+ legacySerializer = d.Serializer
+ }
+ }
+ }
+ if legacySerializer == nil {
+ legacySerializer = serializers[0].Serializer
+ }
+
+ streamAccepts := []string{}
+ alreadyAccepted = make(map[string]struct{})
+ for _, d := range serializers {
+ if len(d.StreamContentType) == 0 {
+ continue
+ }
+ for _, mediaType := range d.AcceptStreamContentTypes {
+ if _, ok := alreadyAccepted[mediaType]; ok {
+ continue
+ }
+ alreadyAccepted[mediaType] = struct{}{}
+ streamAccepts = append(streamAccepts, mediaType)
+ }
+ }
+
+ return CodecFactory{
+ scheme: scheme,
+ serializers: serializers,
+ universal: recognizer.NewDecoder(decoders...),
+
+ accepts: accepts,
+ streamingAccepts: streamAccepts,
+
+ legacySerializer: legacySerializer,
+ }
+}
+
+var _ runtime.NegotiatedSerializer = &CodecFactory{}
+
+// SupportedMediaTypes returns the RFC2046 media types that this factory has serializers for.
+func (f CodecFactory) SupportedMediaTypes() []string {
+ return f.accepts
+}
+
+// SupportedStreamingMediaTypes returns the RFC2046 media types that this factory has stream serializers for.
+func (f CodecFactory) SupportedStreamingMediaTypes() []string {
+ return f.streamingAccepts
+}
+
+// LegacyCodec encodes output to a given API version, and decodes output into the internal form from
+// any recognized source. The returned codec will always encode output to JSON.
+//
+// This method is deprecated - clients and servers should negotiate a serializer by mime-type and
+// invoke CodecForVersions. Callers that need only to read data should use UniversalDecoder().
+func (f CodecFactory) LegacyCodec(version ...unversioned.GroupVersion) runtime.Codec {
+ return versioning.NewCodecForScheme(f.scheme, f.legacySerializer, f.universal, version, nil)
+}
+
+// UniversalDeserializer can convert any stored data recognized by this factory into a Go object that satisfies
+// runtime.Object. It does not perform conversion. It does not perform defaulting.
+func (f CodecFactory) UniversalDeserializer() runtime.Decoder {
+ return f.universal
+}
+
+// UniversalDecoder returns a runtime.Decoder capable of decoding all known API objects in all known formats. Used
+// by clients that do not need to encode objects but want to deserialize API objects stored on disk. Only decodes
+// objects in groups registered with the scheme. The GroupVersions passed may be used to select alternate
+// versions of objects to return - by default, runtime.APIVersionInternal is used. If any versions are specified,
+// unrecognized groups will be returned in the version they are encoded as (no conversion). This decoder performs
+// defaulting.
+//
+// TODO: the decoder will eventually be removed in favor of dealing with objects in their versioned form
+func (f CodecFactory) UniversalDecoder(versions ...unversioned.GroupVersion) runtime.Decoder {
+ return f.CodecForVersions(nil, f.universal, nil, versions)
+}
+
+// CodecFor creates a codec with the provided serializer. If an object is decoded and its group is not in the list,
+// it will default to runtime.APIVersionInternal. If encode is not specified for an object's group, the object is not
+// converted. If encode or decode are nil, no conversion is performed.
+func (f CodecFactory) CodecForVersions(encoder runtime.Encoder, decoder runtime.Decoder, encode []unversioned.GroupVersion, decode []unversioned.GroupVersion) runtime.Codec {
+ return versioning.NewCodecForScheme(f.scheme, encoder, decoder, encode, decode)
+}
+
+// DecoderToVersion returns a decoder that targets the provided group version.
+func (f CodecFactory) DecoderToVersion(decoder runtime.Decoder, gv unversioned.GroupVersion) runtime.Decoder {
+ return f.CodecForVersions(nil, decoder, nil, []unversioned.GroupVersion{gv})
+}
+
+// EncoderForVersion returns an encoder that targets the provided group version.
+func (f CodecFactory) EncoderForVersion(encoder runtime.Encoder, gv unversioned.GroupVersion) runtime.Encoder {
+ return f.CodecForVersions(encoder, nil, []unversioned.GroupVersion{gv}, nil)
+}
+
+// SerializerForMediaType returns a serializer that matches the provided RFC2046 mediaType, or false if no such
+// serializer exists
+func (f CodecFactory) SerializerForMediaType(mediaType string, params map[string]string) (runtime.SerializerInfo, bool) {
+ for _, s := range f.serializers {
+ for _, accepted := range s.AcceptContentTypes {
+ if accepted == mediaType {
+ // specialization abstracts variants to the content type
+ if s.Specialize != nil && len(params) > 0 {
+ serializer, ok := s.Specialize(params)
+ // TODO: return formatted mediaType+params
+ return runtime.SerializerInfo{Serializer: serializer, MediaType: s.ContentType, EncodesAsText: s.EncodesAsText}, ok
+ }
+
+ // legacy support for ?pretty=1 continues, but this is more formally defined
+ if v, ok := params["pretty"]; ok && v == "1" && s.PrettySerializer != nil {
+ return runtime.SerializerInfo{Serializer: s.PrettySerializer, MediaType: s.ContentType, EncodesAsText: s.EncodesAsText}, true
+ }
+
+ // return the base variant
+ return runtime.SerializerInfo{Serializer: s.Serializer, MediaType: s.ContentType, EncodesAsText: s.EncodesAsText}, true
+ }
+ }
+ }
+ return runtime.SerializerInfo{}, false
+}
+
+// StreamingSerializerForMediaType returns a serializer that matches the provided RFC2046 mediaType, or false if no such
+// serializer exists
+func (f CodecFactory) StreamingSerializerForMediaType(mediaType string, params map[string]string) (runtime.StreamSerializerInfo, bool) {
+ for _, s := range f.serializers {
+ for _, accepted := range s.AcceptStreamContentTypes {
+ if accepted == mediaType {
+ // TODO: accept params
+ nested, ok := f.SerializerForMediaType(s.ContentType, nil)
+ if !ok {
+ panic("no serializer defined for internal content type")
+ }
+
+ if s.StreamSpecialize != nil && len(params) > 0 {
+ serializer, ok := s.StreamSpecialize(params)
+ // TODO: return formatted mediaType+params
+ return runtime.StreamSerializerInfo{
+ SerializerInfo: runtime.SerializerInfo{
+ Serializer: serializer,
+ MediaType: s.StreamContentType,
+ EncodesAsText: s.EncodesAsText,
+ },
+ Framer: s.Framer,
+ Embedded: nested,
+ }, ok
+ }
+
+ return runtime.StreamSerializerInfo{
+ SerializerInfo: runtime.SerializerInfo{
+ Serializer: s.StreamSerializer,
+ MediaType: s.StreamContentType,
+ EncodesAsText: s.EncodesAsText,
+ },
+ Framer: s.Framer,
+ Embedded: nested,
+ }, true
+ }
+ }
+ }
+ return runtime.StreamSerializerInfo{}, false
+}
+
+// SerializerForFileExtension returns a serializer for the provided extension, or false if no serializer matches.
+func (f CodecFactory) SerializerForFileExtension(extension string) (runtime.Serializer, bool) {
+ for _, s := range f.serializers {
+ for _, ext := range s.FileExtensions {
+ if extension == ext {
+ return s.Serializer, true
+ }
+ }
+ }
+ return nil, false
+}
+
+// DirectCodecFactory provides methods for retrieving "DirectCodec"s, which do not do conversion.
+type DirectCodecFactory struct {
+ CodecFactory
+}
+
+// EncoderForVersion returns an encoder that does not do conversion. gv is ignored.
+func (f DirectCodecFactory) EncoderForVersion(serializer runtime.Encoder, gv unversioned.GroupVersion) runtime.Encoder {
+ return DirectCodec{
+ runtime.NewCodec(serializer, nil),
+ f.CodecFactory.scheme,
+ }
+}
+
+// DecoderToVersion returns an decoder that does not do conversion. gv is ignored.
+func (f DirectCodecFactory) DecoderToVersion(serializer runtime.Decoder, gv unversioned.GroupVersion) runtime.Decoder {
+ return DirectCodec{
+ runtime.NewCodec(nil, serializer),
+ nil,
+ }
+}
+
+// DirectCodec is a codec that does not do conversion. It sets the gvk during serialization, and removes the gvk during deserialization.
+type DirectCodec struct {
+ runtime.Serializer
+ runtime.ObjectTyper
+}
+
+// EncodeToStream does not do conversion. It sets the gvk during serialization. overrides are ignored.
+func (c DirectCodec) Encode(obj runtime.Object, stream io.Writer) error {
+ gvks, _, err := c.ObjectTyper.ObjectKinds(obj)
+ if err != nil {
+ return err
+ }
+ kind := obj.GetObjectKind()
+ oldGVK := kind.GroupVersionKind()
+ kind.SetGroupVersionKind(gvks[0])
+ err = c.Serializer.Encode(obj, stream)
+ kind.SetGroupVersionKind(oldGVK)
+ return err
+}
+
+// Decode does not do conversion. It removes the gvk during deserialization.
+func (c DirectCodec) Decode(data []byte, defaults *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ obj, gvk, err := c.Serializer.Decode(data, defaults, into)
+ if obj != nil {
+ kind := obj.GetObjectKind()
+ // clearing the gvk is just a convention of a codec
+ kind.SetGroupVersionKind(unversioned.GroupVersionKind{})
+ }
+ return obj, gvk, err
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go
similarity index 69%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go
index f9fb4bbfb22709c85329f61f8f008d961f7ecdf5..c226448f379aece89eb755b9e5a97087ecdc7c9b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/json/json.go
@@ -25,12 +25,13 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/framer"
utilyaml "k8s.io/kubernetes/pkg/util/yaml"
)
// NewSerializer creates a JSON serializer that handles encoding versioned objects into the proper JSON form. If typer
// is not nil, the object has the group, version, and kind fields set.
-func NewSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.Typer, pretty bool) runtime.Serializer {
+func NewSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper, pretty bool) *Serializer {
return &Serializer{
meta: meta,
creater: creater,
@@ -43,7 +44,7 @@ func NewSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtim
// NewYAMLSerializer creates a YAML serializer that handles encoding versioned objects into the proper YAML form. If typer
// is not nil, the object has the group, version, and kind fields set. This serializer supports only the subset of YAML that
// matches JSON, and will error if constructs are used that do not serialize to JSON.
-func NewYAMLSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.Typer) runtime.Serializer {
+func NewYAMLSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper) *Serializer {
return &Serializer{
meta: meta,
creater: creater,
@@ -55,11 +56,14 @@ func NewYAMLSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer ru
type Serializer struct {
meta MetaFactory
creater runtime.ObjectCreater
- typer runtime.Typer
+ typer runtime.ObjectTyper
yaml bool
pretty bool
}
+// Serializer implements Serializer
+var _ runtime.Serializer = &Serializer{}
+
// Decode attempts to convert the provided data into YAML or JSON, extract the stored schema kind, apply the provided default gvk, and then
// load that data into an object matching the desired schema kind or the provided into. If into is *runtime.Unknown, the raw data will be
// extracted and no decoding will be performed. If into is not registered with the typer, then the object will be straight decoded using
@@ -105,14 +109,14 @@ func (s *Serializer) Decode(originalData []byte, gvk *unversioned.GroupVersionKi
}
if unk, ok := into.(*runtime.Unknown); ok && unk != nil {
- unk.RawJSON = originalData
- // TODO: set content type here
- unk.GetObjectKind().SetGroupVersionKind(actual)
+ unk.Raw = originalData
+ unk.ContentType = runtime.ContentTypeJSON
+ unk.GetObjectKind().SetGroupVersionKind(*actual)
return unk, actual, nil
}
if into != nil {
- typed, _, err := s.typer.ObjectKind(into)
+ types, _, err := s.typer.ObjectKinds(into)
switch {
case runtime.IsNotRegisteredError(err):
if err := codec.NewDecoderBytes(data, new(codec.JsonHandle)).Decode(into); err != nil {
@@ -122,6 +126,7 @@ func (s *Serializer) Decode(originalData []byte, gvk *unversioned.GroupVersionKi
case err != nil:
return nil, actual, err
default:
+ typed := types[0]
if len(actual.Kind) == 0 {
actual.Kind = typed.Kind
}
@@ -154,8 +159,8 @@ func (s *Serializer) Decode(originalData []byte, gvk *unversioned.GroupVersionKi
return obj, actual, nil
}
-// EncodeToStream serializes the provided object to the given writer. Overrides is ignored.
-func (s *Serializer) EncodeToStream(obj runtime.Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
+// Encode serializes the provided object to the given writer.
+func (s *Serializer) Encode(obj runtime.Object, w io.Writer) error {
if s.yaml {
json, err := json.Marshal(obj)
if err != nil {
@@ -182,10 +187,57 @@ func (s *Serializer) EncodeToStream(obj runtime.Object, w io.Writer, overrides .
}
// RecognizesData implements the RecognizingDecoder interface.
-func (s *Serializer) RecognizesData(peek io.Reader) (bool, error) {
- _, ok := utilyaml.GuessJSONStream(peek, 2048)
+func (s *Serializer) RecognizesData(peek io.Reader) (ok, unknown bool, err error) {
if s.yaml {
- return !ok, nil
+ // we could potentially look for '---'
+ return false, true, nil
+ }
+ _, ok = utilyaml.GuessJSONStream(peek, 2048)
+ return ok, false, nil
+}
+
+// Framer is the default JSON framing behavior, with newlines delimiting individual objects.
+var Framer = jsonFramer{}
+
+type jsonFramer struct{}
+
+// NewFrameWriter implements stream framing for this serializer
+func (jsonFramer) NewFrameWriter(w io.Writer) io.Writer {
+ // we can write JSON objects directly to the writer, because they are self-framing
+ return w
+}
+
+// NewFrameReader implements stream framing for this serializer
+func (jsonFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser {
+ // we need to extract the JSON chunks of data to pass to Decode()
+ return framer.NewJSONFramedReader(r)
+}
+
+// Framer is the default JSON framing behavior, with newlines delimiting individual objects.
+var YAMLFramer = yamlFramer{}
+
+type yamlFramer struct{}
+
+// NewFrameWriter implements stream framing for this serializer
+func (yamlFramer) NewFrameWriter(w io.Writer) io.Writer {
+ return yamlFrameWriter{w}
+}
+
+// NewFrameReader implements stream framing for this serializer
+func (yamlFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser {
+ // extract the YAML document chunks directly
+ return utilyaml.NewDocumentDecoder(r)
+}
+
+type yamlFrameWriter struct {
+ w io.Writer
+}
+
+// Write separates each document with the YAML document separator (`---` followed by line
+// break). Writers must write well formed YAML documents (include a final line break).
+func (w yamlFrameWriter) Write(data []byte) (n int, err error) {
+ if _, err := w.w.Write([]byte("---\n")); err != nil {
+ return 0, err
}
- return ok, nil
+ return w.w.Write(data)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/json/meta.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/json/meta.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/json/meta.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/serializer/json/meta.go
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/negotiated_codec.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/negotiated_codec.go
new file mode 100644
index 0000000000000000000000000000000000000000..6f6a56dd3fa5a745e1bd2cce552e27e091aa24c1
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/negotiated_codec.go
@@ -0,0 +1,57 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 serializer
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// TODO: We should figure out what happens when someone asks
+// encoder for version and it conflicts with the raw serializer.
+type negotiatedSerializerWrapper struct {
+ info runtime.SerializerInfo
+ streamInfo runtime.StreamSerializerInfo
+}
+
+func NegotiatedSerializerWrapper(info runtime.SerializerInfo, streamInfo runtime.StreamSerializerInfo) runtime.NegotiatedSerializer {
+ return &negotiatedSerializerWrapper{info, streamInfo}
+}
+
+func (n *negotiatedSerializerWrapper) SupportedMediaTypes() []string {
+ return []string{}
+}
+
+func (n *negotiatedSerializerWrapper) SerializerForMediaType(mediaType string, options map[string]string) (runtime.SerializerInfo, bool) {
+ return n.info, true
+}
+
+func (n *negotiatedSerializerWrapper) SupportedStreamingMediaTypes() []string {
+ return []string{}
+}
+
+func (n *negotiatedSerializerWrapper) StreamingSerializerForMediaType(mediaType string, options map[string]string) (runtime.StreamSerializerInfo, bool) {
+ return n.streamInfo, true
+}
+
+func (n *negotiatedSerializerWrapper) EncoderForVersion(e runtime.Encoder, _ unversioned.GroupVersion) runtime.Encoder {
+ return e
+}
+
+func (n *negotiatedSerializerWrapper) DecoderToVersion(d runtime.Decoder, _gv unversioned.GroupVersion) runtime.Decoder {
+ return d
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/doc.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..91b86af6cdb73040dfb245faa75b9b167c447303
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 protobuf provides a Kubernetes serializer for the protobuf format.
+package protobuf
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/protobuf.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/protobuf.go
new file mode 100644
index 0000000000000000000000000000000000000000..a202a18d66554a805656fe6ab4885230051d060a
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf/protobuf.go
@@ -0,0 +1,433 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 protobuf
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "reflect"
+
+ "github.com/gogo/protobuf/proto"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/framer"
+)
+
+var (
+ // protoEncodingPrefix serves as a magic number for an encoded protobuf message on this serializer. All
+ // proto messages serialized by this schema will be preceded by the bytes 0x6b 0x38 0x73, with the fourth
+ // byte being reserved for the encoding style. The only encoding style defined is 0x00, which means that
+ // the rest of the byte stream is a message of type k8s.io.kubernetes.pkg.runtime.Unknown (proto2).
+ //
+ // See k8s.io/kubernetes/pkg/runtime/generated.proto for details of the runtime.Unknown message.
+ //
+ // This encoding scheme is experimental, and is subject to change at any time.
+ protoEncodingPrefix = []byte{0x6b, 0x38, 0x73, 0x00}
+)
+
+type errNotMarshalable struct {
+ t reflect.Type
+}
+
+func (e errNotMarshalable) Error() string {
+ return fmt.Sprintf("object %v does not implement the protobuf marshalling interface and cannot be encoded to a protobuf message", e.t)
+}
+
+func IsNotMarshalable(err error) bool {
+ _, ok := err.(errNotMarshalable)
+ return err != nil && ok
+}
+
+// NewSerializer creates a Protobuf serializer that handles encoding versioned objects into the proper wire form. If a typer
+// is passed, the encoded object will have group, version, and kind fields set. If typer is nil, the objects will be written
+// as-is (any type info passed with the object will be used).
+//
+// This encoding scheme is experimental, and is subject to change at any time.
+func NewSerializer(creater runtime.ObjectCreater, typer runtime.ObjectTyper, defaultContentType string) *Serializer {
+ return &Serializer{
+ prefix: protoEncodingPrefix,
+ creater: creater,
+ typer: typer,
+ contentType: defaultContentType,
+ }
+}
+
+type Serializer struct {
+ prefix []byte
+ creater runtime.ObjectCreater
+ typer runtime.ObjectTyper
+ contentType string
+}
+
+var _ runtime.Serializer = &Serializer{}
+
+// Decode attempts to convert the provided data into a protobuf message, extract the stored schema kind, apply the provided default
+// gvk, and then load that data into an object matching the desired schema kind or the provided into. If into is *runtime.Unknown,
+// the raw data will be extracted and no decoding will be performed. If into is not registered with the typer, then the object will
+// be straight decoded using normal protobuf unmarshalling (the MarshalTo interface). If into is provided and the original data is
+// not fully qualified with kind/version/group, the type of the into will be used to alter the returned gvk. On success or most
+// errors, the method will return the calculated schema kind.
+func (s *Serializer) Decode(originalData []byte, gvk *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ if versioned, ok := into.(*runtime.VersionedObjects); ok {
+ into = versioned.Last()
+ obj, actual, err := s.Decode(originalData, gvk, into)
+ if err != nil {
+ return nil, actual, err
+ }
+ // the last item in versioned becomes into, so if versioned was not originally empty we reset the object
+ // array so the first position is the decoded object and the second position is the outermost object.
+ // if there were no objects in the versioned list passed to us, only add ourselves.
+ if into != nil && into != obj {
+ versioned.Objects = []runtime.Object{obj, into}
+ } else {
+ versioned.Objects = []runtime.Object{obj}
+ }
+ return versioned, actual, err
+ }
+
+ prefixLen := len(s.prefix)
+ switch {
+ case len(originalData) == 0:
+ // TODO: treat like decoding {} from JSON with defaulting
+ return nil, nil, fmt.Errorf("empty data")
+ case len(originalData) < prefixLen || !bytes.Equal(s.prefix, originalData[:prefixLen]):
+ return nil, nil, fmt.Errorf("provided data does not appear to be a protobuf message, expected prefix %v", s.prefix)
+ case len(originalData) == prefixLen:
+ // TODO: treat like decoding {} from JSON with defaulting
+ return nil, nil, fmt.Errorf("empty body")
+ }
+
+ data := originalData[prefixLen:]
+ unk := runtime.Unknown{}
+ if err := unk.Unmarshal(data); err != nil {
+ return nil, nil, err
+ }
+
+ actual := unk.GroupVersionKind()
+ copyKindDefaults(&actual, gvk)
+
+ if intoUnknown, ok := into.(*runtime.Unknown); ok && intoUnknown != nil {
+ *intoUnknown = unk
+ if len(intoUnknown.ContentType) == 0 {
+ intoUnknown.ContentType = s.contentType
+ }
+ return intoUnknown, &actual, nil
+ }
+
+ if into != nil {
+ types, _, err := s.typer.ObjectKinds(into)
+ switch {
+ case runtime.IsNotRegisteredError(err):
+ pb, ok := into.(proto.Message)
+ if !ok {
+ return nil, &actual, errNotMarshalable{reflect.TypeOf(into)}
+ }
+ if err := proto.Unmarshal(unk.Raw, pb); err != nil {
+ return nil, &actual, err
+ }
+ return into, &actual, nil
+ case err != nil:
+ return nil, &actual, err
+ default:
+ copyKindDefaults(&actual, &types[0])
+ // if the result of defaulting did not set a version or group, ensure that at least group is set
+ // (copyKindDefaults will not assign Group if version is already set). This guarantees that the group
+ // of into is set if there is no better information from the caller or object.
+ if len(actual.Version) == 0 && len(actual.Group) == 0 {
+ actual.Group = types[0].Group
+ }
+ }
+ }
+
+ if len(actual.Kind) == 0 {
+ return nil, &actual, runtime.NewMissingKindErr(fmt.Sprintf("%#v", unk.TypeMeta))
+ }
+ if len(actual.Version) == 0 {
+ return nil, &actual, runtime.NewMissingVersionErr(fmt.Sprintf("%#v", unk.TypeMeta))
+ }
+
+ return unmarshalToObject(s.typer, s.creater, &actual, into, unk.Raw)
+}
+
+// Encode serializes the provided object to the given writer.
+func (s *Serializer) Encode(obj runtime.Object, w io.Writer) error {
+ var unk runtime.Unknown
+ kind := obj.GetObjectKind().GroupVersionKind()
+ unk = runtime.Unknown{
+ TypeMeta: runtime.TypeMeta{
+ Kind: kind.Kind,
+ APIVersion: kind.GroupVersion().String(),
+ },
+ }
+
+ prefixSize := uint64(len(s.prefix))
+
+ switch t := obj.(type) {
+ case bufferedMarshaller:
+ // this path performs a single allocation during write but requires the caller to implement
+ // the more efficient Size and MarshalTo methods
+ encodedSize := uint64(t.Size())
+ estimatedSize := prefixSize + estimateUnknownSize(&unk, encodedSize)
+ data := make([]byte, estimatedSize)
+
+ i, err := unk.NestedMarshalTo(data[prefixSize:], t, encodedSize)
+ if err != nil {
+ return err
+ }
+
+ copy(data, s.prefix)
+
+ _, err = w.Write(data[:prefixSize+uint64(i)])
+ return err
+
+ case proto.Marshaler:
+ // this path performs extra allocations
+ data, err := t.Marshal()
+ if err != nil {
+ return err
+ }
+ unk.Raw = data
+
+ estimatedSize := prefixSize + uint64(unk.Size())
+ data = make([]byte, estimatedSize)
+
+ i, err := unk.MarshalTo(data[prefixSize:])
+ if err != nil {
+ return err
+ }
+
+ copy(data, s.prefix)
+
+ _, err = w.Write(data[:prefixSize+uint64(i)])
+ return err
+
+ default:
+ // TODO: marshal with a different content type and serializer (JSON for third party objects)
+ return errNotMarshalable{reflect.TypeOf(obj)}
+ }
+}
+
+// RecognizesData implements the RecognizingDecoder interface.
+func (s *Serializer) RecognizesData(peek io.Reader) (bool, error) {
+ prefix := make([]byte, 4)
+ n, err := peek.Read(prefix)
+ if err != nil {
+ if err == io.EOF {
+ return false, nil
+ }
+ return false, err
+ }
+ if n != 4 {
+ return false, nil
+ }
+ return bytes.Equal(s.prefix, prefix), nil
+}
+
+// copyKindDefaults defaults dst to the value in src if dst does not have a value set.
+func copyKindDefaults(dst, src *unversioned.GroupVersionKind) {
+ if src == nil {
+ return
+ }
+ // apply kind and version defaulting from provided default
+ if len(dst.Kind) == 0 {
+ dst.Kind = src.Kind
+ }
+ if len(dst.Version) == 0 && len(src.Version) > 0 {
+ dst.Group = src.Group
+ dst.Version = src.Version
+ }
+}
+
+// bufferedMarshaller describes a more efficient marshalling interface that can avoid allocating multiple
+// byte buffers by pre-calculating the size of the final buffer needed.
+type bufferedMarshaller interface {
+ proto.Sizer
+ runtime.ProtobufMarshaller
+}
+
+// estimateUnknownSize returns the expected bytes consumed by a given runtime.Unknown
+// object with a nil RawJSON struct and the expected size of the provided buffer. The
+// returned size will not be correct if RawJSOn is set on unk.
+func estimateUnknownSize(unk *runtime.Unknown, byteSize uint64) uint64 {
+ size := uint64(unk.Size())
+ // protobuf uses 1 byte for the tag, a varint for the length of the array (at most 8 bytes - uint64 - here),
+ // and the size of the array.
+ size += 1 + 8 + byteSize
+ return size
+}
+
+// NewRawSerializer creates a Protobuf serializer that handles encoding versioned objects into the proper wire form. If typer
+// is not nil, the object has the group, version, and kind fields set. This serializer does not provide type information for the
+// encoded object, and thus is not self describing (callers must know what type is being described in order to decode).
+//
+// This encoding scheme is experimental, and is subject to change at any time.
+func NewRawSerializer(creater runtime.ObjectCreater, typer runtime.ObjectTyper, defaultContentType string) *RawSerializer {
+ return &RawSerializer{
+ creater: creater,
+ typer: typer,
+ contentType: defaultContentType,
+ }
+}
+
+// RawSerializer encodes and decodes objects without adding a runtime.Unknown wrapper (objects are encoded without identifying
+// type).
+type RawSerializer struct {
+ creater runtime.ObjectCreater
+ typer runtime.ObjectTyper
+ contentType string
+}
+
+var _ runtime.Serializer = &RawSerializer{}
+
+// Decode attempts to convert the provided data into a protobuf message, extract the stored schema kind, apply the provided default
+// gvk, and then load that data into an object matching the desired schema kind or the provided into. If into is *runtime.Unknown,
+// the raw data will be extracted and no decoding will be performed. If into is not registered with the typer, then the object will
+// be straight decoded using normal protobuf unmarshalling (the MarshalTo interface). If into is provided and the original data is
+// not fully qualified with kind/version/group, the type of the into will be used to alter the returned gvk. On success or most
+// errors, the method will return the calculated schema kind.
+func (s *RawSerializer) Decode(originalData []byte, gvk *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ if into == nil {
+ return nil, nil, fmt.Errorf("this serializer requires an object to decode into: %#v", s)
+ }
+
+ if versioned, ok := into.(*runtime.VersionedObjects); ok {
+ into = versioned.Last()
+ obj, actual, err := s.Decode(originalData, gvk, into)
+ if err != nil {
+ return nil, actual, err
+ }
+ if into != nil && into != obj {
+ versioned.Objects = []runtime.Object{obj, into}
+ } else {
+ versioned.Objects = []runtime.Object{obj}
+ }
+ return versioned, actual, err
+ }
+
+ if len(originalData) == 0 {
+ // TODO: treat like decoding {} from JSON with defaulting
+ return nil, nil, fmt.Errorf("empty data")
+ }
+ data := originalData
+
+ actual := &unversioned.GroupVersionKind{}
+ copyKindDefaults(actual, gvk)
+
+ if intoUnknown, ok := into.(*runtime.Unknown); ok && intoUnknown != nil {
+ intoUnknown.Raw = data
+ intoUnknown.ContentEncoding = ""
+ intoUnknown.ContentType = s.contentType
+ intoUnknown.SetGroupVersionKind(*actual)
+ return intoUnknown, actual, nil
+ }
+
+ types, _, err := s.typer.ObjectKinds(into)
+ switch {
+ case runtime.IsNotRegisteredError(err):
+ pb, ok := into.(proto.Message)
+ if !ok {
+ return nil, actual, errNotMarshalable{reflect.TypeOf(into)}
+ }
+ if err := proto.Unmarshal(data, pb); err != nil {
+ return nil, actual, err
+ }
+ return into, actual, nil
+ case err != nil:
+ return nil, actual, err
+ default:
+ copyKindDefaults(actual, &types[0])
+ // if the result of defaulting did not set a version or group, ensure that at least group is set
+ // (copyKindDefaults will not assign Group if version is already set). This guarantees that the group
+ // of into is set if there is no better information from the caller or object.
+ if len(actual.Version) == 0 && len(actual.Group) == 0 {
+ actual.Group = types[0].Group
+ }
+ }
+
+ if len(actual.Kind) == 0 {
+ return nil, actual, runtime.NewMissingKindErr("<protobuf encoded body - must provide default type>")
+ }
+ if len(actual.Version) == 0 {
+ return nil, actual, runtime.NewMissingVersionErr("<protobuf encoded body - must provide default type>")
+ }
+
+ return unmarshalToObject(s.typer, s.creater, actual, into, data)
+}
+
+// unmarshalToObject is the common code between decode in the raw and normal serializer.
+func unmarshalToObject(typer runtime.ObjectTyper, creater runtime.ObjectCreater, actual *unversioned.GroupVersionKind, into runtime.Object, data []byte) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ // use the target if necessary
+ obj, err := runtime.UseOrCreateObject(typer, creater, *actual, into)
+ if err != nil {
+ return nil, actual, err
+ }
+
+ pb, ok := obj.(proto.Message)
+ if !ok {
+ return nil, actual, errNotMarshalable{reflect.TypeOf(obj)}
+ }
+ if err := proto.Unmarshal(data, pb); err != nil {
+ return nil, actual, err
+ }
+ return obj, actual, nil
+}
+
+// Encode serializes the provided object to the given writer. Overrides is ignored.
+func (s *RawSerializer) Encode(obj runtime.Object, w io.Writer) error {
+ switch t := obj.(type) {
+ case bufferedMarshaller:
+ // this path performs a single allocation during write but requires the caller to implement
+ // the more efficient Size and MarshalTo methods
+ encodedSize := uint64(t.Size())
+ data := make([]byte, encodedSize)
+
+ n, err := t.MarshalTo(data)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data[:n])
+ return err
+
+ case proto.Marshaler:
+ // this path performs extra allocations
+ data, err := t.Marshal()
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data)
+ return err
+
+ default:
+ return errNotMarshalable{reflect.TypeOf(obj)}
+ }
+}
+
+var LengthDelimitedFramer = lengthDelimitedFramer{}
+
+type lengthDelimitedFramer struct{}
+
+// NewFrameWriter implements stream framing for this serializer
+func (lengthDelimitedFramer) NewFrameWriter(w io.Writer) io.Writer {
+ return framer.NewLengthDelimitedFrameWriter(w)
+}
+
+// NewFrameReader implements stream framing for this serializer
+func (lengthDelimitedFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser {
+ return framer.NewLengthDelimitedFrameReader(r)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf_extension.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf_extension.go
new file mode 100644
index 0000000000000000000000000000000000000000..a93708c45d059353213156426b6376d319f607b7
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/protobuf_extension.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 serializer
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer/protobuf"
+)
+
+const (
+ // contentTypeProtobuf is the protobuf type exposed for Kubernetes. It is private to prevent others from
+ // depending on it unintentionally.
+ // TODO: potentially move to pkg/api (since it's part of the Kube public API) and pass it in to the
+ // CodecFactory on initialization.
+ contentTypeProtobuf = "application/vnd.kubernetes.protobuf"
+ contentTypeProtobufWatch = contentTypeProtobuf + ";stream=watch"
+)
+
+func protobufSerializer(scheme *runtime.Scheme) (serializerType, bool) {
+ serializer := protobuf.NewSerializer(scheme, scheme, contentTypeProtobuf)
+ raw := protobuf.NewRawSerializer(scheme, scheme, contentTypeProtobuf)
+ return serializerType{
+ AcceptContentTypes: []string{contentTypeProtobuf},
+ ContentType: contentTypeProtobuf,
+ FileExtensions: []string{"pb"},
+ Serializer: serializer,
+ RawSerializer: raw,
+
+ AcceptStreamContentTypes: []string{contentTypeProtobuf, contentTypeProtobufWatch},
+ StreamContentType: contentTypeProtobufWatch,
+ Framer: protobuf.LengthDelimitedFramer,
+ StreamSerializer: raw,
+ }, true
+}
+
+func init() {
+ serializerExtensions = append(serializerExtensions, protobufSerializer)
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b8b1e204e395c835faab42f4fe61818b6c852f0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/recognizer/recognizer.go
@@ -0,0 +1,127 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 recognizer
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+type RecognizingDecoder interface {
+ runtime.Decoder
+ // RecognizesData should return true if the input provided in the provided reader
+ // belongs to this decoder, or an error if the data could not be read or is ambiguous.
+ // Unknown is true if the data could not be determined to match the decoder type.
+ // Decoders should assume that they can read as much of peek as they need (as the caller
+ // provides) and may return unknown if the data provided is not sufficient to make a
+ // a determination. When peek returns EOF that may mean the end of the input or the
+ // end of buffered input - recognizers should return the best guess at that time.
+ RecognizesData(peek io.Reader) (ok, unknown bool, err error)
+}
+
+// NewDecoder creates a decoder that will attempt multiple decoders in an order defined
+// by:
+//
+// 1. The decoder implements RecognizingDecoder and identifies the data
+// 2. All other decoders, and any decoder that returned true for unknown.
+//
+// The order passed to the constructor is preserved within those priorities.
+func NewDecoder(decoders ...runtime.Decoder) runtime.Decoder {
+ return &decoder{
+ decoders: decoders,
+ }
+}
+
+type decoder struct {
+ decoders []runtime.Decoder
+}
+
+var _ RecognizingDecoder = &decoder{}
+
+func (d *decoder) RecognizesData(peek io.Reader) (bool, bool, error) {
+ var (
+ lastErr error
+ anyUnknown bool
+ )
+ data, _ := bufio.NewReaderSize(peek, 1024).Peek(1024)
+ for _, r := range d.decoders {
+ switch t := r.(type) {
+ case RecognizingDecoder:
+ ok, unknown, err := t.RecognizesData(bytes.NewBuffer(data))
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ anyUnknown = anyUnknown || unknown
+ if !ok {
+ continue
+ }
+ return true, false, nil
+ }
+ }
+ return false, anyUnknown, lastErr
+}
+
+func (d *decoder) Decode(data []byte, gvk *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ var (
+ lastErr error
+ skipped []runtime.Decoder
+ )
+
+ // try recognizers, record any decoders we need to give a chance later
+ for _, r := range d.decoders {
+ switch t := r.(type) {
+ case RecognizingDecoder:
+ buf := bytes.NewBuffer(data)
+ ok, unknown, err := t.RecognizesData(buf)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ if unknown {
+ skipped = append(skipped, t)
+ continue
+ }
+ if !ok {
+ continue
+ }
+ return r.Decode(data, gvk, into)
+ default:
+ skipped = append(skipped, t)
+ }
+ }
+
+ // try recognizers that returned unknown or didn't recognize their data
+ for _, r := range skipped {
+ out, actual, err := r.Decode(data, gvk, into)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ return out, actual, nil
+ }
+
+ if lastErr == nil {
+ lastErr = fmt.Errorf("no serialization format matched the provided data")
+ }
+ return nil, nil, lastErr
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/serializer/streaming/streaming.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/streaming/streaming.go
new file mode 100644
index 0000000000000000000000000000000000000000..c34f9a570db8ba2afb2e9e8d789f4c002f1e81ac
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/streaming/streaming.go
@@ -0,0 +1,137 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 streaming implements encoder and decoder for streams
+// of runtime.Objects over io.Writer/Readers.
+package streaming
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Encoder is a runtime.Encoder on a stream.
+type Encoder interface {
+ // Encode will write the provided object to the stream or return an error. It obeys the same
+ // contract as runtime.VersionedEncoder.
+ Encode(obj runtime.Object) error
+}
+
+// Decoder is a runtime.Decoder from a stream.
+type Decoder interface {
+ // Decode will return io.EOF when no more objects are available.
+ Decode(defaults *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error)
+ // Close closes the underlying stream.
+ Close() error
+}
+
+// Serializer is a factory for creating encoders and decoders that work over streams.
+type Serializer interface {
+ NewEncoder(w io.Writer) Encoder
+ NewDecoder(r io.ReadCloser) Decoder
+}
+
+type decoder struct {
+ reader io.ReadCloser
+ decoder runtime.Decoder
+ buf []byte
+ maxBytes int
+ resetRead bool
+}
+
+// NewDecoder creates a streaming decoder that reads object chunks from r and decodes them with d.
+// The reader is expected to return ErrShortRead if the provided buffer is not large enough to read
+// an entire object.
+func NewDecoder(r io.ReadCloser, d runtime.Decoder) Decoder {
+ return &decoder{
+ reader: r,
+ decoder: d,
+ buf: make([]byte, 1024),
+ maxBytes: 1024 * 1024,
+ }
+}
+
+var ErrObjectTooLarge = fmt.Errorf("object to decode was longer than maximum allowed size")
+
+// Decode reads the next object from the stream and decodes it.
+func (d *decoder) Decode(defaults *unversioned.GroupVersionKind, into runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+ base := 0
+ for {
+ n, err := d.reader.Read(d.buf[base:])
+ if err == io.ErrShortBuffer {
+ if n == 0 {
+ return nil, nil, fmt.Errorf("got short buffer with n=0, base=%d, cap=%d", base, cap(d.buf))
+ }
+ if d.resetRead {
+ continue
+ }
+ // double the buffer size up to maxBytes
+ if len(d.buf) < d.maxBytes {
+ base += n
+ d.buf = append(d.buf, make([]byte, len(d.buf))...)
+ continue
+ }
+ // must read the rest of the frame (until we stop getting ErrShortBuffer)
+ d.resetRead = true
+ base = 0
+ return nil, nil, ErrObjectTooLarge
+ }
+ if err != nil {
+ return nil, nil, err
+ }
+ if d.resetRead {
+ // now that we have drained the large read, continue
+ d.resetRead = false
+ continue
+ }
+ base += n
+ break
+ }
+ return d.decoder.Decode(d.buf[:base], defaults, into)
+}
+
+func (d *decoder) Close() error {
+ return d.reader.Close()
+}
+
+type encoder struct {
+ writer io.Writer
+ encoder runtime.Encoder
+ buf *bytes.Buffer
+}
+
+// NewEncoder returns a new streaming encoder.
+func NewEncoder(w io.Writer, e runtime.Encoder) Encoder {
+ return &encoder{
+ writer: w,
+ encoder: e,
+ buf: &bytes.Buffer{},
+ }
+}
+
+// Encode writes the provided object to the nested writer.
+func (e *encoder) Encode(obj runtime.Object) error {
+ if err := e.encoder.Encode(obj, e.buf); err != nil {
+ return err
+ }
+ _, err := e.writer.Write(e.buf.Bytes())
+ e.buf.Reset()
+ return err
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go
similarity index 68%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go
index 0ded5365ddc3c98bc4393044819b785f17f20dae..f69d126c8c2d858f5d1d03522a4810fc3d83b90f 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/serializer/versioning/versioning.go
@@ -27,6 +27,7 @@ import (
// EnableCrossGroupDecoding modifies the given decoder in place, if it is a codec
// from this package. It allows objects from one group to be auto-decoded into
// another group. 'destGroup' must already exist in the codec.
+// TODO: this is an encapsulation violation and should be refactored
func EnableCrossGroupDecoding(d runtime.Decoder, sourceGroup, destGroup string) error {
internal, ok := d.(*codec)
if !ok {
@@ -45,6 +46,7 @@ func EnableCrossGroupDecoding(d runtime.Decoder, sourceGroup, destGroup string)
// EnableCrossGroupEncoding modifies the given encoder in place, if it is a codec
// from this package. It allows objects from one group to be auto-decoded into
// another group. 'destGroup' must already exist in the codec.
+// TODO: this is an encapsulation violation and should be refactored
func EnableCrossGroupEncoding(e runtime.Encoder, sourceGroup, destGroup string) error {
internal, ok := e.(*codec)
if !ok {
@@ -64,31 +66,34 @@ func EnableCrossGroupEncoding(e runtime.Encoder, sourceGroup, destGroup string)
func NewCodecForScheme(
// TODO: I should be a scheme interface?
scheme *runtime.Scheme,
- serializer runtime.Serializer,
+ encoder runtime.Encoder,
+ decoder runtime.Decoder,
encodeVersion []unversioned.GroupVersion,
decodeVersion []unversioned.GroupVersion,
) runtime.Codec {
- return NewCodec(serializer, scheme, scheme, scheme, runtime.ObjectTyperToTyper(scheme), encodeVersion, decodeVersion)
+ return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, encodeVersion, decodeVersion)
}
// NewCodec takes objects in their internal versions and converts them to external versions before
// serializing them. It assumes the serializer provided to it only deals with external versions.
// This class is also a serializer, but is generally used with a specific version.
func NewCodec(
- serializer runtime.Serializer,
+ encoder runtime.Encoder,
+ decoder runtime.Decoder,
convertor runtime.ObjectConvertor,
creater runtime.ObjectCreater,
copier runtime.ObjectCopier,
- typer runtime.Typer,
+ typer runtime.ObjectTyper,
encodeVersion []unversioned.GroupVersion,
decodeVersion []unversioned.GroupVersion,
) runtime.Codec {
internal := &codec{
- serializer: serializer,
- convertor: convertor,
- creater: creater,
- copier: copier,
- typer: typer,
+ encoder: encoder,
+ decoder: decoder,
+ convertor: convertor,
+ creater: creater,
+ copier: copier,
+ typer: typer,
}
if encodeVersion != nil {
internal.encodeVersion = make(map[string]unversioned.GroupVersion)
@@ -99,6 +104,11 @@ func NewCodec(
}
internal.encodeVersion[v.Group] = v
}
+ if len(internal.encodeVersion) == 1 {
+ for _, v := range internal.encodeVersion {
+ internal.preferredEncodeVersion = []unversioned.GroupVersion{v}
+ }
+ }
}
if decodeVersion != nil {
internal.decodeVersion = make(map[string]unversioned.GroupVersion)
@@ -115,14 +125,17 @@ func NewCodec(
}
type codec struct {
- serializer runtime.Serializer
- convertor runtime.ObjectConvertor
- creater runtime.ObjectCreater
- copier runtime.ObjectCopier
- typer runtime.Typer
+ encoder runtime.Encoder
+ decoder runtime.Decoder
+ convertor runtime.ObjectConvertor
+ creater runtime.ObjectCreater
+ copier runtime.ObjectCopier
+ typer runtime.ObjectTyper
encodeVersion map[string]unversioned.GroupVersion
decodeVersion map[string]unversioned.GroupVersion
+
+ preferredEncodeVersion []unversioned.GroupVersion
}
// Decode attempts a decode of the object, then tries to convert it to the internal version. If into is provided and the decoding is
@@ -134,7 +147,7 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
into = versioned.Last()
}
- obj, gvk, err := c.serializer.Decode(data, defaultGVK, into)
+ obj, gvk, err := c.decoder.Decode(data, defaultGVK, into)
if err != nil {
return nil, gvk, err
}
@@ -198,7 +211,7 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
}
// Convert if needed.
- out, err := c.convertor.ConvertToVersion(obj, targetGV.String())
+ out, err := c.convertor.ConvertToVersion(obj, targetGV)
if err != nil {
return nil, gvk, err
}
@@ -209,44 +222,33 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
return out, gvk, nil
}
-// EncodeToStream ensures the provided object is output in the right scheme. If overrides are specified, when
-// encoding the object the first override that matches the object's group is used. Other overrides are ignored.
-func (c *codec) EncodeToStream(obj runtime.Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
+// Encode ensures the provided object is output in the appropriate group and version, invoking
+// conversion if necessary. Unversioned objects (according to the ObjectTyper) are output as is.
+func (c *codec) Encode(obj runtime.Object, w io.Writer) error {
if _, ok := obj.(*runtime.Unknown); ok {
- return c.serializer.EncodeToStream(obj, w, overrides...)
+ return c.encoder.Encode(obj, w)
}
- gvk, isUnversioned, err := c.typer.ObjectKind(obj)
+ gvks, isUnversioned, err := c.typer.ObjectKinds(obj)
if err != nil {
return err
}
-
- if (c.encodeVersion == nil && len(overrides) == 0) || isUnversioned {
- old := obj.GetObjectKind().GroupVersionKind()
- obj.GetObjectKind().SetGroupVersionKind(gvk)
- defer obj.GetObjectKind().SetGroupVersionKind(old)
- return c.serializer.EncodeToStream(obj, w, overrides...)
+ gvk := gvks[0]
+
+ if c.encodeVersion == nil || isUnversioned {
+ objectKind := obj.GetObjectKind()
+ old := objectKind.GroupVersionKind()
+ objectKind.SetGroupVersionKind(gvk)
+ err = c.encoder.Encode(obj, w)
+ objectKind.SetGroupVersionKind(old)
+ return err
}
targetGV, ok := c.encodeVersion[gvk.Group]
- // use override if provided
- for i, override := range overrides {
- if override.Group == gvk.Group {
- ok = true
- targetGV = override
- // swap the position of the override
- overrides[0], overrides[i] = targetGV, overrides[0]
- break
- }
- }
// attempt a conversion to the sole encode version
- if !ok && len(c.encodeVersion) == 1 {
+ if !ok && c.preferredEncodeVersion != nil {
ok = true
- for _, v := range c.encodeVersion {
- targetGV = v
- }
- // ensure the target override is first
- overrides = promoteOrPrependGroupVersion(targetGV, overrides)
+ targetGV = c.preferredEncodeVersion[0]
}
// if no fallback is available, error
@@ -255,33 +257,19 @@ func (c *codec) EncodeToStream(obj runtime.Object, w io.Writer, overrides ...unv
}
// Perform a conversion if necessary
- if gvk.GroupVersion() != targetGV {
- out, err := c.convertor.ConvertToVersion(obj, targetGV.String())
- if err != nil {
- if ok {
- return err
- }
- } else {
- obj = out
+ objectKind := obj.GetObjectKind()
+ old := objectKind.GroupVersionKind()
+ out, err := c.convertor.ConvertToVersion(obj, targetGV)
+ if err != nil {
+ if ok {
+ return err
}
} else {
- old := obj.GetObjectKind().GroupVersionKind()
- defer obj.GetObjectKind().SetGroupVersionKind(old)
- obj.GetObjectKind().SetGroupVersionKind(&unversioned.GroupVersionKind{Group: targetGV.Group, Version: targetGV.Version, Kind: gvk.Kind})
- }
-
- return c.serializer.EncodeToStream(obj, w, overrides...)
-}
-
-// promoteOrPrependGroupVersion finds the group version in the provided group versions that has the same group as target.
-// If the group is found the returned array will have that group version in the first position - if the group is not found
-// the returned array will have target in the first position.
-func promoteOrPrependGroupVersion(target unversioned.GroupVersion, gvs []unversioned.GroupVersion) []unversioned.GroupVersion {
- for i, gv := range gvs {
- if gv.Group == target.Group {
- gvs[0], gvs[i] = gvs[i], gvs[0]
- return gvs
- }
+ obj = out
}
- return append([]unversioned.GroupVersion{target}, gvs...)
+ // Conversion is responsible for setting the proper group, version, and kind onto the outgoing object
+ err = c.encoder.Encode(obj, w)
+ // restore the old GVK, in case conversion returned the same object
+ objectKind.SetGroupVersionKind(old)
+ return err
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go b/vendor/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go
index 8d922ccd663d1e7dd963856e407f8ad709e82677..19b8378a4912433fec3c43009f09a9529715a5c0 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/swagger_doc_generator.go
@@ -113,6 +113,37 @@ func fieldName(field *ast.Field) string {
return jsonTag
}
+// A buffer of lines that will be written.
+type bufferedLine struct {
+ line string
+ indentation int
+}
+
+type buffer struct {
+ lines []bufferedLine
+}
+
+func newBuffer() *buffer {
+ return &buffer{
+ lines: make([]bufferedLine, 0),
+ }
+}
+
+func (b *buffer) addLine(line string, indent int) {
+ b.lines = append(b.lines, bufferedLine{line, indent})
+}
+
+func (b *buffer) flushLines(w io.Writer) error {
+ for _, line := range b.lines {
+ indentation := strings.Repeat("\t", line.indentation)
+ fullLine := fmt.Sprintf("%s%s", indentation, line.line)
+ if _, err := io.WriteString(w, fullLine); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
func writeFuncHeader(b *buffer, structName string, indent int) {
s := fmt.Sprintf("var map_%s = map[string]string {\n", structName)
b.addLine(s, indent)
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/types.go b/vendor/k8s.io/kubernetes/pkg/runtime/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..e646d2afaf95bbba0a7f15a73cbc2ee3221e7a2f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/types.go
@@ -0,0 +1,514 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+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 runtime
+
+import (
+ "fmt"
+
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/api/meta/metatypes"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/types"
+)
+
+// Note that the types provided in this file are not versioned and are intended to be
+// safe to use from within all versions of every API object.
+
+// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
+// like this:
+// type MyAwesomeAPIObject struct {
+// runtime.TypeMeta `json:",inline"`
+// ... // other fields
+// }
+// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *unversioned.GroupVersionKind) { unversioned.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
+//
+// TypeMeta is provided here for convenience. You may use it directly from this package or define
+// your own with the same fields.
+//
+// +gencopy=true
+// +protobuf=true
+type TypeMeta struct {
+ APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"`
+ Kind string `json:"kind,omitempty" yaml:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"`
+}
+
+const (
+ ContentTypeJSON string = "application/json"
+)
+
+// 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.)
+//
+// +gencopy=true
+// +protobuf=true
+type RawExtension struct {
+ // Raw is the underlying serialization of this object.
+ //
+ // TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data.
+ Raw []byte `protobuf:"bytes,1,opt,name=raw"`
+ // Object can hold a representation of this extension - useful for working with versioned
+ // structs.
+ Object Object `json:"-"`
+}
+
+// Unknown allows api objects with unknown types to be passed-through. This can be used
+// to deal with the API objects from a plug-in. Unknown objects still have functioning
+// TypeMeta features-- kind, version, etc.
+// TODO: Make this object have easy access to field based accessors and settors for
+// metadata and field mutatation.
+//
+// +gencopy=true
+// +protobuf=true
+type Unknown struct {
+ TypeMeta `json:",inline" protobuf:"bytes,1,opt,name=typeMeta"`
+ // Raw will hold the complete serialized object which couldn't be matched
+ // with a registered type. Most likely, nothing should be done with this
+ // except for passing it through the system.
+ Raw []byte `protobuf:"bytes,2,opt,name=raw"`
+ // ContentEncoding is encoding used to encode 'Raw' data.
+ // Unspecified means no encoding.
+ ContentEncoding string `protobuf:"bytes,3,opt,name=contentEncoding"`
+ // ContentType is serialization method used to serialize 'Raw'.
+ // Unspecified means ContentTypeJSON.
+ ContentType string `protobuf:"bytes,4,opt,name=contentType"`
+}
+
+// Unstructured allows objects that do not have Golang structs registered to be manipulated
+// generically. This can be used to deal with the API objects from a plug-in. Unstructured
+// objects still have functioning TypeMeta features-- kind, version, etc.
+// TODO: Make this object have easy access to field based accessors and settors for
+// metadata and field mutatation.
+type Unstructured struct {
+ // Object is a JSON compatible map with string, float, int, []interface{}, or map[string]interface{}
+ // children.
+ Object map[string]interface{}
+}
+
+func getNestedField(obj map[string]interface{}, fields ...string) interface{} {
+ var val interface{} = obj
+ for _, field := range fields {
+ if _, ok := val.(map[string]interface{}); !ok {
+ return nil
+ }
+ val = val.(map[string]interface{})[field]
+ }
+ return val
+}
+
+func getNestedString(obj map[string]interface{}, fields ...string) string {
+ if str, ok := getNestedField(obj, fields...).(string); ok {
+ return str
+ }
+ return ""
+}
+
+func getNestedSlice(obj map[string]interface{}, fields ...string) []string {
+ if m, ok := getNestedField(obj, fields...).([]interface{}); ok {
+ strSlice := make([]string, 0, len(m))
+ for _, v := range m {
+ if str, ok := v.(string); ok {
+ strSlice = append(strSlice, str)
+ }
+ }
+ return strSlice
+ }
+ return nil
+}
+
+func getNestedMap(obj map[string]interface{}, fields ...string) map[string]string {
+ if m, ok := getNestedField(obj, fields...).(map[string]interface{}); ok {
+ strMap := make(map[string]string, len(m))
+ for k, v := range m {
+ if str, ok := v.(string); ok {
+ strMap[k] = str
+ }
+ }
+ return strMap
+ }
+ return nil
+}
+
+func setNestedField(obj map[string]interface{}, value interface{}, fields ...string) {
+ m := obj
+ if len(fields) > 1 {
+ for _, field := range fields[0 : len(fields)-1] {
+ if _, ok := m[field].(map[string]interface{}); !ok {
+ m[field] = make(map[string]interface{})
+ }
+ m = m[field].(map[string]interface{})
+ }
+ }
+ m[fields[len(fields)-1]] = value
+}
+
+func setNestedSlice(obj map[string]interface{}, value []string, fields ...string) {
+ m := make([]interface{}, 0, len(value))
+ for _, v := range value {
+ m = append(m, v)
+ }
+ setNestedField(obj, m, fields...)
+}
+
+func setNestedMap(obj map[string]interface{}, value map[string]string, fields ...string) {
+ m := make(map[string]interface{}, len(value))
+ for k, v := range value {
+ m[k] = v
+ }
+ setNestedField(obj, m, fields...)
+}
+
+func (u *Unstructured) setNestedField(value interface{}, fields ...string) {
+ if u.Object == nil {
+ u.Object = make(map[string]interface{})
+ }
+ setNestedField(u.Object, value, fields...)
+}
+
+func (u *Unstructured) setNestedSlice(value []string, fields ...string) {
+ if u.Object == nil {
+ u.Object = make(map[string]interface{})
+ }
+ setNestedSlice(u.Object, value, fields...)
+}
+
+func (u *Unstructured) setNestedMap(value map[string]string, fields ...string) {
+ if u.Object == nil {
+ u.Object = make(map[string]interface{})
+ }
+ setNestedMap(u.Object, value, fields...)
+}
+
+func extractOwnerReference(src interface{}) metatypes.OwnerReference {
+ v := src.(map[string]interface{})
+ controllerPtr, ok := (getNestedField(v, "controller")).(*bool)
+ if !ok {
+ controllerPtr = nil
+ } else {
+ if controllerPtr != nil {
+ controller := *controllerPtr
+ controllerPtr = &controller
+ }
+ }
+ return metatypes.OwnerReference{
+ Kind: getNestedString(v, "kind"),
+ Name: getNestedString(v, "name"),
+ APIVersion: getNestedString(v, "apiVersion"),
+ UID: (types.UID)(getNestedString(v, "uid")),
+ Controller: controllerPtr,
+ }
+}
+
+func setOwnerReference(src metatypes.OwnerReference) map[string]interface{} {
+ ret := make(map[string]interface{})
+ controllerPtr := src.Controller
+ if controllerPtr != nil {
+ controller := *controllerPtr
+ controllerPtr = &controller
+ }
+ setNestedField(ret, src.Kind, "kind")
+ setNestedField(ret, src.Name, "name")
+ setNestedField(ret, src.APIVersion, "apiVersion")
+ setNestedField(ret, string(src.UID), "uid")
+ setNestedField(ret, controllerPtr, "controller")
+ return ret
+}
+
+func getOwnerReferences(object map[string]interface{}) ([]map[string]interface{}, error) {
+ field := getNestedField(object, "metadata", "ownerReferences")
+ if field == nil {
+ return nil, fmt.Errorf("cannot find field metadata.ownerReferences in %v", object)
+ }
+ ownerReferences, ok := field.([]map[string]interface{})
+ if ok {
+ return ownerReferences, nil
+ }
+ // TODO: This is hacky...
+ interfaces, ok := field.([]interface{})
+ if !ok {
+ return nil, fmt.Errorf("expect metadata.ownerReferences to be a slice in %#v", object)
+ }
+ ownerReferences = make([]map[string]interface{}, 0, len(interfaces))
+ for i := 0; i < len(interfaces); i++ {
+ r, ok := interfaces[i].(map[string]interface{})
+ if !ok {
+ return nil, fmt.Errorf("expect element metadata.ownerReferences to be a map[string]interface{} in %#v", object)
+ }
+ ownerReferences = append(ownerReferences, r)
+ }
+ return ownerReferences, nil
+}
+
+func (u *Unstructured) GetOwnerReferences() []metatypes.OwnerReference {
+ original, err := getOwnerReferences(u.Object)
+ if err != nil {
+ glog.V(6).Info(err)
+ return nil
+ }
+ ret := make([]metatypes.OwnerReference, 0, len(original))
+ for i := 0; i < len(original); i++ {
+ ret = append(ret, extractOwnerReference(original[i]))
+ }
+ return ret
+}
+
+func (u *Unstructured) SetOwnerReferences(references []metatypes.OwnerReference) {
+ var newReferences = make([]map[string]interface{}, 0, len(references))
+ for i := 0; i < len(references); i++ {
+ newReferences = append(newReferences, setOwnerReference(references[i]))
+ }
+ u.setNestedField(newReferences, "metadata", "ownerReferences")
+}
+
+func (u *Unstructured) GetAPIVersion() string {
+ return getNestedString(u.Object, "apiVersion")
+}
+
+func (u *Unstructured) SetAPIVersion(version string) {
+ u.setNestedField(version, "apiVersion")
+}
+
+func (u *Unstructured) GetKind() string {
+ return getNestedString(u.Object, "kind")
+}
+
+func (u *Unstructured) SetKind(kind string) {
+ u.setNestedField(kind, "kind")
+}
+
+func (u *Unstructured) GetNamespace() string {
+ return getNestedString(u.Object, "metadata", "namespace")
+}
+
+func (u *Unstructured) SetNamespace(namespace string) {
+ u.setNestedField(namespace, "metadata", "namespace")
+}
+
+func (u *Unstructured) GetName() string {
+ return getNestedString(u.Object, "metadata", "name")
+}
+
+func (u *Unstructured) SetName(name string) {
+ u.setNestedField(name, "metadata", "name")
+}
+
+func (u *Unstructured) GetGenerateName() string {
+ return getNestedString(u.Object, "metadata", "generateName")
+}
+
+func (u *Unstructured) SetGenerateName(name string) {
+ u.setNestedField(name, "metadata", "generateName")
+}
+
+func (u *Unstructured) GetUID() types.UID {
+ return types.UID(getNestedString(u.Object, "metadata", "uid"))
+}
+
+func (u *Unstructured) SetUID(uid types.UID) {
+ u.setNestedField(string(uid), "metadata", "uid")
+}
+
+func (u *Unstructured) GetResourceVersion() string {
+ return getNestedString(u.Object, "metadata", "resourceVersion")
+}
+
+func (u *Unstructured) SetResourceVersion(version string) {
+ u.setNestedField(version, "metadata", "resourceVersion")
+}
+
+func (u *Unstructured) GetSelfLink() string {
+ return getNestedString(u.Object, "metadata", "selfLink")
+}
+
+func (u *Unstructured) SetSelfLink(selfLink string) {
+ u.setNestedField(selfLink, "metadata", "selfLink")
+}
+
+func (u *Unstructured) GetCreationTimestamp() unversioned.Time {
+ var timestamp unversioned.Time
+ timestamp.UnmarshalQueryParameter(getNestedString(u.Object, "metadata", "creationTimestamp"))
+ return timestamp
+}
+
+func (u *Unstructured) SetCreationTimestamp(timestamp unversioned.Time) {
+ ts, _ := timestamp.MarshalQueryParameter()
+ u.setNestedField(ts, "metadata", "creationTimestamp")
+}
+
+func (u *Unstructured) GetDeletionTimestamp() *unversioned.Time {
+ var timestamp unversioned.Time
+ timestamp.UnmarshalQueryParameter(getNestedString(u.Object, "metadata", "deletionTimestamp"))
+ if timestamp.IsZero() {
+ return nil
+ }
+ return ×tamp
+}
+
+func (u *Unstructured) SetDeletionTimestamp(timestamp *unversioned.Time) {
+ ts, _ := timestamp.MarshalQueryParameter()
+ u.setNestedField(ts, "metadata", "deletionTimestamp")
+}
+
+func (u *Unstructured) GetLabels() map[string]string {
+ return getNestedMap(u.Object, "metadata", "labels")
+}
+
+func (u *Unstructured) SetLabels(labels map[string]string) {
+ u.setNestedMap(labels, "metadata", "labels")
+}
+
+func (u *Unstructured) GetAnnotations() map[string]string {
+ return getNestedMap(u.Object, "metadata", "annotations")
+}
+
+func (u *Unstructured) SetAnnotations(annotations map[string]string) {
+ u.setNestedMap(annotations, "metadata", "annotations")
+}
+
+func (u *Unstructured) SetGroupVersionKind(gvk unversioned.GroupVersionKind) {
+ u.SetAPIVersion(gvk.GroupVersion().String())
+ u.SetKind(gvk.Kind)
+}
+
+func (u *Unstructured) GroupVersionKind() unversioned.GroupVersionKind {
+ gv, err := unversioned.ParseGroupVersion(u.GetAPIVersion())
+ if err != nil {
+ return unversioned.GroupVersionKind{}
+ }
+ gvk := gv.WithKind(u.GetKind())
+ return gvk
+}
+
+func (u *Unstructured) GetFinalizers() []string {
+ return getNestedSlice(u.Object, "metadata", "finalizers")
+}
+
+func (u *Unstructured) SetFinalizers(finalizers []string) {
+ u.setNestedSlice(finalizers, "metadata", "finalizers")
+}
+
+// UnstructuredList allows lists that do not have Golang structs
+// registered to be manipulated generically. This can be used to deal
+// with the API lists from a plug-in.
+type UnstructuredList struct {
+ Object map[string]interface{}
+
+ // Items is a list of unstructured objects.
+ Items []*Unstructured `json:"items"`
+}
+
+func (u *UnstructuredList) setNestedField(value interface{}, fields ...string) {
+ if u.Object == nil {
+ u.Object = make(map[string]interface{})
+ }
+ setNestedField(u.Object, value, fields...)
+}
+
+func (u *UnstructuredList) GetAPIVersion() string {
+ return getNestedString(u.Object, "apiVersion")
+}
+
+func (u *UnstructuredList) SetAPIVersion(version string) {
+ u.setNestedField(version, "apiVersion")
+}
+
+func (u *UnstructuredList) GetKind() string {
+ return getNestedString(u.Object, "kind")
+}
+
+func (u *UnstructuredList) SetKind(kind string) {
+ u.setNestedField(kind, "kind")
+}
+
+func (u *UnstructuredList) GetResourceVersion() string {
+ return getNestedString(u.Object, "metadata", "resourceVersion")
+}
+
+func (u *UnstructuredList) SetResourceVersion(version string) {
+ u.setNestedField(version, "metadata", "resourceVersion")
+}
+
+func (u *UnstructuredList) GetSelfLink() string {
+ return getNestedString(u.Object, "metadata", "selfLink")
+}
+
+func (u *UnstructuredList) SetSelfLink(selfLink string) {
+ u.setNestedField(selfLink, "metadata", "selfLink")
+}
+
+func (u *UnstructuredList) SetGroupVersionKind(gvk unversioned.GroupVersionKind) {
+ u.SetAPIVersion(gvk.GroupVersion().String())
+ u.SetKind(gvk.Kind)
+}
+
+func (u *UnstructuredList) GroupVersionKind() unversioned.GroupVersionKind {
+ gv, err := unversioned.ParseGroupVersion(u.GetAPIVersion())
+ if err != nil {
+ return unversioned.GroupVersionKind{}
+ }
+ gvk := gv.WithKind(u.GetKind())
+ return gvk
+}
+
+// VersionedObjects is used by Decoders to give callers a way to access all versions
+// of an object during the decoding process.
+type VersionedObjects struct {
+ // Objects is the set of objects retrieved during decoding, in order of conversion.
+ // The 0 index is the object as serialized on the wire. If conversion has occurred,
+ // other objects may be present. The right most object is the same as would be returned
+ // by a normal Decode call.
+ Objects []Object
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/runtime/types_proto.go b/vendor/k8s.io/kubernetes/pkg/runtime/types_proto.go
new file mode 100644
index 0000000000000000000000000000000000000000..142dd05daaacb996a82943431383c2bd09c746ee
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/types_proto.go
@@ -0,0 +1,69 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 runtime
+
+import (
+ "fmt"
+)
+
+type ProtobufMarshaller interface {
+ MarshalTo(data []byte) (int, error)
+}
+
+// NestedMarshalTo allows a caller to avoid extra allocations during serialization of an Unknown
+// that will contain an object that implements ProtobufMarshaller.
+func (m *Unknown) NestedMarshalTo(data []byte, b ProtobufMarshaller, size uint64) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.TypeMeta.Size()))
+ n1, err := m.TypeMeta.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+
+ if b != nil {
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, size)
+ n2, err := b.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ if uint64(n2) != size {
+ // programmer error: the Size() method for protobuf does not match the results of MarshalTo, which means the proto
+ // struct returned would be wrong.
+ return 0, fmt.Errorf("the Size() value of %T was %d, but NestedMarshalTo wrote %d bytes to data", b, size, n2)
+ }
+ i += n2
+ }
+
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContentEncoding)))
+ i += copy(data[i:], m.ContentEncoding)
+
+ data[i] = 0x22
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.ContentType)))
+ i += copy(data[i:], m.ContentType)
+ return i, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/unstructured.go b/vendor/k8s.io/kubernetes/pkg/runtime/unstructured.go
similarity index 52%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/unstructured.go
rename to vendor/k8s.io/kubernetes/pkg/runtime/unstructured.go
index e4cdef8c9213f25e68006fe96c7e1100e8cd7e53..4a15142c1247ad94e72eba4ea1ba8a4e8b58de81 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/unstructured.go
+++ b/vendor/k8s.io/kubernetes/pkg/runtime/unstructured.go
@@ -17,10 +17,14 @@ limitations under the License.
package runtime
import (
- "encoding/json"
+ gojson "encoding/json"
+ "errors"
+ "fmt"
"io"
+ "strings"
"k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/util/json"
)
// UnstructuredJSONScheme is capable of converting JSON data into the Unstructured
@@ -44,30 +48,27 @@ func (s unstructuredJSONScheme) Decode(data []byte, _ *unversioned.GroupVersionK
gvk := obj.GetObjectKind().GroupVersionKind()
if len(gvk.Kind) == 0 {
- return nil, gvk, NewMissingKindErr(string(data))
+ return nil, &gvk, NewMissingKindErr(string(data))
}
- return obj, gvk, nil
+ return obj, &gvk, nil
}
-func (unstructuredJSONScheme) EncodeToStream(obj Object, w io.Writer, overrides ...unversioned.GroupVersion) error {
+func (unstructuredJSONScheme) Encode(obj Object, w io.Writer) error {
switch t := obj.(type) {
case *Unstructured:
return json.NewEncoder(w).Encode(t.Object)
case *UnstructuredList:
- type encodeList struct {
- TypeMeta `json:",inline"`
- Items []map[string]interface{} `json:"items"`
- }
- eList := encodeList{
- TypeMeta: t.TypeMeta,
- }
+ items := make([]map[string]interface{}, 0, len(t.Items))
for _, i := range t.Items {
- eList.Items = append(eList.Items, i.Object)
+ items = append(items, i.Object)
}
- return json.NewEncoder(w).Encode(eList)
+ t.Object["items"] = items
+ defer func() { delete(t.Object, "items") }()
+ return json.NewEncoder(w).Encode(t.Object)
case *Unknown:
- _, err := w.Write(t.RawJSON)
+ // TODO: Unstructured needs to deal with ContentType.
+ _, err := w.Write(t.Raw)
return err
default:
return json.NewEncoder(w).Encode(t)
@@ -76,7 +77,7 @@ func (unstructuredJSONScheme) EncodeToStream(obj Object, w io.Writer, overrides
func (s unstructuredJSONScheme) decode(data []byte) (Object, error) {
type detector struct {
- Items json.RawMessage
+ Items gojson.RawMessage
}
var det detector
if err := json.Unmarshal(data, &det); err != nil {
@@ -100,6 +101,13 @@ func (s unstructuredJSONScheme) decodeInto(data []byte, obj Object) error {
return s.decodeToUnstructured(data, x)
case *UnstructuredList:
return s.decodeToList(data, x)
+ case *VersionedObjects:
+ u := new(Unstructured)
+ err := s.decodeToUnstructured(data, u)
+ if err == nil {
+ x.Objects = []Object{u}
+ }
+ return err
default:
return json.Unmarshal(data, x)
}
@@ -111,25 +119,6 @@ func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstru
return err
}
- if v, ok := m["kind"]; ok {
- if s, ok := v.(string); ok {
- unstruct.Kind = s
- }
- }
- if v, ok := m["apiVersion"]; ok {
- if s, ok := v.(string); ok {
- unstruct.APIVersion = s
- }
- }
- if metadata, ok := m["metadata"]; ok {
- if metadata, ok := metadata.(map[string]interface{}); ok {
- if name, ok := metadata["name"]; ok {
- if name, ok := name.(string); ok {
- unstruct.Name = name
- }
- }
- }
- }
unstruct.Object = m
return nil
@@ -137,8 +126,7 @@ func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstru
func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList) error {
type decodeList struct {
- TypeMeta `json:",inline"`
- Items []json.RawMessage
+ Items []gojson.RawMessage
}
var dList decodeList
@@ -146,14 +134,66 @@ func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList
return err
}
- list.TypeMeta = dList.TypeMeta
+ if err := json.Unmarshal(data, &list.Object); err != nil {
+ return err
+ }
+
+ // For typed lists, e.g., a PodList, API server doesn't set each item's
+ // APIVersion and Kind. We need to set it.
+ listAPIVersion := list.GetAPIVersion()
+ listKind := list.GetKind()
+ itemKind := strings.TrimSuffix(listKind, "List")
+
+ delete(list.Object, "items")
list.Items = nil
for _, i := range dList.Items {
unstruct := &Unstructured{}
if err := s.decodeToUnstructured([]byte(i), unstruct); err != nil {
return err
}
+ // This is hacky. Set the item's Kind and APIVersion to those inferred
+ // from the List.
+ if len(unstruct.GetKind()) == 0 && len(unstruct.GetAPIVersion()) == 0 {
+ unstruct.SetKind(itemKind)
+ unstruct.SetAPIVersion(listAPIVersion)
+ }
list.Items = append(list.Items, unstruct)
}
return nil
}
+
+// UnstructuredObjectConverter is an ObjectConverter for use with
+// Unstructured objects. Since it has no schema or type information,
+// it will only succeed for no-op conversions. This is provided as a
+// sane implementation for APIs that require an object converter.
+type UnstructuredObjectConverter struct{}
+
+func (UnstructuredObjectConverter) Convert(in, out interface{}) error {
+ unstructIn, ok := in.(*Unstructured)
+ if !ok {
+ return fmt.Errorf("input type %T in not valid for unstructured conversion", in)
+ }
+
+ unstructOut, ok := out.(*Unstructured)
+ if !ok {
+ return fmt.Errorf("output type %T in not valid for unstructured conversion", out)
+ }
+
+ // maybe deep copy the map? It is documented in the
+ // ObjectConverter interface that this function is not
+ // guaranteeed to not mutate the input. Or maybe set the input
+ // object to nil.
+ unstructOut.Object = unstructIn.Object
+ return nil
+}
+
+func (UnstructuredObjectConverter) ConvertToVersion(in Object, outVersion unversioned.GroupVersion) (Object, error) {
+ if gvk := in.GetObjectKind().GroupVersionKind(); gvk.GroupVersion() != outVersion {
+ return nil, errors.New("unstructured converter cannot convert versions")
+ }
+ return in, nil
+}
+
+func (UnstructuredObjectConverter) ConvertFieldLabel(version, kind, label, value string) (string, string, error) {
+ return "", "", errors.New("unstructured cannot convert field labels")
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/security/podsecuritypolicy/util/util.go b/vendor/k8s.io/kubernetes/pkg/security/podsecuritypolicy/util/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..097b1a6c21d9fccf76ff9acaeaa0d4519505d2a2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/security/podsecuritypolicy/util/util.go
@@ -0,0 +1,145 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 util
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ "k8s.io/kubernetes/pkg/util/sets"
+)
+
+const (
+ ValidatedPSPAnnotation = "kubernetes.io/psp"
+)
+
+func GetAllFSTypesExcept(exceptions ...string) sets.String {
+ fstypes := GetAllFSTypesAsSet()
+ for _, e := range exceptions {
+ fstypes.Delete(e)
+ }
+ return fstypes
+}
+
+func GetAllFSTypesAsSet() sets.String {
+ fstypes := sets.NewString()
+ fstypes.Insert(
+ string(extensions.HostPath),
+ string(extensions.AzureFile),
+ string(extensions.Flocker),
+ string(extensions.FlexVolume),
+ string(extensions.EmptyDir),
+ string(extensions.GCEPersistentDisk),
+ string(extensions.AWSElasticBlockStore),
+ string(extensions.GitRepo),
+ string(extensions.Secret),
+ string(extensions.NFS),
+ string(extensions.ISCSI),
+ string(extensions.Glusterfs),
+ string(extensions.PersistentVolumeClaim),
+ string(extensions.RBD),
+ string(extensions.Cinder),
+ string(extensions.CephFS),
+ string(extensions.DownwardAPI),
+ string(extensions.FC),
+ string(extensions.ConfigMap),
+ string(extensions.VsphereVolume))
+ return fstypes
+}
+
+// getVolumeFSType gets the FSType for a volume.
+func GetVolumeFSType(v api.Volume) (extensions.FSType, error) {
+ switch {
+ case v.HostPath != nil:
+ return extensions.HostPath, nil
+ case v.EmptyDir != nil:
+ return extensions.EmptyDir, nil
+ case v.GCEPersistentDisk != nil:
+ return extensions.GCEPersistentDisk, nil
+ case v.AWSElasticBlockStore != nil:
+ return extensions.AWSElasticBlockStore, nil
+ case v.GitRepo != nil:
+ return extensions.GitRepo, nil
+ case v.Secret != nil:
+ return extensions.Secret, nil
+ case v.NFS != nil:
+ return extensions.NFS, nil
+ case v.ISCSI != nil:
+ return extensions.ISCSI, nil
+ case v.Glusterfs != nil:
+ return extensions.Glusterfs, nil
+ case v.PersistentVolumeClaim != nil:
+ return extensions.PersistentVolumeClaim, nil
+ case v.RBD != nil:
+ return extensions.RBD, nil
+ case v.FlexVolume != nil:
+ return extensions.FlexVolume, nil
+ case v.Cinder != nil:
+ return extensions.Cinder, nil
+ case v.CephFS != nil:
+ return extensions.CephFS, nil
+ case v.Flocker != nil:
+ return extensions.Flocker, nil
+ case v.DownwardAPI != nil:
+ return extensions.DownwardAPI, nil
+ case v.FC != nil:
+ return extensions.FC, nil
+ case v.AzureFile != nil:
+ return extensions.AzureFile, nil
+ case v.ConfigMap != nil:
+ return extensions.ConfigMap, nil
+ case v.VsphereVolume != nil:
+ return extensions.VsphereVolume, nil
+ }
+
+ return "", fmt.Errorf("unknown volume type for volume: %#v", v)
+}
+
+// fsTypeToStringSet converts an FSType slice to a string set.
+func FSTypeToStringSet(fsTypes []extensions.FSType) sets.String {
+ set := sets.NewString()
+ for _, v := range fsTypes {
+ set.Insert(string(v))
+ }
+ return set
+}
+
+// PSPAllowsAllVolumes checks for FSTypeAll in the psp's allowed volumes.
+func PSPAllowsAllVolumes(psp *extensions.PodSecurityPolicy) bool {
+ return PSPAllowsFSType(psp, extensions.All)
+}
+
+// PSPAllowsFSType is a utility for checking if a PSP allows a particular FSType.
+// If all volumes are allowed then this will return true for any FSType passed.
+func PSPAllowsFSType(psp *extensions.PodSecurityPolicy, fsType extensions.FSType) bool {
+ if psp == nil {
+ return false
+ }
+
+ for _, v := range psp.Spec.Volumes {
+ if v == fsType || v == extensions.All {
+ return true
+ }
+ }
+ return false
+}
+
+// FallsInRange is a utility to determine it the id falls in the valid range.
+func FallsInRange(id int64, rng extensions.IDRange) bool {
+ return id >= rng.Min && id <= rng.Max
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/OWNERS b/vendor/k8s.io/kubernetes/pkg/storage/OWNERS
new file mode 100644
index 0000000000000000000000000000000000000000..a57ded7f6587de2c067ee2bf2c55afa5559e5955
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/OWNERS
@@ -0,0 +1,6 @@
+assignees:
+ - lavalamp
+ - liggitt
+ - timothysc
+ - wojtek-t
+ - xiang90
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/cacher.go b/vendor/k8s.io/kubernetes/pkg/storage/cacher.go
new file mode 100644
index 0000000000000000000000000000000000000000..e7b4d63e2f05483ad09602d499dadee40dc7a01c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/cacher.go
@@ -0,0 +1,629 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 storage
+
+import (
+ "fmt"
+ "net/http"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/rest"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/client/cache"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+ utilruntime "k8s.io/kubernetes/pkg/util/runtime"
+ "k8s.io/kubernetes/pkg/util/wait"
+ "k8s.io/kubernetes/pkg/watch"
+
+ "github.com/golang/glog"
+ "golang.org/x/net/context"
+)
+
+// CacherConfig contains the configuration for a given Cache.
+type CacherConfig struct {
+ // Maximum size of the history cached in memory.
+ CacheCapacity int
+
+ // An underlying storage.Interface.
+ Storage Interface
+
+ // An underlying storage.Versioner.
+ Versioner Versioner
+
+ // The Cache will be caching objects of a given Type and assumes that they
+ // are all stored under ResourcePrefix directory in the underlying database.
+ Type interface{}
+ ResourcePrefix string
+
+ // KeyFunc is used to get a key in the underyling storage for a given object.
+ KeyFunc func(runtime.Object) (string, error)
+
+ // NewList is a function that creates new empty object storing a list of
+ // objects of type Type.
+ NewListFunc func() runtime.Object
+}
+
+// Cacher is responsible for serving WATCH and LIST requests for a given
+// resource from its internal cache and updating its cache in the background
+// based on the underlying storage contents.
+// Cacher implements storage.Interface (although most of the calls are just
+// delegated to the underlying storage).
+type Cacher struct {
+ sync.RWMutex
+
+ // Each user-facing method that is not simply redirected to the underlying
+ // storage has to read-lock on this mutex before starting any processing.
+ // This is necessary to prevent users from accessing structures that are
+ // uninitialized or are being repopulated right now.
+ // NOTE: We cannot easily reuse the main mutex for it due to multi-threaded
+ // interactions of Cacher with the underlying WatchCache. Since Cacher is
+ // caling WatchCache directly and WatchCache is calling Cacher methods
+ // via its OnEvent and OnReplace hooks, we explicitly assume that if mutexes
+ // of both structures are held, the one from WatchCache is acquired first
+ // to avoid deadlocks. Unfortunately, forcing this rule in startCaching
+ // would be very difficult and introducing one more mutex seems to be much
+ // easier.
+ usable sync.RWMutex
+
+ // Underlying storage.Interface.
+ storage Interface
+
+ // "sliding window" of recent changes of objects and the current state.
+ watchCache *watchCache
+ reflector *cache.Reflector
+
+ // Registered watchers.
+ watcherIdx int
+ watchers map[int]*cacheWatcher
+
+ // Versioner is used to handle resource versions.
+ versioner Versioner
+
+ // keyFunc is used to get a key in the underyling storage for a given object.
+ keyFunc func(runtime.Object) (string, error)
+
+ // Handling graceful termination.
+ stopLock sync.RWMutex
+ stopped bool
+ stopCh chan struct{}
+ stopWg sync.WaitGroup
+}
+
+// Create a new Cacher responsible from service WATCH and LIST requests from its
+// internal cache and updating its cache in the background based on the given
+// configuration.
+func NewCacher(
+ storage Interface,
+ capacity int,
+ versioner Versioner,
+ objectType runtime.Object,
+ resourcePrefix string,
+ scopeStrategy rest.NamespaceScopedStrategy,
+ newListFunc func() runtime.Object) Interface {
+ config := CacherConfig{
+ CacheCapacity: capacity,
+ Storage: storage,
+ Versioner: versioner,
+ Type: objectType,
+ ResourcePrefix: resourcePrefix,
+ NewListFunc: newListFunc,
+ }
+ if scopeStrategy.NamespaceScoped() {
+ config.KeyFunc = func(obj runtime.Object) (string, error) {
+ return NamespaceKeyFunc(resourcePrefix, obj)
+ }
+ } else {
+ config.KeyFunc = func(obj runtime.Object) (string, error) {
+ return NoNamespaceKeyFunc(resourcePrefix, obj)
+ }
+ }
+ return NewCacherFromConfig(config)
+}
+
+// Create a new Cacher responsible from service WATCH and LIST requests from its
+// internal cache and updating its cache in the background based on the given
+// configuration.
+func NewCacherFromConfig(config CacherConfig) *Cacher {
+ watchCache := newWatchCache(config.CacheCapacity)
+ listerWatcher := newCacherListerWatcher(config.Storage, config.ResourcePrefix, config.NewListFunc)
+
+ // Give this error when it is constructed rather than when you get the
+ // first watch item, because it's much easier to track down that way.
+ if obj, ok := config.Type.(runtime.Object); ok {
+ if err := runtime.CheckCodec(config.Storage.Codec(), obj); err != nil {
+ panic("storage codec doesn't seem to match given type: " + err.Error())
+ }
+ }
+
+ cacher := &Cacher{
+ usable: sync.RWMutex{},
+ storage: config.Storage,
+ watchCache: watchCache,
+ reflector: cache.NewReflector(listerWatcher, config.Type, watchCache, 0),
+ watcherIdx: 0,
+ watchers: make(map[int]*cacheWatcher),
+ versioner: config.Versioner,
+ keyFunc: config.KeyFunc,
+ stopped: false,
+ // We need to (potentially) stop both:
+ // - wait.Until go-routine
+ // - reflector.ListAndWatch
+ // and there are no guarantees on the order that they will stop.
+ // So we will be simply closing the channel, and synchronizing on the WaitGroup.
+ stopCh: make(chan struct{}),
+ stopWg: sync.WaitGroup{},
+ }
+ // See startCaching method for explanation and where this is unlocked.
+ cacher.usable.Lock()
+ watchCache.SetOnEvent(cacher.processEvent)
+
+ stopCh := cacher.stopCh
+ cacher.stopWg.Add(1)
+ go func() {
+ defer cacher.stopWg.Done()
+ wait.Until(
+ func() {
+ if !cacher.isStopped() {
+ cacher.startCaching(stopCh)
+ }
+ }, time.Second, stopCh,
+ )
+ }()
+ return cacher
+}
+
+func (c *Cacher) startCaching(stopChannel <-chan struct{}) {
+ // The 'usable' lock is always 'RLock'able when it is safe to use the cache.
+ // It is safe to use the cache after a successful list until a disconnection.
+ // We start with usable (write) locked. The below OnReplace function will
+ // unlock it after a successful list. The below defer will then re-lock
+ // it when this function exits (always due to disconnection), only if
+ // we actually got a successful list. This cycle will repeat as needed.
+ successfulList := false
+ c.watchCache.SetOnReplace(func() {
+ successfulList = true
+ c.usable.Unlock()
+ })
+ defer func() {
+ if successfulList {
+ c.usable.Lock()
+ }
+ }()
+
+ c.terminateAllWatchers()
+ // Note that since onReplace may be not called due to errors, we explicitly
+ // need to retry it on errors under lock.
+ // Also note that startCaching is called in a loop, so there's no need
+ // to have another loop here.
+ if err := c.reflector.ListAndWatch(stopChannel); err != nil {
+ glog.Errorf("unexpected ListAndWatch error: %v", err)
+ }
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Backends(ctx context.Context) []string {
+ return c.storage.Backends(ctx)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Versioner() Versioner {
+ return c.storage.Versioner()
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Create(ctx context.Context, key string, obj, out runtime.Object, ttl uint64) error {
+ return c.storage.Create(ctx, key, obj, out, ttl)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Delete(ctx context.Context, key string, out runtime.Object, preconditions *Preconditions) error {
+ return c.storage.Delete(ctx, key, out, preconditions)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Watch(ctx context.Context, key string, resourceVersion string, filter FilterFunc) (watch.Interface, error) {
+ watchRV, err := ParseWatchResourceVersion(resourceVersion)
+ if err != nil {
+ return nil, err
+ }
+
+ // Do NOT allow Watch to start when the underlying structures are not propagated.
+ c.usable.RLock()
+ defer c.usable.RUnlock()
+
+ // We explicitly use thread unsafe version and do locking ourself to ensure that
+ // no new events will be processed in the meantime. The watchCache will be unlocked
+ // on return from this function.
+ // Note that we cannot do it under Cacher lock, to avoid a deadlock, since the
+ // underlying watchCache is calling processEvent under its lock.
+ c.watchCache.RLock()
+ defer c.watchCache.RUnlock()
+ initEvents, err := c.watchCache.GetAllEventsSinceThreadUnsafe(watchRV)
+ if err != nil {
+ // To match the uncached watch implementation, once we have passed authn/authz/admission,
+ // and successfully parsed a resource version, other errors must fail with a watch event of type ERROR,
+ // rather than a directly returned error.
+ return newErrWatcher(err), nil
+ }
+
+ c.Lock()
+ defer c.Unlock()
+ watcher := newCacheWatcher(watchRV, initEvents, filterFunction(key, c.keyFunc, filter), forgetWatcher(c, c.watcherIdx))
+ c.watchers[c.watcherIdx] = watcher
+ c.watcherIdx++
+ return watcher, nil
+}
+
+// Implements storage.Interface.
+func (c *Cacher) WatchList(ctx context.Context, key string, resourceVersion string, filter FilterFunc) (watch.Interface, error) {
+ return c.Watch(ctx, key, resourceVersion, filter)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Get(ctx context.Context, key string, objPtr runtime.Object, ignoreNotFound bool) error {
+ return c.storage.Get(ctx, key, objPtr, ignoreNotFound)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) GetToList(ctx context.Context, key string, filter FilterFunc, listObj runtime.Object) error {
+ return c.storage.GetToList(ctx, key, filter, listObj)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) List(ctx context.Context, key string, resourceVersion string, filter FilterFunc, listObj runtime.Object) error {
+ if resourceVersion == "" {
+ // If resourceVersion is not specified, serve it from underlying
+ // storage (for backward compatibility).
+ return c.storage.List(ctx, key, resourceVersion, filter, listObj)
+ }
+
+ // If resourceVersion is specified, serve it from cache.
+ // It's guaranteed that the returned value is at least that
+ // fresh as the given resourceVersion.
+
+ listRV, err := ParseListResourceVersion(resourceVersion)
+ if err != nil {
+ return err
+ }
+
+ // To avoid situation when List is processed before the underlying
+ // watchCache is propagated for the first time, we acquire and immediately
+ // release the 'usable' lock.
+ // We don't need to hold it all the time, because watchCache is thread-safe
+ // and it would complicate already very difficult locking pattern.
+ c.usable.RLock()
+ c.usable.RUnlock()
+
+ // List elements from cache, with at least 'listRV'.
+ listPtr, err := meta.GetItemsPtr(listObj)
+ if err != nil {
+ return err
+ }
+ listVal, err := conversion.EnforcePtr(listPtr)
+ if err != nil || listVal.Kind() != reflect.Slice {
+ return fmt.Errorf("need a pointer to slice, got %v", listVal.Kind())
+ }
+ filterFunc := filterFunction(key, c.keyFunc, filter)
+
+ objs, readResourceVersion, err := c.watchCache.WaitUntilFreshAndList(listRV)
+ if err != nil {
+ return fmt.Errorf("failed to wait for fresh list: %v", err)
+ }
+ for _, obj := range objs {
+ object, ok := obj.(runtime.Object)
+ if !ok {
+ return fmt.Errorf("non runtime.Object returned from storage: %v", obj)
+ }
+ if filterFunc(object) {
+ listVal.Set(reflect.Append(listVal, reflect.ValueOf(object).Elem()))
+ }
+ }
+ if c.versioner != nil {
+ if err := c.versioner.UpdateList(listObj, readResourceVersion); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Implements storage.Interface.
+func (c *Cacher) GuaranteedUpdate(ctx context.Context, key string, ptrToType runtime.Object, ignoreNotFound bool, preconditions *Preconditions, tryUpdate UpdateFunc) error {
+ return c.storage.GuaranteedUpdate(ctx, key, ptrToType, ignoreNotFound, preconditions, tryUpdate)
+}
+
+// Implements storage.Interface.
+func (c *Cacher) Codec() runtime.Codec {
+ return c.storage.Codec()
+}
+
+func (c *Cacher) processEvent(event watchCacheEvent) {
+ c.Lock()
+ defer c.Unlock()
+ for _, watcher := range c.watchers {
+ watcher.add(event)
+ }
+}
+
+func (c *Cacher) terminateAllWatchers() {
+ c.Lock()
+ defer c.Unlock()
+ for key, watcher := range c.watchers {
+ delete(c.watchers, key)
+ watcher.stop()
+ }
+}
+
+func (c *Cacher) isStopped() bool {
+ c.stopLock.RLock()
+ defer c.stopLock.RUnlock()
+ return c.stopped
+}
+
+func (c *Cacher) Stop() {
+ c.stopLock.Lock()
+ c.stopped = true
+ c.stopLock.Unlock()
+ close(c.stopCh)
+ c.stopWg.Wait()
+}
+
+func forgetWatcher(c *Cacher, index int) func(bool) {
+ return func(lock bool) {
+ if lock {
+ c.Lock()
+ defer c.Unlock()
+ }
+ // It's possible that the watcher is already not in the map (e.g. in case of
+ // simulaneous Stop() and terminateAllWatchers(), but it doesn't break anything.
+ delete(c.watchers, index)
+ }
+}
+
+func filterFunction(key string, keyFunc func(runtime.Object) (string, error), filter FilterFunc) FilterFunc {
+ return func(obj runtime.Object) bool {
+ objKey, err := keyFunc(obj)
+ if err != nil {
+ glog.Errorf("invalid object for filter: %v", obj)
+ return false
+ }
+ if !strings.HasPrefix(objKey, key) {
+ return false
+ }
+ return filter(obj)
+ }
+}
+
+// Returns resource version to which the underlying cache is synced.
+func (c *Cacher) LastSyncResourceVersion() (uint64, error) {
+ // To avoid situation when LastSyncResourceVersion is processed before the
+ // underlying watchCache is propagated, we acquire 'usable' lock.
+ c.usable.RLock()
+ defer c.usable.RUnlock()
+
+ c.RLock()
+ defer c.RUnlock()
+
+ resourceVersion := c.reflector.LastSyncResourceVersion()
+ if resourceVersion == "" {
+ return 0, nil
+ }
+ return strconv.ParseUint(resourceVersion, 10, 64)
+}
+
+// cacherListerWatcher opaques storage.Interface to expose cache.ListerWatcher.
+type cacherListerWatcher struct {
+ storage Interface
+ resourcePrefix string
+ newListFunc func() runtime.Object
+}
+
+func newCacherListerWatcher(storage Interface, resourcePrefix string, newListFunc func() runtime.Object) cache.ListerWatcher {
+ return &cacherListerWatcher{
+ storage: storage,
+ resourcePrefix: resourcePrefix,
+ newListFunc: newListFunc,
+ }
+}
+
+// Implements cache.ListerWatcher interface.
+func (lw *cacherListerWatcher) List(options api.ListOptions) (runtime.Object, error) {
+ list := lw.newListFunc()
+ if err := lw.storage.List(context.TODO(), lw.resourcePrefix, "", Everything, list); err != nil {
+ return nil, err
+ }
+ return list, nil
+}
+
+// Implements cache.ListerWatcher interface.
+func (lw *cacherListerWatcher) Watch(options api.ListOptions) (watch.Interface, error) {
+ return lw.storage.WatchList(context.TODO(), lw.resourcePrefix, options.ResourceVersion, Everything)
+}
+
+// cacherWatch implements watch.Interface to return a single error
+type errWatcher struct {
+ result chan watch.Event
+}
+
+func newErrWatcher(err error) *errWatcher {
+ // Create an error event
+ errEvent := watch.Event{Type: watch.Error}
+ switch err := err.(type) {
+ case runtime.Object:
+ errEvent.Object = err
+ case *errors.StatusError:
+ errEvent.Object = &err.ErrStatus
+ default:
+ errEvent.Object = &unversioned.Status{
+ Status: unversioned.StatusFailure,
+ Message: err.Error(),
+ Reason: unversioned.StatusReasonInternalError,
+ Code: http.StatusInternalServerError,
+ }
+ }
+
+ // Create a watcher with room for a single event, populate it, and close the channel
+ watcher := &errWatcher{result: make(chan watch.Event, 1)}
+ watcher.result <- errEvent
+ close(watcher.result)
+
+ return watcher
+}
+
+// Implements watch.Interface.
+func (c *errWatcher) ResultChan() <-chan watch.Event {
+ return c.result
+}
+
+// Implements watch.Interface.
+func (c *errWatcher) Stop() {
+ // no-op
+}
+
+// cacherWatch implements watch.Interface
+type cacheWatcher struct {
+ sync.Mutex
+ input chan watchCacheEvent
+ result chan watch.Event
+ filter FilterFunc
+ stopped bool
+ forget func(bool)
+}
+
+func newCacheWatcher(resourceVersion uint64, initEvents []watchCacheEvent, filter FilterFunc, forget func(bool)) *cacheWatcher {
+ watcher := &cacheWatcher{
+ input: make(chan watchCacheEvent, 10),
+ result: make(chan watch.Event, 10),
+ filter: filter,
+ stopped: false,
+ forget: forget,
+ }
+ go watcher.process(initEvents, resourceVersion)
+ return watcher
+}
+
+// Implements watch.Interface.
+func (c *cacheWatcher) ResultChan() <-chan watch.Event {
+ return c.result
+}
+
+// Implements watch.Interface.
+func (c *cacheWatcher) Stop() {
+ c.forget(true)
+ c.stop()
+}
+
+func (c *cacheWatcher) stop() {
+ c.Lock()
+ defer c.Unlock()
+ if !c.stopped {
+ c.stopped = true
+ close(c.input)
+ }
+}
+
+var timerPool sync.Pool
+
+func (c *cacheWatcher) add(event watchCacheEvent) {
+ // Try to send the event immediately, without blocking.
+ select {
+ case c.input <- event:
+ return
+ default:
+ }
+
+ // OK, block sending, but only for up to 5 seconds.
+ // cacheWatcher.add is called very often, so arrange
+ // to reuse timers instead of constantly allocating.
+ const timeout = 5 * time.Second
+ t, ok := timerPool.Get().(*time.Timer)
+ if ok {
+ t.Reset(timeout)
+ } else {
+ t = time.NewTimer(timeout)
+ }
+ defer timerPool.Put(t)
+
+ select {
+ case c.input <- event:
+ stopped := t.Stop()
+ if !stopped {
+ // Consume triggered (but not yet received) timer event
+ // so that future reuse does not get a spurious timeout.
+ <-t.C
+ }
+ case <-t.C:
+ // This means that we couldn't send event to that watcher.
+ // Since we don't want to block on it infinitely,
+ // we simply terminate it.
+ c.forget(false)
+ c.stop()
+ }
+}
+
+func (c *cacheWatcher) sendWatchCacheEvent(event watchCacheEvent) {
+ curObjPasses := event.Type != watch.Deleted && c.filter(event.Object)
+ oldObjPasses := false
+ if event.PrevObject != nil {
+ oldObjPasses = c.filter(event.PrevObject)
+ }
+ if !curObjPasses && !oldObjPasses {
+ // Watcher is not interested in that object.
+ return
+ }
+
+ object, err := api.Scheme.Copy(event.Object)
+ if err != nil {
+ glog.Errorf("unexpected copy error: %v", err)
+ return
+ }
+ switch {
+ case curObjPasses && !oldObjPasses:
+ c.result <- watch.Event{Type: watch.Added, Object: object}
+ case curObjPasses && oldObjPasses:
+ c.result <- watch.Event{Type: watch.Modified, Object: object}
+ case !curObjPasses && oldObjPasses:
+ c.result <- watch.Event{Type: watch.Deleted, Object: object}
+ }
+}
+
+func (c *cacheWatcher) process(initEvents []watchCacheEvent, resourceVersion uint64) {
+ defer utilruntime.HandleCrash()
+
+ for _, event := range initEvents {
+ c.sendWatchCacheEvent(event)
+ }
+ defer close(c.result)
+ defer c.Stop()
+ for {
+ event, ok := <-c.input
+ if !ok {
+ return
+ }
+ // only send events newer than resourceVersion
+ if event.ResourceVersion > resourceVersion {
+ c.sendWatchCacheEvent(event)
+ }
+ }
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/doc.go b/vendor/k8s.io/kubernetes/pkg/storage/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..dca0d5b7096569277baf5e9fd73ca475abff6085
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/doc.go
@@ -0,0 +1,18 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// Interfaces for database-related operations.
+package storage
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/errors.go b/vendor/k8s.io/kubernetes/pkg/storage/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..61b3cba52c750dff3df3c1cc9912c247dbe07029
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/errors.go
@@ -0,0 +1,174 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 storage
+
+import (
+ "fmt"
+
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+const (
+ ErrCodeKeyNotFound int = iota + 1
+ ErrCodeKeyExists
+ ErrCodeResourceVersionConflicts
+ ErrCodeInvalidObj
+ ErrCodeUnreachable
+)
+
+var errCodeToMessage = map[int]string{
+ ErrCodeKeyNotFound: "key not found",
+ ErrCodeKeyExists: "key exists",
+ ErrCodeResourceVersionConflicts: "resource version conflicts",
+ ErrCodeInvalidObj: "invalid object",
+ ErrCodeUnreachable: "server unreachable",
+}
+
+func NewKeyNotFoundError(key string, rv int64) *StorageError {
+ return &StorageError{
+ Code: ErrCodeKeyNotFound,
+ Key: key,
+ ResourceVersion: rv,
+ }
+}
+
+func NewKeyExistsError(key string, rv int64) *StorageError {
+ return &StorageError{
+ Code: ErrCodeKeyExists,
+ Key: key,
+ ResourceVersion: rv,
+ }
+}
+
+func NewResourceVersionConflictsError(key string, rv int64) *StorageError {
+ return &StorageError{
+ Code: ErrCodeResourceVersionConflicts,
+ Key: key,
+ ResourceVersion: rv,
+ }
+}
+
+func NewUnreachableError(key string, rv int64) *StorageError {
+ return &StorageError{
+ Code: ErrCodeUnreachable,
+ Key: key,
+ ResourceVersion: rv,
+ }
+}
+
+func NewInvalidObjError(key, msg string) *StorageError {
+ return &StorageError{
+ Code: ErrCodeInvalidObj,
+ Key: key,
+ AdditionalErrorMsg: msg,
+ }
+}
+
+type StorageError struct {
+ Code int
+ Key string
+ ResourceVersion int64
+ AdditionalErrorMsg string
+}
+
+func (e *StorageError) Error() string {
+ return fmt.Sprintf("StorageError: %s, Code: %d, Key: %s, ResourceVersion: %d, AdditionalErrorMsg: %s",
+ errCodeToMessage[e.Code], e.Code, e.Key, e.ResourceVersion, e.AdditionalErrorMsg)
+}
+
+// IsNotFound returns true if and only if err is "key" not found error.
+func IsNotFound(err error) bool {
+ return isErrCode(err, ErrCodeKeyNotFound)
+}
+
+// IsNodeExist returns true if and only if err is an node already exist error.
+func IsNodeExist(err error) bool {
+ return isErrCode(err, ErrCodeKeyExists)
+}
+
+// IsUnreachable returns true if and only if err indicates the server could not be reached.
+func IsUnreachable(err error) bool {
+ return isErrCode(err, ErrCodeUnreachable)
+}
+
+// IsTestFailed returns true if and only if err is a write conflict.
+func IsTestFailed(err error) bool {
+ return isErrCode(err, ErrCodeResourceVersionConflicts, ErrCodeInvalidObj)
+}
+
+// IsInvalidUID returns true if and only if err is invalid UID error
+func IsInvalidObj(err error) bool {
+ return isErrCode(err, ErrCodeInvalidObj)
+}
+
+func isErrCode(err error, codes ...int) bool {
+ if err == nil {
+ return false
+ }
+ if e, ok := err.(*StorageError); ok {
+ for _, code := range codes {
+ if e.Code == code {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// InvalidError is generated when an error caused by invalid API object occurs
+// in the storage package.
+type InvalidError struct {
+ Errs field.ErrorList
+}
+
+func (e InvalidError) Error() string {
+ return e.Errs.ToAggregate().Error()
+}
+
+// IsInvalidError returns true if and only if err is an InvalidError.
+func IsInvalidError(err error) bool {
+ _, ok := err.(InvalidError)
+ return ok
+}
+
+func NewInvalidError(errors field.ErrorList) InvalidError {
+ return InvalidError{errors}
+}
+
+// InternalError is generated when an error occurs in the storage package, i.e.,
+// not from the underlying storage backend (e.g., etcd).
+type InternalError struct {
+ Reason string
+}
+
+func (e InternalError) Error() string {
+ return e.Reason
+}
+
+// IsInternalError returns true if and only if err is an InternalError.
+func IsInternalError(err error) bool {
+ _, ok := err.(InternalError)
+ return ok
+}
+
+func NewInternalError(reason string) InternalError {
+ return InternalError{reason}
+}
+
+func NewInternalErrorf(format string, a ...interface{}) InternalError {
+ return InternalError{fmt.Sprintf(format, a)}
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/interfaces.go b/vendor/k8s.io/kubernetes/pkg/storage/interfaces.go
new file mode 100644
index 0000000000000000000000000000000000000000..89290e29abe5656afcd927572aaa7b0653e44c80
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/interfaces.go
@@ -0,0 +1,171 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 storage
+
+import (
+ "golang.org/x/net/context"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/types"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// Versioner abstracts setting and retrieving metadata fields from database response
+// onto the object ot list.
+type Versioner interface {
+ // UpdateObject sets storage metadata into an API object. Returns an error if the object
+ // cannot be updated correctly. May return nil if the requested object does not need metadata
+ // from database.
+ UpdateObject(obj runtime.Object, resourceVersion uint64) error
+ // UpdateList sets the resource version into an API list object. Returns an error if the object
+ // cannot be updated correctly. May return nil if the requested object does not need metadata
+ // from database.
+ UpdateList(obj runtime.Object, resourceVersion uint64) error
+ // ObjectResourceVersion returns the resource version (for persistence) of the specified object.
+ // Should return an error if the specified object does not have a persistable version.
+ ObjectResourceVersion(obj runtime.Object) (uint64, error)
+}
+
+// ResponseMeta contains information about the database metadata that is associated with
+// an object. It abstracts the actual underlying objects to prevent coupling with concrete
+// database and to improve testability.
+type ResponseMeta struct {
+ // TTL is the time to live of the node that contained the returned object. It may be
+ // zero or negative in some cases (objects may be expired after the requested
+ // expiration time due to server lag).
+ TTL int64
+ // The resource version of the node that contained the returned object.
+ ResourceVersion uint64
+}
+
+// FilterFunc is a predicate which takes an API object and returns true
+// if and only if the object should remain in the set.
+type FilterFunc func(obj runtime.Object) bool
+
+// Everything is a FilterFunc which accepts all objects.
+func Everything(runtime.Object) bool {
+ return true
+}
+
+// Pass an UpdateFunc to Interface.GuaranteedUpdate to make an update
+// that is guaranteed to succeed.
+// See the comment for GuaranteedUpdate for more details.
+type UpdateFunc func(input runtime.Object, res ResponseMeta) (output runtime.Object, ttl *uint64, err error)
+
+// Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
+type Preconditions struct {
+ // Specifies the target UID.
+ UID *types.UID `json:"uid,omitempty"`
+}
+
+// NewUIDPreconditions returns a Preconditions with UID set.
+func NewUIDPreconditions(uid string) *Preconditions {
+ u := types.UID(uid)
+ return &Preconditions{UID: &u}
+}
+
+// Interface offers a common interface for object marshaling/unmarshling operations and
+// hides all the storage-related operations behind it.
+type Interface interface {
+ // Returns list of servers addresses of the underyling database.
+ // TODO: This method is used only in a single place. Consider refactoring and getting rid
+ // of this method from the interface.
+ Backends(ctx context.Context) []string
+
+ // Returns Versioner associated with this interface.
+ Versioner() Versioner
+
+ // Create adds a new object at a key unless it already exists. 'ttl' is time-to-live
+ // in seconds (0 means forever). If no error is returned and out is not nil, out will be
+ // set to the read value from database.
+ Create(ctx context.Context, key string, obj, out runtime.Object, ttl uint64) error
+
+ // Delete removes the specified key and returns the value that existed at that spot.
+ // If key didn't exist, it will return NotFound storage error.
+ Delete(ctx context.Context, key string, out runtime.Object, preconditions *Preconditions) error
+
+ // Watch begins watching the specified key. Events are decoded into API objects,
+ // and any items passing 'filter' are sent down to returned watch.Interface.
+ // resourceVersion may be used to specify what version to begin watching,
+ // which should be the current resourceVersion, and no longer rv+1
+ // (e.g. reconnecting without missing any updates).
+ Watch(ctx context.Context, key string, resourceVersion string, filter FilterFunc) (watch.Interface, error)
+
+ // WatchList begins watching the specified key's items. Items are decoded into API
+ // objects and any item passing 'filter' are sent down to returned watch.Interface.
+ // resourceVersion may be used to specify what version to begin watching,
+ // which should be the current resourceVersion, and no longer rv+1
+ // (e.g. reconnecting without missing any updates).
+ WatchList(ctx context.Context, key string, resourceVersion string, filter FilterFunc) (watch.Interface, error)
+
+ // Get unmarshals json found at key into objPtr. On a not found error, will either
+ // return a zero object of the requested type, or an error, depending on ignoreNotFound.
+ // Treats empty responses and nil response nodes exactly like a not found error.
+ Get(ctx context.Context, key string, objPtr runtime.Object, ignoreNotFound bool) error
+
+ // GetToList unmarshals json found at key and opaque it into *List api object
+ // (an object that satisfies the runtime.IsList definition).
+ GetToList(ctx context.Context, key string, filter FilterFunc, listObj runtime.Object) error
+
+ // List unmarshalls jsons found at directory defined by key and opaque them
+ // into *List api object (an object that satisfies runtime.IsList definition).
+ // The returned contents may be delayed, but it is guaranteed that they will
+ // be have at least 'resourceVersion'.
+ List(ctx context.Context, key string, resourceVersion string, filter FilterFunc, listObj runtime.Object) error
+
+ // GuaranteedUpdate keeps calling 'tryUpdate()' to update key 'key' (of type 'ptrToType')
+ // retrying the update until success if there is index conflict.
+ // Note that object passed to tryUpdate may change across invocations of tryUpdate() if
+ // other writers are simultaneously updating it, so tryUpdate() needs to take into account
+ // the current contents of the object when deciding how the update object should look.
+ // If the key doesn't exist, it will return NotFound storage error if ignoreNotFound=false
+ // or zero value in 'ptrToType' parameter otherwise.
+ // If the object to update has the same value as previous, it won't do any update
+ // but will return the object in 'ptrToType' parameter.
+ //
+ // Example:
+ //
+ // s := /* implementation of Interface */
+ // err := s.GuaranteedUpdate(
+ // "myKey", &MyType{}, true,
+ // func(input runtime.Object, res ResponseMeta) (runtime.Object, *uint64, error) {
+ // // Before each incovation of the user defined function, "input" is reset to
+ // // current contents for "myKey" in database.
+ // curr := input.(*MyType) // Guaranteed to succeed.
+ //
+ // // Make the modification
+ // curr.Counter++
+ //
+ // // Return the modified object - return an error to stop iterating. Return
+ // // a uint64 to alter the TTL on the object, or nil to keep it the same value.
+ // return cur, nil, nil
+ // }
+ // })
+ GuaranteedUpdate(ctx context.Context, key string, ptrToType runtime.Object, ignoreNotFound bool, precondtions *Preconditions, tryUpdate UpdateFunc) error
+
+ // Codec provides access to the underlying codec being used by the implementation.
+ Codec() runtime.Codec
+}
+
+// Config interface allows storage tiers to generate the proper storage.interface
+// and reduce the dependencies to encapsulate storage.
+type Config interface {
+ // Creates the Interface base on ConfigObject
+ NewStorage() (Interface, error)
+
+ // This function is used to enforce membership, and return the underlying type
+ GetType() string
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/util.go b/vendor/k8s.io/kubernetes/pkg/storage/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..6595a6763828f50a67ccc52e22369f56b0ed5bd0
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/util.go
@@ -0,0 +1,90 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 storage
+
+import (
+ "fmt"
+ "strconv"
+
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/api/validation"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+type SimpleUpdateFunc func(runtime.Object) (runtime.Object, error)
+
+// SimpleUpdateFunc converts SimpleUpdateFunc into UpdateFunc
+func SimpleUpdate(fn SimpleUpdateFunc) UpdateFunc {
+ return func(input runtime.Object, _ ResponseMeta) (runtime.Object, *uint64, error) {
+ out, err := fn(input)
+ return out, nil, err
+ }
+}
+
+// ParseWatchResourceVersion takes a resource version argument and converts it to
+// the etcd version we should pass to helper.Watch(). Because resourceVersion is
+// an opaque value, the default watch behavior for non-zero watch is to watch
+// the next value (if you pass "1", you will see updates from "2" onwards).
+func ParseWatchResourceVersion(resourceVersion string) (uint64, error) {
+ if resourceVersion == "" || resourceVersion == "0" {
+ return 0, nil
+ }
+ version, err := strconv.ParseUint(resourceVersion, 10, 64)
+ if err != nil {
+ return 0, NewInvalidError(field.ErrorList{
+ // Validation errors are supposed to return version-specific field
+ // paths, but this is probably close enough.
+ field.Invalid(field.NewPath("resourceVersion"), resourceVersion, err.Error()),
+ })
+ }
+ return version, nil
+}
+
+// ParseListResourceVersion takes a resource version argument and converts it to
+// the etcd version.
+func ParseListResourceVersion(resourceVersion string) (uint64, error) {
+ if resourceVersion == "" {
+ return 0, nil
+ }
+ version, err := strconv.ParseUint(resourceVersion, 10, 64)
+ return version, err
+}
+
+func NamespaceKeyFunc(prefix string, obj runtime.Object) (string, error) {
+ meta, err := meta.Accessor(obj)
+ if err != nil {
+ return "", err
+ }
+ name := meta.GetName()
+ if msgs := validation.IsValidPathSegmentName(name); len(msgs) != 0 {
+ return "", fmt.Errorf("invalid name: %v", msgs)
+ }
+ return prefix + "/" + meta.GetNamespace() + "/" + name, nil
+}
+
+func NoNamespaceKeyFunc(prefix string, obj runtime.Object) (string, error) {
+ meta, err := meta.Accessor(obj)
+ if err != nil {
+ return "", err
+ }
+ name := meta.GetName()
+ if msgs := validation.IsValidPathSegmentName(name); len(msgs) != 0 {
+ return "", fmt.Errorf("invalid name: %v", msgs)
+ }
+ return prefix + "/" + name, nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/storage/watch_cache.go b/vendor/k8s.io/kubernetes/pkg/storage/watch_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..3e5ce5d73003f00c2558fe268e9a4ee531809a9c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/storage/watch_cache.go
@@ -0,0 +1,331 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 storage
+
+import (
+ "fmt"
+ "sort"
+ "strconv"
+ "sync"
+ "time"
+
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/meta"
+ "k8s.io/kubernetes/pkg/client/cache"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/util"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+const (
+ // MaximumListWait determines how long we're willing to wait for a
+ // list if a client specified a resource version in the future.
+ MaximumListWait = 60 * time.Second
+)
+
+// watchCacheEvent is a single "watch event" that is send to users of
+// watchCache. Additionally to a typical "watch.Event" it contains
+// the previous value of the object to enable proper filtering in the
+// upper layers.
+type watchCacheEvent struct {
+ Type watch.EventType
+ Object runtime.Object
+ PrevObject runtime.Object
+ ResourceVersion uint64
+}
+
+// watchCacheElement is a single "watch event" stored in a cache.
+// It contains the resource version of the object and the object
+// itself.
+type watchCacheElement struct {
+ resourceVersion uint64
+ watchCacheEvent watchCacheEvent
+}
+
+// watchCache implements a Store interface.
+// However, it depends on the elements implementing runtime.Object interface.
+//
+// watchCache is a "sliding window" (with a limited capacity) of objects
+// observed from a watch.
+type watchCache struct {
+ sync.RWMutex
+
+ // Condition on which lists are waiting for the fresh enough
+ // resource version.
+ cond *sync.Cond
+
+ // Maximum size of history window.
+ capacity int
+
+ // cache is used a cyclic buffer - its first element (with the smallest
+ // resourceVersion) is defined by startIndex, its last element is defined
+ // by endIndex (if cache is full it will be startIndex + capacity).
+ // Both startIndex and endIndex can be greater than buffer capacity -
+ // you should always apply modulo capacity to get an index in cache array.
+ cache []watchCacheElement
+ startIndex int
+ endIndex int
+
+ // store will effectively support LIST operation from the "end of cache
+ // history" i.e. from the moment just after the newest cached watched event.
+ // It is necessary to effectively allow clients to start watching at now.
+ store cache.Store
+
+ // ResourceVersion up to which the watchCache is propagated.
+ resourceVersion uint64
+
+ // This handler is run at the end of every successful Replace() method.
+ onReplace func()
+
+ // This handler is run at the end of every Add/Update/Delete method
+ // and additionally gets the previous value of the object.
+ onEvent func(watchCacheEvent)
+
+ // for testing timeouts.
+ clock util.Clock
+}
+
+func newWatchCache(capacity int) *watchCache {
+ wc := &watchCache{
+ capacity: capacity,
+ cache: make([]watchCacheElement, capacity),
+ startIndex: 0,
+ endIndex: 0,
+ store: cache.NewStore(cache.MetaNamespaceKeyFunc),
+ resourceVersion: 0,
+ clock: util.RealClock{},
+ }
+ wc.cond = sync.NewCond(wc.RLocker())
+ return wc
+}
+
+func (w *watchCache) Add(obj interface{}) error {
+ object, resourceVersion, err := objectToVersionedRuntimeObject(obj)
+ if err != nil {
+ return err
+ }
+ event := watch.Event{Type: watch.Added, Object: object}
+
+ f := func(obj runtime.Object) error { return w.store.Add(obj) }
+ return w.processEvent(event, resourceVersion, f)
+}
+
+func (w *watchCache) Update(obj interface{}) error {
+ object, resourceVersion, err := objectToVersionedRuntimeObject(obj)
+ if err != nil {
+ return err
+ }
+ event := watch.Event{Type: watch.Modified, Object: object}
+
+ f := func(obj runtime.Object) error { return w.store.Update(obj) }
+ return w.processEvent(event, resourceVersion, f)
+}
+
+func (w *watchCache) Delete(obj interface{}) error {
+ object, resourceVersion, err := objectToVersionedRuntimeObject(obj)
+ if err != nil {
+ return err
+ }
+ event := watch.Event{Type: watch.Deleted, Object: object}
+
+ f := func(obj runtime.Object) error { return w.store.Delete(obj) }
+ return w.processEvent(event, resourceVersion, f)
+}
+
+func objectToVersionedRuntimeObject(obj interface{}) (runtime.Object, uint64, error) {
+ object, ok := obj.(runtime.Object)
+ if !ok {
+ return nil, 0, fmt.Errorf("obj does not implement runtime.Object interface: %v", obj)
+ }
+ meta, err := meta.Accessor(object)
+ if err != nil {
+ return nil, 0, err
+ }
+ resourceVersion, err := parseResourceVersion(meta.GetResourceVersion())
+ if err != nil {
+ return nil, 0, err
+ }
+ return object, resourceVersion, nil
+}
+
+func parseResourceVersion(resourceVersion string) (uint64, error) {
+ if resourceVersion == "" {
+ return 0, nil
+ }
+ return strconv.ParseUint(resourceVersion, 10, 64)
+}
+
+func (w *watchCache) processEvent(event watch.Event, resourceVersion uint64, updateFunc func(runtime.Object) error) error {
+ w.Lock()
+ defer w.Unlock()
+ previous, exists, err := w.store.Get(event.Object)
+ if err != nil {
+ return err
+ }
+ var prevObject runtime.Object
+ if exists {
+ prevObject = previous.(runtime.Object)
+ }
+ watchCacheEvent := watchCacheEvent{event.Type, event.Object, prevObject, resourceVersion}
+ if w.onEvent != nil {
+ w.onEvent(watchCacheEvent)
+ }
+ w.updateCache(resourceVersion, watchCacheEvent)
+ w.resourceVersion = resourceVersion
+ w.cond.Broadcast()
+ return updateFunc(event.Object)
+}
+
+// Assumes that lock is already held for write.
+func (w *watchCache) updateCache(resourceVersion uint64, event watchCacheEvent) {
+ if w.endIndex == w.startIndex+w.capacity {
+ // Cache is full - remove the oldest element.
+ w.startIndex++
+ }
+ w.cache[w.endIndex%w.capacity] = watchCacheElement{resourceVersion, event}
+ w.endIndex++
+}
+
+func (w *watchCache) List() []interface{} {
+ w.RLock()
+ defer w.RUnlock()
+ return w.store.List()
+}
+
+func (w *watchCache) WaitUntilFreshAndList(resourceVersion uint64) ([]interface{}, uint64, error) {
+ startTime := w.clock.Now()
+ go func() {
+ // Wake us up when the time limit has expired. The docs
+ // promise that time.After (well, NewTimer, which it calls)
+ // will wait *at least* the duration given. Since this go
+ // routine starts sometime after we record the start time, and
+ // it will wake up the loop below sometime after the broadcast,
+ // we don't need to worry about waking it up before the time
+ // has expired accidentally.
+ <-w.clock.After(MaximumListWait)
+ w.cond.Broadcast()
+ }()
+
+ w.RLock()
+ defer w.RUnlock()
+ for w.resourceVersion < resourceVersion {
+ if w.clock.Since(startTime) >= MaximumListWait {
+ return nil, 0, fmt.Errorf("time limit exceeded while waiting for resource version %v (current value: %v)", resourceVersion, w.resourceVersion)
+ }
+ w.cond.Wait()
+ }
+ return w.store.List(), w.resourceVersion, nil
+}
+
+func (w *watchCache) ListKeys() []string {
+ w.RLock()
+ defer w.RUnlock()
+ return w.store.ListKeys()
+}
+
+func (w *watchCache) Get(obj interface{}) (interface{}, bool, error) {
+ w.RLock()
+ defer w.RUnlock()
+ return w.store.Get(obj)
+}
+
+func (w *watchCache) GetByKey(key string) (interface{}, bool, error) {
+ w.RLock()
+ defer w.RUnlock()
+ return w.store.GetByKey(key)
+}
+
+func (w *watchCache) Replace(objs []interface{}, resourceVersion string) error {
+ version, err := parseResourceVersion(resourceVersion)
+ if err != nil {
+ return err
+ }
+
+ w.Lock()
+ defer w.Unlock()
+
+ w.startIndex = 0
+ w.endIndex = 0
+ if err := w.store.Replace(objs, resourceVersion); err != nil {
+ return err
+ }
+ w.resourceVersion = version
+ if w.onReplace != nil {
+ w.onReplace()
+ }
+ w.cond.Broadcast()
+ return nil
+}
+
+func (w *watchCache) SetOnReplace(onReplace func()) {
+ w.Lock()
+ defer w.Unlock()
+ w.onReplace = onReplace
+}
+
+func (w *watchCache) SetOnEvent(onEvent func(watchCacheEvent)) {
+ w.Lock()
+ defer w.Unlock()
+ w.onEvent = onEvent
+}
+
+func (w *watchCache) GetAllEventsSinceThreadUnsafe(resourceVersion uint64) ([]watchCacheEvent, error) {
+ size := w.endIndex - w.startIndex
+ oldest := w.resourceVersion
+ if size > 0 {
+ oldest = w.cache[w.startIndex%w.capacity].resourceVersion
+ }
+ if resourceVersion == 0 {
+ // resourceVersion = 0 means that we don't require any specific starting point
+ // and we would like to start watching from ~now.
+ // However, to keep backward compatibility, we additionally need to return the
+ // current state and only then start watching from that point.
+ //
+ // TODO: In v2 api, we should stop returning the current state - #13969.
+ allItems := w.store.List()
+ result := make([]watchCacheEvent, len(allItems))
+ for i, item := range allItems {
+ result[i] = watchCacheEvent{Type: watch.Added, Object: item.(runtime.Object)}
+ }
+ return result, nil
+ }
+ if resourceVersion < oldest-1 {
+ return nil, errors.NewGone(fmt.Sprintf("too old resource version: %d (%d)", resourceVersion, oldest-1))
+ }
+
+ // Binary search the smallest index at which resourceVersion is greater than the given one.
+ f := func(i int) bool {
+ return w.cache[(w.startIndex+i)%w.capacity].resourceVersion > resourceVersion
+ }
+ first := sort.Search(size, f)
+ result := make([]watchCacheEvent, size-first)
+ for i := 0; i < size-first; i++ {
+ result[i] = w.cache[(w.startIndex+first+i)%w.capacity].watchCacheEvent
+ }
+ return result, nil
+}
+
+func (w *watchCache) GetAllEventsSince(resourceVersion uint64) ([]watchCacheEvent, error) {
+ w.RLock()
+ defer w.RUnlock()
+ return w.GetAllEventsSinceThreadUnsafe(resourceVersion)
+}
+
+func (w *watchCache) Resync() error {
+ // Nothing to do
+ return nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/doc.go b/vendor/k8s.io/kubernetes/pkg/types/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/doc.go
rename to vendor/k8s.io/kubernetes/pkg/types/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/namespacedname.go b/vendor/k8s.io/kubernetes/pkg/types/namespacedname.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/namespacedname.go
rename to vendor/k8s.io/kubernetes/pkg/types/namespacedname.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/uid.go b/vendor/k8s.io/kubernetes/pkg/types/uid.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/uid.go
rename to vendor/k8s.io/kubernetes/pkg/types/uid.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/unix_user_id.go b/vendor/k8s.io/kubernetes/pkg/types/unix_user_id.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/types/unix_user_id.go
rename to vendor/k8s.io/kubernetes/pkg/types/unix_user_id.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/clock.go b/vendor/k8s.io/kubernetes/pkg/util/clock.go
similarity index 77%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/clock.go
rename to vendor/k8s.io/kubernetes/pkg/util/clock.go
index ac2d738d628114b3af90fa29326dd83634b29428..474cbb68d11f89b46c9a5f6bf518fd840a42bc5e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/clock.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/clock.go
@@ -28,6 +28,7 @@ type Clock interface {
Since(time.Time) time.Duration
After(d time.Duration) <-chan time.Time
Sleep(d time.Duration)
+ Tick(d time.Duration) <-chan time.Time
}
var (
@@ -54,6 +55,10 @@ func (RealClock) After(d time.Duration) <-chan time.Time {
return time.After(d)
}
+func (RealClock) Tick(d time.Duration) <-chan time.Time {
+ return time.Tick(d)
+}
+
func (RealClock) Sleep(d time.Duration) {
time.Sleep(d)
}
@@ -68,8 +73,10 @@ type FakeClock struct {
}
type fakeClockWaiter struct {
- targetTime time.Time
- destChan chan<- time.Time
+ targetTime time.Time
+ stepInterval time.Duration
+ skipIfBlocked bool
+ destChan chan<- time.Time
}
func NewFakeClock(t time.Time) *FakeClock {
@@ -105,7 +112,22 @@ func (f *FakeClock) After(d time.Duration) <-chan time.Time {
return ch
}
-// Move clock by Duration, notify anyone that's called After
+func (f *FakeClock) Tick(d time.Duration) <-chan time.Time {
+ f.lock.Lock()
+ defer f.lock.Unlock()
+ tickTime := f.time.Add(d)
+ ch := make(chan time.Time, 1) // hold one tick
+ f.waiters = append(f.waiters, fakeClockWaiter{
+ targetTime: tickTime,
+ stepInterval: d,
+ skipIfBlocked: true,
+ destChan: ch,
+ })
+
+ return ch
+}
+
+// Move clock by Duration, notify anyone that's called After or Tick
func (f *FakeClock) Step(d time.Duration) {
f.lock.Lock()
defer f.lock.Unlock()
@@ -126,7 +148,23 @@ func (f *FakeClock) setTimeLocked(t time.Time) {
for i := range f.waiters {
w := &f.waiters[i]
if !w.targetTime.After(t) {
- w.destChan <- t
+
+ if w.skipIfBlocked {
+ select {
+ case w.destChan <- t:
+ default:
+ }
+ } else {
+ w.destChan <- t
+ }
+
+ if w.stepInterval > 0 {
+ for !w.targetTime.After(t) {
+ w.targetTime = w.targetTime.Add(w.stepInterval)
+ }
+ newWaiters = append(newWaiters, *w)
+ }
+
} else {
newWaiters = append(newWaiters, f.waiters[i])
}
@@ -169,6 +207,12 @@ func (*IntervalClock) After(d time.Duration) <-chan time.Time {
panic("IntervalClock doesn't implement After")
}
+// Unimplemented, will panic.
+// TODO: make interval clock use FakeClock so this can be implemented.
+func (*IntervalClock) Tick(d time.Duration) <-chan time.Time {
+ panic("IntervalClock doesn't implement Tick")
+}
+
func (*IntervalClock) Sleep(d time.Duration) {
panic("IntervalClock doesn't implement Sleep")
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crypto.go b/vendor/k8s.io/kubernetes/pkg/util/crypto/crypto.go
similarity index 90%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crypto.go
rename to vendor/k8s.io/kubernetes/pkg/util/crypto/crypto.go
index 42b890d1891f0a54c2bb12fbbd325da0aad79a11..f43664369f612146234c80162d54a619f118a5b4 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/crypto.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/crypto/crypto.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package util
+package crypto
import (
"bytes"
@@ -33,6 +33,29 @@ import (
"time"
)
+// ShouldGenSelfSignedCerts returns false if the certificate or key files already exists,
+// otherwise returns true.
+func ShouldGenSelfSignedCerts(certPath, keyPath string) bool {
+ if canReadFile(certPath) || canReadFile(keyPath) {
+ return false
+ }
+
+ return true
+}
+
+// If the file represented by path exists and
+// readable, returns true otherwise returns false.
+func canReadFile(path string) bool {
+ f, err := os.Open(path)
+ if err != nil {
+ return false
+ }
+
+ defer f.Close()
+
+ return true
+}
+
// GenerateSelfSignedCert creates a self-signed certificate and key for the given host.
// Host may be an IP or a DNS name
// You may also specify additional subject alt names (either ip or dns names) for the certificate
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deployment/deployment.go b/vendor/k8s.io/kubernetes/pkg/util/deployment/deployment.go
similarity index 71%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deployment/deployment.go
rename to vendor/k8s.io/kubernetes/pkg/util/deployment/deployment.go
index 6160f5d138f97bc0d56fb2153ad57cdfad85fc77..0442da429019ca97970b40de42ff03e9db39b949 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/deployment/deployment.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/deployment/deployment.go
@@ -34,6 +34,7 @@ import (
intstrutil "k8s.io/kubernetes/pkg/util/intstr"
labelsutil "k8s.io/kubernetes/pkg/util/labels"
podutil "k8s.io/kubernetes/pkg/util/pod"
+ rsutil "k8s.io/kubernetes/pkg/util/replicaset"
"k8s.io/kubernetes/pkg/util/wait"
)
@@ -47,23 +48,39 @@ const (
RollbackDone = "DeploymentRollback"
)
+// GetAllReplicaSets returns the old and new replica sets targeted by the given Deployment. It gets PodList and ReplicaSetList from client interface.
+// Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
+// The third returned value is the new replica set, and it may be nil if it doesn't exist yet.
+func GetAllReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, *extensions.ReplicaSet, error) {
+ rsList, err := listReplicaSets(deployment, c)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ podList, err := listPods(deployment, c)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ oldRSes, allOldRSes, err := FindOldReplicaSets(deployment, rsList, podList)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ newRS, err := FindNewReplicaSet(deployment, rsList)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ return oldRSes, allOldRSes, newRS, nil
+}
+
// GetOldReplicaSets returns the old replica sets targeted by the given Deployment; get PodList and ReplicaSetList from client interface.
// Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, error) {
- rsList, err := ListReplicaSets(deployment,
- func(namespace string, options api.ListOptions) ([]extensions.ReplicaSet, error) {
- rsList, err := c.Extensions().ReplicaSets(namespace).List(options)
- return rsList.Items, err
- })
+ rsList, err := listReplicaSets(deployment, c)
if err != nil {
- return nil, nil, fmt.Errorf("error listing ReplicaSets: %v", err)
+ return nil, nil, err
}
- podList, err := ListPods(deployment,
- func(namespace string, options api.ListOptions) (*api.PodList, error) {
- return c.Core().Pods(namespace).List(options)
- })
+ podList, err := listPods(deployment, c)
if err != nil {
- return nil, nil, fmt.Errorf("error listing Pods: %v", err)
+ return nil, nil, err
}
return FindOldReplicaSets(deployment, rsList, podList)
}
@@ -71,15 +88,28 @@ func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface)
// GetNewReplicaSet returns a replica set that matches the intent of the given deployment; get ReplicaSetList from client interface.
// Returns nil if the new replica set doesn't exist yet.
func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface) (*extensions.ReplicaSet, error) {
- rsList, err := ListReplicaSets(deployment,
+ rsList, err := listReplicaSets(deployment, c)
+ if err != nil {
+ return nil, err
+ }
+ return FindNewReplicaSet(deployment, rsList)
+}
+
+// listReplicaSets lists all RSes the given deployment targets with the given client interface.
+func listReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]extensions.ReplicaSet, error) {
+ return ListReplicaSets(deployment,
func(namespace string, options api.ListOptions) ([]extensions.ReplicaSet, error) {
rsList, err := c.Extensions().ReplicaSets(namespace).List(options)
return rsList.Items, err
})
- if err != nil {
- return nil, fmt.Errorf("error listing ReplicaSets: %v", err)
- }
- return FindNewReplicaSet(deployment, rsList)
+}
+
+// listReplicaSets lists all Pods the given deployment targets with the given client interface.
+func listPods(deployment *extensions.Deployment, c clientset.Interface) (*api.PodList, error) {
+ return ListPods(deployment,
+ func(namespace string, options api.ListOptions) (*api.PodList, error) {
+ return c.Core().Pods(namespace).List(options)
+ })
}
// TODO: switch this to full namespacers
@@ -111,11 +141,34 @@ func ListPods(deployment *extensions.Deployment, getPodList podListFunc) (*api.P
return getPodList(namespace, options)
}
+// equalIgnoreHash returns true if two given podTemplateSpec are equal, ignoring the diff in value of Labels[pod-template-hash]
+// We ignore pod-template-hash because the hash result would be different upon podTemplateSpec API changes
+// (e.g. the addition of a new field will cause the hash code to change)
+// Note that we assume input podTemplateSpecs contain non-empty labels
+func equalIgnoreHash(template1, template2 api.PodTemplateSpec) (bool, error) {
+ // The podTemplateSpec must have a non-empty label so that label selectors can find them.
+ // This is checked by validation (of resources contain a podTemplateSpec).
+ if len(template1.Labels) == 0 || len(template2.Labels) == 0 {
+ return false, fmt.Errorf("Unexpected empty labels found in given template")
+ }
+ hash1 := template1.Labels[extensions.DefaultDeploymentUniqueLabelKey]
+ hash2 := template2.Labels[extensions.DefaultDeploymentUniqueLabelKey]
+ // compare equality ignoring pod-template-hash
+ template1.Labels[extensions.DefaultDeploymentUniqueLabelKey] = hash2
+ result := api.Semantic.DeepEqual(template1, template2)
+ template1.Labels[extensions.DefaultDeploymentUniqueLabelKey] = hash1
+ return result, nil
+}
+
// FindNewReplicaSet returns the new RS this given deployment targets (the one with the same pod template).
func FindNewReplicaSet(deployment *extensions.Deployment, rsList []extensions.ReplicaSet) (*extensions.ReplicaSet, error) {
newRSTemplate := GetNewReplicaSetTemplate(deployment)
for i := range rsList {
- if api.Semantic.DeepEqual(rsList[i].Spec.Template, newRSTemplate) {
+ equal, err := equalIgnoreHash(rsList[i].Spec.Template, newRSTemplate)
+ if err != nil {
+ return nil, err
+ }
+ if equal {
// This is the new ReplicaSet.
return &rsList[i], nil
}
@@ -140,7 +193,11 @@ func FindOldReplicaSets(deployment *extensions.Deployment, rsList []extensions.R
return nil, nil, fmt.Errorf("invalid label selector: %v", err)
}
// Filter out replica set that has the same pod template spec as the deployment - that is the new replica set.
- if api.Semantic.DeepEqual(rs.Spec.Template, newRSTemplate) {
+ equal, err := equalIgnoreHash(rs.Spec.Template, newRSTemplate)
+ if err != nil {
+ return nil, nil, err
+ }
+ if equal {
continue
}
allOldRSs[rs.ObjectMeta.Name] = rs
@@ -237,8 +294,8 @@ func SetFromReplicaSetTemplate(deployment *extensions.Deployment, template api.P
}
// Returns the sum of Replicas of the given replica sets.
-func GetReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) int {
- totalReplicaCount := 0
+func GetReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) int32 {
+ totalReplicaCount := int32(0)
for _, rs := range replicaSets {
if rs != nil {
totalReplicaCount += rs.Spec.Replicas
@@ -248,8 +305,8 @@ func GetReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) int {
}
// GetActualReplicaCountForReplicaSets returns the sum of actual replicas of the given replica sets.
-func GetActualReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) int {
- totalReplicaCount := 0
+func GetActualReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) int32 {
+ totalReplicaCount := int32(0)
for _, rs := range replicaSets {
if rs != nil {
totalReplicaCount += rs.Status.Replicas
@@ -258,26 +315,45 @@ func GetActualReplicaCountForReplicaSets(replicaSets []*extensions.ReplicaSet) i
return totalReplicaCount
}
-// Returns the number of available pods corresponding to the given replica sets.
-func GetAvailablePodsForReplicaSets(c clientset.Interface, rss []*extensions.ReplicaSet, minReadySeconds int) (int, error) {
- allPods, err := GetPodsForReplicaSets(c, rss)
+// GetAvailablePodsForReplicaSets returns the number of available pods (listed from clientset) corresponding to the given replica sets.
+func GetAvailablePodsForReplicaSets(c clientset.Interface, deployment *extensions.Deployment, rss []*extensions.ReplicaSet, minReadySeconds int32) (int32, error) {
+ podList, err := listPods(deployment, c)
+ if err != nil {
+ return 0, err
+ }
+ return CountAvailablePodsForReplicaSets(podList, rss, minReadySeconds)
+}
+
+// CountAvailablePodsForReplicaSets returns the number of available pods corresponding to the given pod list and replica sets.
+// Note that the input pod list should be the pods targeted by the deployment of input replica sets.
+func CountAvailablePodsForReplicaSets(podList *api.PodList, rss []*extensions.ReplicaSet, minReadySeconds int32) (int32, error) {
+ rsPods, err := filterPodsMatchingReplicaSets(rss, podList)
if err != nil {
return 0, err
}
- return getReadyPodsCount(allPods, minReadySeconds), nil
+ return countAvailablePods(rsPods, minReadySeconds), nil
}
-func getReadyPodsCount(pods []api.Pod, minReadySeconds int) int {
- readyPodCount := 0
+// GetAvailablePodsForDeployment returns the number of available pods (listed from clientset) corresponding to the given deployment.
+func GetAvailablePodsForDeployment(c clientset.Interface, deployment *extensions.Deployment, minReadySeconds int32) (int32, error) {
+ podList, err := listPods(deployment, c)
+ if err != nil {
+ return 0, err
+ }
+ return countAvailablePods(podList.Items, minReadySeconds), nil
+}
+
+func countAvailablePods(pods []api.Pod, minReadySeconds int32) int32 {
+ availablePodCount := int32(0)
for _, pod := range pods {
if IsPodAvailable(&pod, minReadySeconds) {
- readyPodCount++
+ availablePodCount++
}
}
- return readyPodCount
+ return availablePodCount
}
-func IsPodAvailable(pod *api.Pod, minReadySeconds int) bool {
+func IsPodAvailable(pod *api.Pod, minReadySeconds int32) bool {
if !controller.IsPodActive(*pod) {
return false
}
@@ -286,11 +362,11 @@ func IsPodAvailable(pod *api.Pod, minReadySeconds int) bool {
for _, c := range pod.Status.Conditions {
// we only care about pod ready conditions
if c.Type == api.PodReady && c.Status == api.ConditionTrue {
- // 2 cases that this ready condition is valid (passed minReadySeconds, i.e. the pod is ready):
- // 1. minReadySeconds <= 0
+ // 2 cases that this ready condition is valid (passed minReadySeconds, i.e. the pod is available):
+ // 1. minReadySeconds == 0, or
// 2. LastTransitionTime (is set) + minReadySeconds (>0) < current time
minReadySecondsDuration := time.Duration(minReadySeconds) * time.Second
- if minReadySeconds <= 0 || !c.LastTransitionTime.IsZero() && c.LastTransitionTime.Add(minReadySecondsDuration).Before(time.Now()) {
+ if minReadySeconds == 0 || !c.LastTransitionTime.IsZero() && c.LastTransitionTime.Add(minReadySecondsDuration).Before(time.Now()) {
return true
}
}
@@ -298,29 +374,20 @@ func IsPodAvailable(pod *api.Pod, minReadySeconds int) bool {
return false
}
-func GetPodsForReplicaSets(c clientset.Interface, replicaSets []*extensions.ReplicaSet) ([]api.Pod, error) {
- allPods := map[string]api.Pod{}
+// filterPodsMatchingReplicaSets filters the given pod list and only return the ones targeted by the input replicasets
+func filterPodsMatchingReplicaSets(replicaSets []*extensions.ReplicaSet, podList *api.PodList) ([]api.Pod, error) {
+ rsPods := []api.Pod{}
for _, rs := range replicaSets {
- if rs != nil {
- selector, err := unversioned.LabelSelectorAsSelector(rs.Spec.Selector)
- if err != nil {
- return nil, fmt.Errorf("invalid label selector: %v", err)
- }
- options := api.ListOptions{LabelSelector: selector}
- podList, err := c.Core().Pods(rs.ObjectMeta.Namespace).List(options)
- if err != nil {
- return nil, fmt.Errorf("error listing pods: %v", err)
- }
- for _, pod := range podList.Items {
- allPods[pod.Name] = pod
- }
+ matchingFunc, err := rsutil.MatchingPodsFunc(rs)
+ if err != nil {
+ return nil, err
}
+ if matchingFunc == nil {
+ continue
+ }
+ rsPods = append(rsPods, podutil.Filter(podList, matchingFunc)...)
}
- requiredPods := []api.Pod{}
- for _, pod := range allPods {
- requiredPods = append(requiredPods, pod)
- }
- return requiredPods, nil
+ return rsPods, nil
}
// Revision returns the revision number of the input replica set
@@ -340,17 +407,17 @@ func IsRollingUpdate(deployment *extensions.Deployment) bool {
// When one of the followings is true, we're rolling out the deployment; otherwise, we're scaling it.
// 1) The new RS is saturated: newRS's replicas == deployment's replicas
// 2) Max number of pods allowed is reached: deployment's replicas + maxSurge == all RSs' replicas
-func NewRSNewReplicas(deployment *extensions.Deployment, allRSs []*extensions.ReplicaSet, newRS *extensions.ReplicaSet) (int, error) {
+func NewRSNewReplicas(deployment *extensions.Deployment, allRSs []*extensions.ReplicaSet, newRS *extensions.ReplicaSet) (int32, error) {
switch deployment.Spec.Strategy.Type {
case extensions.RollingUpdateDeploymentStrategyType:
// Check if we can scale up.
- maxSurge, err := intstrutil.GetValueFromIntOrPercent(&deployment.Spec.Strategy.RollingUpdate.MaxSurge, deployment.Spec.Replicas, true)
+ maxSurge, err := intstrutil.GetValueFromIntOrPercent(&deployment.Spec.Strategy.RollingUpdate.MaxSurge, int(deployment.Spec.Replicas), true)
if err != nil {
return 0, err
}
// Find the total number of pods
currentPodCount := GetReplicaCountForReplicaSets(allRSs)
- maxTotalPods := deployment.Spec.Replicas + maxSurge
+ maxTotalPods := deployment.Spec.Replicas + int32(maxSurge)
if currentPodCount >= maxTotalPods {
// Cannot scale up.
return newRS.Spec.Replicas, nil
@@ -358,7 +425,7 @@ func NewRSNewReplicas(deployment *extensions.Deployment, allRSs []*extensions.Re
// Scale up.
scaleUpCount := maxTotalPods - currentPodCount
// Do not exceed the number of desired replicas.
- scaleUpCount = integer.IntMin(scaleUpCount, deployment.Spec.Replicas-newRS.Spec.Replicas)
+ scaleUpCount = int32(integer.IntMin(int(scaleUpCount), int(deployment.Spec.Replicas-newRS.Spec.Replicas)))
return newRS.Spec.Replicas + scaleUpCount, nil
case extensions.RecreateDeploymentStrategyType:
return deployment.Spec.Replicas, nil
@@ -389,12 +456,12 @@ func WaitForObservedDeployment(getDeploymentFunc func() (*extensions.Deployment,
// 1 desired, max unavailable 25%, surge 1% - should scale new(+1), then old(-1)
// 2 desired, max unavailable 0%, surge 1% - should scale new(+1), then old(-1), then new(+1), then old(-1)
// 1 desired, max unavailable 0%, surge 1% - should scale new(+1), then old(-1)
-func ResolveFenceposts(maxSurge, maxUnavailable *intstrutil.IntOrString, desired int) (int, int, error) {
- surge, err := intstrutil.GetValueFromIntOrPercent(maxSurge, desired, true)
+func ResolveFenceposts(maxSurge, maxUnavailable *intstrutil.IntOrString, desired int32) (int32, int32, error) {
+ surge, err := intstrutil.GetValueFromIntOrPercent(maxSurge, int(desired), true)
if err != nil {
return 0, 0, err
}
- unavailable, err := intstrutil.GetValueFromIntOrPercent(maxUnavailable, desired, false)
+ unavailable, err := intstrutil.GetValueFromIntOrPercent(maxUnavailable, int(desired), false)
if err != nil {
return 0, 0, err
}
@@ -407,5 +474,5 @@ func ResolveFenceposts(maxSurge, maxUnavailable *intstrutil.IntOrString, desired
unavailable = 1
}
- return surge, unavailable, nil
+ return int32(surge), int32(unavailable), nil
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/doc.go b/vendor/k8s.io/kubernetes/pkg/util/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/errors/doc.go b/vendor/k8s.io/kubernetes/pkg/util/errors/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/errors/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/errors/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/errors/errors.go b/vendor/k8s.io/kubernetes/pkg/util/errors/errors.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/errors/errors.go
rename to vendor/k8s.io/kubernetes/pkg/util/errors/errors.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/backoff.go b/vendor/k8s.io/kubernetes/pkg/util/flowcontrol/backoff.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/backoff.go
rename to vendor/k8s.io/kubernetes/pkg/util/flowcontrol/backoff.go
index 275a58a22981d3fb842a031e8936195262d2af9b..1898c55c99d7734075289d98331586570a116d06 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/backoff.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/flowcontrol/backoff.go
@@ -14,12 +14,13 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package util
+package flowcontrol
import (
"sync"
"time"
+ "k8s.io/kubernetes/pkg/util"
"k8s.io/kubernetes/pkg/util/integer"
)
@@ -30,13 +31,13 @@ type backoffEntry struct {
type Backoff struct {
sync.Mutex
- Clock Clock
+ Clock util.Clock
defaultDuration time.Duration
maxDuration time.Duration
perItemBackoff map[string]*backoffEntry
}
-func NewFakeBackOff(initial, max time.Duration, tc *FakeClock) *Backoff {
+func NewFakeBackOff(initial, max time.Duration, tc *util.FakeClock) *Backoff {
return &Backoff{
perItemBackoff: map[string]*backoffEntry{},
Clock: tc,
@@ -48,7 +49,7 @@ func NewFakeBackOff(initial, max time.Duration, tc *FakeClock) *Backoff {
func NewBackOff(initial, max time.Duration) *Backoff {
return &Backoff{
perItemBackoff: map[string]*backoffEntry{},
- Clock: RealClock{},
+ Clock: util.RealClock{},
defaultDuration: initial,
maxDuration: max,
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/throttle.go b/vendor/k8s.io/kubernetes/pkg/util/flowcontrol/throttle.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/throttle.go
rename to vendor/k8s.io/kubernetes/pkg/util/flowcontrol/throttle.go
index c1caea099fee3f4c96834465e3cfd277a938beef..a63817ca8c104a96900eeecd1880df34931f89be 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/throttle.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/flowcontrol/throttle.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package util
+package flowcontrol
import (
"sync"
diff --git a/vendor/k8s.io/kubernetes/pkg/util/framer/framer.go b/vendor/k8s.io/kubernetes/pkg/util/framer/framer.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ca806fa054752171901e24769d7aa4a2901f73d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/framer/framer.go
@@ -0,0 +1,167 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 framer implements simple frame decoding techniques for an io.ReadCloser
+package framer
+
+import (
+ "encoding/binary"
+ "encoding/json"
+ "io"
+)
+
+type lengthDelimitedFrameWriter struct {
+ w io.Writer
+ h [4]byte
+}
+
+func NewLengthDelimitedFrameWriter(w io.Writer) io.Writer {
+ return &lengthDelimitedFrameWriter{w: w}
+}
+
+// Write writes a single frame to the nested writer, prepending it with the length in
+// in bytes of data (as a 4 byte, bigendian uint32).
+func (w *lengthDelimitedFrameWriter) Write(data []byte) (int, error) {
+ binary.BigEndian.PutUint32(w.h[:], uint32(len(data)))
+ n, err := w.w.Write(w.h[:])
+ if err != nil {
+ return 0, err
+ }
+ if n != len(w.h) {
+ return 0, io.ErrShortWrite
+ }
+ return w.w.Write(data)
+}
+
+type lengthDelimitedFrameReader struct {
+ r io.ReadCloser
+ remaining int
+}
+
+// NewLengthDelimitedFrameReader returns an io.Reader that will decode length-prefixed
+// frames off of a stream.
+//
+// The protocol is:
+//
+// stream: message ...
+// message: prefix body
+// prefix: 4 byte uint32 in BigEndian order, denotes length of body
+// body: bytes (0..prefix)
+//
+// If the buffer passed to Read is not long enough to contain an entire frame, io.ErrShortRead
+// will be returned along with the number of bytes read.
+func NewLengthDelimitedFrameReader(r io.ReadCloser) io.ReadCloser {
+ return &lengthDelimitedFrameReader{r: r}
+}
+
+// Read attempts to read an entire frame into data. If that is not possible, io.ErrShortBuffer
+// is returned and subsequent calls will attempt to read the last frame. A frame is complete when
+// err is nil.
+func (r *lengthDelimitedFrameReader) Read(data []byte) (int, error) {
+ if r.remaining <= 0 {
+ header := [4]byte{}
+ n, err := io.ReadAtLeast(r.r, header[:4], 4)
+ if err != nil {
+ return 0, err
+ }
+ if n != 4 {
+ return 0, io.ErrUnexpectedEOF
+ }
+ frameLength := int(binary.BigEndian.Uint32(header[:]))
+ r.remaining = frameLength
+ }
+
+ expect := r.remaining
+ max := expect
+ if max > len(data) {
+ max = len(data)
+ }
+ n, err := io.ReadAtLeast(r.r, data[:max], int(max))
+ r.remaining -= n
+ if err == io.ErrShortBuffer || r.remaining > 0 {
+ return n, io.ErrShortBuffer
+ }
+ if err != nil {
+ return n, err
+ }
+ if n != expect {
+ return n, io.ErrUnexpectedEOF
+ }
+
+ return n, nil
+}
+
+func (r *lengthDelimitedFrameReader) Close() error {
+ return r.r.Close()
+}
+
+type jsonFrameReader struct {
+ r io.ReadCloser
+ decoder *json.Decoder
+ remaining []byte
+}
+
+// NewJSONFramedReader returns an io.Reader that will decode individual JSON objects off
+// of a wire.
+//
+// The boundaries between each frame are valid JSON objects. A JSON parsing error will terminate
+// the read.
+func NewJSONFramedReader(r io.ReadCloser) io.ReadCloser {
+ return &jsonFrameReader{
+ r: r,
+ decoder: json.NewDecoder(r),
+ }
+}
+
+// ReadFrame decodes the next JSON object in the stream, or returns an error. The returned
+// byte slice will be modified the next time ReadFrame is invoked and should not be altered.
+func (r *jsonFrameReader) Read(data []byte) (int, error) {
+ // Return whatever remaining data exists from an in progress frame
+ if n := len(r.remaining); n > 0 {
+ if n <= len(data) {
+ data = append(data[0:0], r.remaining...)
+ r.remaining = nil
+ return n, nil
+ }
+
+ n = len(data)
+ data = append(data[0:0], r.remaining[:n]...)
+ r.remaining = r.remaining[n:]
+ return n, io.ErrShortBuffer
+ }
+
+ // RawMessage#Unmarshal appends to data - we reset the slice down to 0 and will either see
+ // data written to data, or be larger than data and a different array.
+ n := len(data)
+ m := json.RawMessage(data[:0])
+ if err := r.decoder.Decode(&m); err != nil {
+ return 0, err
+ }
+
+ // If capacity of data is less than length of the message, decoder will allocate a new slice
+ // and set m to it, which means we need to copy the partial result back into data and preserve
+ // the remaining result for subsequent reads.
+ if len(m) > n {
+ data = append(data[0:0], m[:n]...)
+ r.remaining = m[n:]
+ return n, io.ErrShortBuffer
+ }
+ return len(m), nil
+}
+
+func (r *jsonFrameReader) Close() error {
+ return r.r.Close()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/hash/hash.go b/vendor/k8s.io/kubernetes/pkg/util/hash/hash.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/hash/hash.go
rename to vendor/k8s.io/kubernetes/pkg/util/hash/hash.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/doc.go b/vendor/k8s.io/kubernetes/pkg/util/httpstream/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/httpstream/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go b/vendor/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go
rename to vendor/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go
index 4f6b608ce7a3f59a1a85627e367b23d1e85d27a6..3ce3b02a0198a2f799122d217846391ba1c1d070 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/httpstream/httpstream.go
@@ -114,20 +114,24 @@ func negotiateProtocol(clientProtocols, serverProtocols []string) string {
return ""
}
-// Handshake performs a subprotocol negotiation. If the client did not request
-// a specific subprotocol, defaultProtocol is used. If the client did request a
+// Handshake performs a subprotocol negotiation. If the client did request a
// subprotocol, Handshake will select the first common value found in
// serverProtocols. If a match is found, Handshake adds a response header
// indicating the chosen subprotocol. If no match is found, HTTP forbidden is
// returned, along with a response header containing the list of protocols the
// server can accept.
-func Handshake(req *http.Request, w http.ResponseWriter, serverProtocols []string, defaultProtocol string) (string, error) {
+func Handshake(req *http.Request, w http.ResponseWriter, serverProtocols []string) (string, error) {
clientProtocols := req.Header[http.CanonicalHeaderKey(HeaderProtocolVersion)]
if len(clientProtocols) == 0 {
- // Kube 1.0 client that didn't support subprotocol negotiation
- // TODO remove this defaulting logic once Kube 1.0 is no longer supported
- w.Header().Add(HeaderProtocolVersion, defaultProtocol)
- return defaultProtocol, nil
+ // Kube 1.0 clients didn't support subprotocol negotiation.
+ // TODO require clientProtocols once Kube 1.0 is no longer supported
+ return "", nil
+ }
+
+ if len(serverProtocols) == 0 {
+ // Kube 1.0 servers didn't support subprotocol negotiation. This is mainly for testing.
+ // TODO require serverProtocols once Kube 1.0 is no longer supported
+ return "", nil
}
negotiatedProtocol := negotiateProtocol(clientProtocols, serverProtocols)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/connection.go b/vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/connection.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/connection.go
rename to vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/connection.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go b/vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go
rename to vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go
index ca7e9370ecf2726b0af11b0bfee5c7cdfd28fe71..6091c4e4b103a35723fc9551bdf5741d57a2014b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/roundtripper.go
@@ -125,6 +125,10 @@ func (s *SpdyRoundTripper) dial(req *http.Request) (net.Conn, error) {
return nil, err
}
+ if s.tlsConfig == nil {
+ s.tlsConfig = &tls.Config{}
+ }
+
if len(s.tlsConfig.ServerName) == 0 {
s.tlsConfig.ServerName = host
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/upgrade.go b/vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/upgrade.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/httpstream/spdy/upgrade.go
rename to vendor/k8s.io/kubernetes/pkg/util/httpstream/spdy/upgrade.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/integer/integer.go b/vendor/k8s.io/kubernetes/pkg/util/integer/integer.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/integer/integer.go
rename to vendor/k8s.io/kubernetes/pkg/util/integer/integer.go
diff --git a/vendor/k8s.io/kubernetes/pkg/util/intstr/deep_copy_generated.go b/vendor/k8s.io/kubernetes/pkg/util/intstr/deep_copy_generated.go
new file mode 100644
index 0000000000000000000000000000000000000000..29aef022349d1b26f15763019b0b88931a39b920
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/intstr/deep_copy_generated.go
@@ -0,0 +1,32 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package intstr
+
+import (
+ conversion "k8s.io/kubernetes/pkg/conversion"
+)
+
+func DeepCopy_intstr_IntOrString(in IntOrString, out *IntOrString, c *conversion.Cloner) error {
+ out.Type = in.Type
+ out.IntVal = in.IntVal
+ out.StrVal = in.StrVal
+ return nil
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..ef39cd58655b1007da41b3c8eda3defbc4d7e4e2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.pb.go
@@ -0,0 +1,347 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/util/intstr/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package intstr is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/util/intstr/generated.proto
+
+ It has these top-level messages:
+ IntOrString
+*/
+package intstr
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *IntOrString) Reset() { *m = IntOrString{} }
+func (*IntOrString) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*IntOrString)(nil), "k8s.io.kubernetes.pkg.util.intstr.IntOrString")
+}
+func (m *IntOrString) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *IntOrString) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0x8
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Type))
+ data[i] = 0x10
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.IntVal))
+ data[i] = 0x1a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.StrVal)))
+ i += copy(data[i:], m.StrVal)
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *IntOrString) Size() (n int) {
+ var l int
+ _ = l
+ n += 1 + sovGenerated(uint64(m.Type))
+ n += 1 + sovGenerated(uint64(m.IntVal))
+ l = len(m.StrVal)
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *IntOrString) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: IntOrString: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: IntOrString: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ m.Type = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.Type |= (Type(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IntVal", wireType)
+ }
+ m.IntVal = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ m.IntVal |= (int32(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StrVal", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.StrVal = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.proto b/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..32ad1b6b1bef47bce3bd9051c9a112dd67415cfe
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/intstr/generated.proto
@@ -0,0 +1,43 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.util.intstr;
+
+// Package-wide variables from generator "generated".
+option go_package = "intstr";
+
+// 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.
+// TODO: Rename to Int32OrString
+//
+// +gencopy=true
+// +protobuf=true
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message IntOrString {
+ optional int64 type = 1;
+
+ optional int32 intVal = 2;
+
+ optional string strVal = 3;
+}
+
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/intstr/intstr.go b/vendor/k8s.io/kubernetes/pkg/util/intstr/intstr.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/intstr/intstr.go
rename to vendor/k8s.io/kubernetes/pkg/util/intstr/intstr.go
index aa3cde1fa87dbe9862f186ecade5c86ea827499a..53bc0fc7e6277d714aa130aff1a1a6e97fc2acf8 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/intstr/intstr.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/intstr/intstr.go
@@ -32,12 +32,13 @@ import (
// accept a name or number.
// TODO: Rename to Int32OrString
//
+// +gencopy=true
// +protobuf=true
// +protobuf.options.(gogoproto.goproto_stringer)=false
type IntOrString struct {
- Type Type
- IntVal int32
- StrVal string
+ Type Type `protobuf:"varint,1,opt,name=type,casttype=Type"`
+ IntVal int32 `protobuf:"varint,2,opt,name=intVal"`
+ StrVal string `protobuf:"bytes,3,opt,name=strVal"`
}
// Type represents the stored type of IntOrString.
diff --git a/vendor/k8s.io/kubernetes/pkg/util/json/json.go b/vendor/k8s.io/kubernetes/pkg/util/json/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ff8cc0d4413ad436178cb35d4226718e480a02c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/json/json.go
@@ -0,0 +1,107 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 json
+
+import (
+ "bytes"
+ "encoding/json"
+ "io"
+)
+
+// NewEncoder delegates to json.NewEncoder
+// It is only here so this package can be a drop-in for common encoding/json uses
+func NewEncoder(w io.Writer) *json.Encoder {
+ return json.NewEncoder(w)
+}
+
+// Marshal delegates to json.Marshal
+// It is only here so this package can be a drop-in for common encoding/json uses
+func Marshal(v interface{}) ([]byte, error) {
+ return json.Marshal(v)
+}
+
+// Unmarshal unmarshals the given data
+// If v is a *map[string]interface{}, numbers are converted to int64 or float64
+func Unmarshal(data []byte, v interface{}) error {
+ switch v := v.(type) {
+ case *map[string]interface{}:
+ // Build a decoder from the given data
+ decoder := json.NewDecoder(bytes.NewBuffer(data))
+ // Preserve numbers, rather than casting to float64 automatically
+ decoder.UseNumber()
+ // Run the decode
+ if err := decoder.Decode(v); err != nil {
+ return err
+ }
+ // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64
+ return convertMapNumbers(*v)
+
+ default:
+ return json.Unmarshal(data, v)
+ }
+}
+
+// convertMapNumbers traverses the map, converting any json.Number values to int64 or float64.
+// values which are map[string]interface{} or []interface{} are recursively visited
+func convertMapNumbers(m map[string]interface{}) error {
+ var err error
+ for k, v := range m {
+ switch v := v.(type) {
+ case json.Number:
+ m[k], err = convertNumber(v)
+ case map[string]interface{}:
+ err = convertMapNumbers(v)
+ case []interface{}:
+ err = convertSliceNumbers(v)
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// convertSliceNumbers traverses the slice, converting any json.Number values to int64 or float64.
+// values which are map[string]interface{} or []interface{} are recursively visited
+func convertSliceNumbers(s []interface{}) error {
+ var err error
+ for i, v := range s {
+ switch v := v.(type) {
+ case json.Number:
+ s[i], err = convertNumber(v)
+ case map[string]interface{}:
+ err = convertMapNumbers(v)
+ case []interface{}:
+ err = convertSliceNumbers(v)
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// convertNumber converts a json.Number to an int64 or float64, or returns an error
+func convertNumber(n json.Number) (interface{}, error) {
+ // Attempt to convert to an int64 first
+ if i, err := n.Int64(); err == nil {
+ return i, nil
+ }
+ // Return a float64 (default json.Decode() behavior)
+ // An overflow will return an error
+ return n.Float64()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/doc.go b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/jsonpath/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go
similarity index 97%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go
rename to vendor/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go
index 35fcdd92d7af68325d93ce5b9a7fd768d7209ec2..7a402af49b11df68ba93f3fe59eafbbe36f52631 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/jsonpath.go
@@ -325,7 +325,13 @@ func (j *JSONPath) evalField(input []reflect.Value, node *FieldNode) ([]reflect.
return nil, err
}
} else if value.Kind() == reflect.Map {
- result = value.MapIndex(reflect.ValueOf(node.Value))
+ mapKeyType := value.Type().Key()
+ nodeValue := reflect.ValueOf(node.Value)
+ // node value type must be convertible to map key type
+ if !nodeValue.Type().ConvertibleTo(mapKeyType) {
+ return results, fmt.Errorf("%s is not convertible to %s", nodeValue, mapKeyType)
+ }
+ result = value.MapIndex(nodeValue.Convert(mapKeyType))
}
if result.IsValid() {
results = append(results, result)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/node.go b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/node.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/node.go
rename to vendor/k8s.io/kubernetes/pkg/util/jsonpath/node.go
index 9d5242de7bf47140b373d5a2959661e1443189f9..ddf015c049a5e2352f71aad745533f6f1ecd4475 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/node.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/node.go
@@ -95,7 +95,7 @@ func (t *TextNode) String() string {
return fmt.Sprintf("%s: %s", t.Type(), t.Text)
}
-// FieldNode holds filed of struct
+// FieldNode holds field of struct
type FieldNode struct {
NodeType
Value string
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/parser.go b/vendor/k8s.io/kubernetes/pkg/util/jsonpath/parser.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/jsonpath/parser.go
rename to vendor/k8s.io/kubernetes/pkg/util/jsonpath/parser.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/labels/doc.go b/vendor/k8s.io/kubernetes/pkg/util/labels/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/labels/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/labels/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/labels/labels.go b/vendor/k8s.io/kubernetes/pkg/util/labels/labels.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/labels/labels.go
rename to vendor/k8s.io/kubernetes/pkg/util/labels/labels.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/line_delimiter.go b/vendor/k8s.io/kubernetes/pkg/util/line_delimiter.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/line_delimiter.go
rename to vendor/k8s.io/kubernetes/pkg/util/line_delimiter.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/logs.go b/vendor/k8s.io/kubernetes/pkg/util/logs.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/logs.go
rename to vendor/k8s.io/kubernetes/pkg/util/logs.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/http.go b/vendor/k8s.io/kubernetes/pkg/util/net/http.go
similarity index 61%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/http.go
rename to vendor/k8s.io/kubernetes/pkg/util/net/http.go
index f3d4473f0a873b27320f332025e137e1b0c0f7b5..68073776afb193afb8aeb0ff0e16edd5ffc3d372 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/http.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/net/http.go
@@ -23,8 +23,12 @@ import (
"net"
"net/http"
"net/url"
+ "os"
"strconv"
"strings"
+
+ "github.com/golang/glog"
+ "golang.org/x/net/http2"
)
// IsProbableEOF returns true if the given error resembles a connection termination
@@ -52,11 +56,13 @@ func IsProbableEOF(err error) bool {
var defaultTransport = http.DefaultTransport.(*http.Transport)
-// SetTransportDefaults applies the defaults from http.DefaultTransport
+// SetOldTransportDefaults applies the defaults from http.DefaultTransport
// for the Proxy, Dial, and TLSHandshakeTimeout fields if unset
-func SetTransportDefaults(t *http.Transport) *http.Transport {
- if t.Proxy == nil {
- t.Proxy = defaultTransport.Proxy
+func SetOldTransportDefaults(t *http.Transport) *http.Transport {
+ if t.Proxy == nil || isDefault(t.Proxy) {
+ // http.ProxyFromEnvironment doesn't respect CIDRs and that makes it impossible to exclude things like pod and service IPs from proxy settings
+ // ProxierWithNoProxyCIDR allows CIDR rules in NO_PROXY
+ t.Proxy = NewProxierWithNoProxyCIDR(http.ProxyFromEnvironment)
}
if t.Dial == nil {
t.Dial = defaultTransport.Dial
@@ -67,6 +73,19 @@ func SetTransportDefaults(t *http.Transport) *http.Transport {
return t
}
+// SetTransportDefaults applies the defaults from http.DefaultTransport
+// for the Proxy, Dial, and TLSHandshakeTimeout fields if unset
+func SetTransportDefaults(t *http.Transport) *http.Transport {
+ t = SetOldTransportDefaults(t)
+ // Allow HTTP2 clients but default off for now
+ if s := os.Getenv("ENABLE_HTTP2"); len(s) > 0 {
+ if err := http2.ConfigureTransport(t); err != nil {
+ glog.Warningf("Transport failed http2 configuration: %v", err)
+ }
+ }
+ return t
+}
+
type RoundTripperWrapper interface {
http.RoundTripper
WrappedRoundTripper() http.RoundTripper
@@ -150,6 +169,65 @@ func GetClientIP(req *http.Request) net.IP {
}
// Fallback to Remote Address in request, which will give the correct client IP when there is no proxy.
- ip := net.ParseIP(req.RemoteAddr)
- return ip
+ // Remote Address in Go's HTTP server is in the form host:port so we need to split that first.
+ host, _, err := net.SplitHostPort(req.RemoteAddr)
+ if err == nil {
+ return net.ParseIP(host)
+ }
+
+ // Fallback if Remote Address was just IP.
+ return net.ParseIP(req.RemoteAddr)
+}
+
+var defaultProxyFuncPointer = fmt.Sprintf("%p", http.ProxyFromEnvironment)
+
+// isDefault checks to see if the transportProxierFunc is pointing to the default one
+func isDefault(transportProxier func(*http.Request) (*url.URL, error)) bool {
+ transportProxierPointer := fmt.Sprintf("%p", transportProxier)
+ return transportProxierPointer == defaultProxyFuncPointer
+}
+
+// NewProxierWithNoProxyCIDR constructs a Proxier function that respects CIDRs in NO_PROXY and delegates if
+// no matching CIDRs are found
+func NewProxierWithNoProxyCIDR(delegate func(req *http.Request) (*url.URL, error)) func(req *http.Request) (*url.URL, error) {
+ // we wrap the default method, so we only need to perform our check if the NO_PROXY envvar has a CIDR in it
+ noProxyEnv := os.Getenv("NO_PROXY")
+ noProxyRules := strings.Split(noProxyEnv, ",")
+
+ cidrs := []*net.IPNet{}
+ for _, noProxyRule := range noProxyRules {
+ _, cidr, _ := net.ParseCIDR(noProxyRule)
+ if cidr != nil {
+ cidrs = append(cidrs, cidr)
+ }
+ }
+
+ if len(cidrs) == 0 {
+ return delegate
+ }
+
+ return func(req *http.Request) (*url.URL, error) {
+ host := req.URL.Host
+ // for some urls, the Host is already the host, not the host:port
+ if net.ParseIP(host) == nil {
+ var err error
+ host, _, err = net.SplitHostPort(req.URL.Host)
+ if err != nil {
+ return delegate(req)
+ }
+ }
+
+ ip := net.ParseIP(host)
+ if ip == nil {
+ return delegate(req)
+ }
+
+ for _, cidr := range cidrs {
+ if cidr.Contains(ip) {
+ return nil, nil
+ }
+ }
+
+ return delegate(req)
+ }
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/interface.go b/vendor/k8s.io/kubernetes/pkg/util/net/interface.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/interface.go
rename to vendor/k8s.io/kubernetes/pkg/util/net/interface.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/port_range.go b/vendor/k8s.io/kubernetes/pkg/util/net/port_range.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/port_range.go
rename to vendor/k8s.io/kubernetes/pkg/util/net/port_range.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/port_split.go b/vendor/k8s.io/kubernetes/pkg/util/net/port_split.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/port_split.go
rename to vendor/k8s.io/kubernetes/pkg/util/net/port_split.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/sets/README.md b/vendor/k8s.io/kubernetes/pkg/util/net/sets/README.md
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/sets/README.md
rename to vendor/k8s.io/kubernetes/pkg/util/net/sets/README.md
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/sets/ipnet.go b/vendor/k8s.io/kubernetes/pkg/util/net/sets/ipnet.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/net/sets/ipnet.go
rename to vendor/k8s.io/kubernetes/pkg/util/net/sets/ipnet.go
diff --git a/vendor/k8s.io/kubernetes/pkg/util/net/util.go b/vendor/k8s.io/kubernetes/pkg/util/net/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..92d5d0b98d1c57f91c1ce7c9ea7e9573277aeb23
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/net/util.go
@@ -0,0 +1,36 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 net
+
+import (
+ "net"
+ "reflect"
+)
+
+// IPNetEqual checks if the two input IPNets are representing the same subnet.
+// For example,
+// 10.0.0.1/24 and 10.0.0.0/24 are the same subnet.
+// 10.0.0.1/24 and 10.0.0.0/25 are not the same subnet.
+func IPNetEqual(ipnet1, ipnet2 *net.IPNet) bool {
+ if ipnet1 == nil || ipnet2 == nil {
+ return false
+ }
+ if reflect.DeepEqual(ipnet1.Mask, ipnet2.Mask) && ipnet1.Contains(ipnet2.IP) && ipnet2.Contains(ipnet1.IP) {
+ return true
+ }
+ return false
+}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/parsers/parsers.go b/vendor/k8s.io/kubernetes/pkg/util/parsers/parsers.go
new file mode 100644
index 0000000000000000000000000000000000000000..a02f18d3eb19a17132c90cb312a86ef6c1c0fc2c
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/parsers/parsers.go
@@ -0,0 +1,54 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 parsers
+
+import (
+ "fmt"
+
+ dockerref "github.com/docker/distribution/reference"
+)
+
+const (
+ DefaultImageTag = "latest"
+)
+
+// ParseImageName parses a docker image string into three parts: repo, tag and digest.
+// If both tag and digest are empty, a default image tag will be returned.
+func ParseImageName(image string) (string, string, string, error) {
+ named, err := dockerref.ParseNamed(image)
+ if err != nil {
+ return "", "", "", fmt.Errorf("couldn't parse image name: %v", err)
+ }
+
+ repoToPull := named.Name()
+ var tag, digest string
+
+ tagged, ok := named.(dockerref.Tagged)
+ if ok {
+ tag = tagged.Tag()
+ }
+
+ digested, ok := named.(dockerref.Digested)
+ if ok {
+ digest = digested.Digest().String()
+ }
+ // If no tag was specified, use the default "latest".
+ if len(tag) == 0 && len(digest) == 0 {
+ tag = DefaultImageTag
+ }
+ return repoToPull, tag, digest, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/pod/doc.go b/vendor/k8s.io/kubernetes/pkg/util/pod/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/pod/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/pod/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/pod/pod.go b/vendor/k8s.io/kubernetes/pkg/util/pod/pod.go
similarity index 88%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/pod/pod.go
rename to vendor/k8s.io/kubernetes/pkg/util/pod/pod.go
index 8fb5cadd0b14989cfa91de3620b78269eb6ee12c..9c57aaebbcab272b07b618164e3e828326a8f970 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/pod/pod.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/pod/pod.go
@@ -25,7 +25,7 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
- unversionedcore "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
+ unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
errorsutil "k8s.io/kubernetes/pkg/util/errors"
hashutil "k8s.io/kubernetes/pkg/util/hash"
"k8s.io/kubernetes/pkg/util/wait"
@@ -87,3 +87,14 @@ func UpdatePodWithRetries(podClient unversionedcore.PodInterface, pod *api.Pod,
// if the error is nil and podUpdated is true, the returned pod contains the applied update.
return pod, podUpdated, err
}
+
+// Filter uses the input function f to filter the given pod list, and return the filtered pods
+func Filter(podList *api.PodList, f func(api.Pod) bool) []api.Pod {
+ pods := make([]api.Pod, 0)
+ for _, p := range podList.Items {
+ if f(p) {
+ pods = append(pods, p)
+ }
+ }
+ return pods
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/rand/rand.go b/vendor/k8s.io/kubernetes/pkg/util/rand/rand.go
similarity index 76%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/rand/rand.go
rename to vendor/k8s.io/kubernetes/pkg/util/rand/rand.go
index fe306506641daf4ee13d66db314122b59b721185..f2647af337a94ee40e39bf4d7058c7f55b90de7b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/rand/rand.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/rand/rand.go
@@ -32,7 +32,7 @@ var rng = struct {
rand: rand.New(rand.NewSource(time.Now().UTC().UnixNano())),
}
-// Intn generates an integer in range 0->max.
+// Intn generates an integer in range [0,max).
// By design this should panic if input is invalid, <= 0.
func Intn(max int) int {
rng.Lock()
@@ -40,6 +40,22 @@ func Intn(max int) int {
return rng.rand.Intn(max)
}
+// IntnRange generates an integer in range [min,max).
+// By design this should panic if input is invalid, <= 0.
+func IntnRange(min, max int) int {
+ rng.Lock()
+ defer rng.Unlock()
+ return rng.rand.Intn(max-min) + min
+}
+
+// IntnRange generates an int64 integer in range [min,max).
+// By design this should panic if input is invalid, <= 0.
+func Int63nRange(min, max int64) int64 {
+ rng.Lock()
+ defer rng.Unlock()
+ return rng.rand.Int63n(max-min) + min
+}
+
// Seed seeds the rng with the provided seed.
func Seed(seed int64) {
rng.Lock()
diff --git a/vendor/k8s.io/kubernetes/pkg/util/replicaset/replicaset.go b/vendor/k8s.io/kubernetes/pkg/util/replicaset/replicaset.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5dd26517b85fc966f3ff7eab4cd796750faf5e2
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/replicaset/replicaset.go
@@ -0,0 +1,110 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 replicaset
+
+import (
+ "fmt"
+ "time"
+
+ "github.com/golang/glog"
+ "k8s.io/kubernetes/pkg/api"
+ "k8s.io/kubernetes/pkg/api/errors"
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/apis/extensions"
+ unversionedextensions "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"
+ "k8s.io/kubernetes/pkg/labels"
+ errorsutil "k8s.io/kubernetes/pkg/util/errors"
+ labelsutil "k8s.io/kubernetes/pkg/util/labels"
+ podutil "k8s.io/kubernetes/pkg/util/pod"
+ "k8s.io/kubernetes/pkg/util/wait"
+)
+
+// TODO: use client library instead when it starts to support update retries
+// see https://github.com/kubernetes/kubernetes/issues/21479
+type updateRSFunc func(rs *extensions.ReplicaSet) error
+
+// UpdateRSWithRetries updates a RS with given applyUpdate function. Note that RS not found error is ignored.
+// The returned bool value can be used to tell if the RS is actually updated.
+func UpdateRSWithRetries(rsClient unversionedextensions.ReplicaSetInterface, rs *extensions.ReplicaSet, applyUpdate updateRSFunc) (*extensions.ReplicaSet, bool, error) {
+ var err error
+ var rsUpdated bool
+ oldRs := rs
+ if err = wait.Poll(10*time.Millisecond, 1*time.Minute, func() (bool, error) {
+ rs, err = rsClient.Get(oldRs.Name)
+ if err != nil {
+ return false, err
+ }
+ // Apply the update, then attempt to push it to the apiserver.
+ if err = applyUpdate(rs); err != nil {
+ return false, err
+ }
+ if rs, err = rsClient.Update(rs); err == nil {
+ // Update successful.
+ return true, nil
+ }
+ // TODO: don't retry on perm-failed errors and handle them gracefully
+ // Update could have failed due to conflict error. Try again.
+ return false, nil
+ }); err == nil {
+ // When there's no error, we've updated this RS.
+ rsUpdated = true
+ }
+
+ // Handle returned error from wait poll
+ if err == wait.ErrWaitTimeout {
+ err = fmt.Errorf("timed out trying to update RS: %+v", oldRs)
+ }
+ // Ignore the RS not found error, but the RS isn't updated.
+ if errors.IsNotFound(err) {
+ glog.V(4).Infof("%s %s/%s is not found, skip updating it.", oldRs.Kind, oldRs.Namespace, oldRs.Name)
+ err = nil
+ }
+ // Ignore the precondition violated error, but the RS isn't updated.
+ if err == errorsutil.ErrPreconditionViolated {
+ glog.V(4).Infof("%s %s/%s precondition doesn't hold, skip updating it.", oldRs.Kind, oldRs.Namespace, oldRs.Name)
+ err = nil
+ }
+
+ // If the error is non-nil the returned RS cannot be trusted; if rsUpdated is false, the contoller isn't updated;
+ // if the error is nil and rsUpdated is true, the returned RS contains the applied update.
+ return rs, rsUpdated, err
+}
+
+// GetPodTemplateSpecHash returns the pod template hash of a ReplicaSet's pod template space
+func GetPodTemplateSpecHash(rs extensions.ReplicaSet) string {
+ meta := rs.Spec.Template.ObjectMeta
+ meta.Labels = labelsutil.CloneAndRemoveLabel(meta.Labels, extensions.DefaultDeploymentUniqueLabelKey)
+ return fmt.Sprintf("%d", podutil.GetPodTemplateSpecHash(api.PodTemplateSpec{
+ ObjectMeta: meta,
+ Spec: rs.Spec.Template.Spec,
+ }))
+}
+
+// MatchingPodsFunc returns a filter function for pods with matching labels
+func MatchingPodsFunc(rs *extensions.ReplicaSet) (func(api.Pod) bool, error) {
+ if rs == nil {
+ return nil, nil
+ }
+ selector, err := unversioned.LabelSelectorAsSelector(rs.Spec.Selector)
+ if err != nil {
+ return nil, fmt.Errorf("invalid label selector: %v", err)
+ }
+ return func(pod api.Pod) bool {
+ podLabelsSelector := labels.Set(pod.ObjectMeta.Labels)
+ return selector.Matches(podLabelsSelector)
+ }, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/resource_container_linux.go b/vendor/k8s.io/kubernetes/pkg/util/resource_container_linux.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/resource_container_linux.go
rename to vendor/k8s.io/kubernetes/pkg/util/resource_container_linux.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/resource_container_unsupported.go b/vendor/k8s.io/kubernetes/pkg/util/resource_container_unsupported.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/resource_container_unsupported.go
rename to vendor/k8s.io/kubernetes/pkg/util/resource_container_unsupported.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/runner.go b/vendor/k8s.io/kubernetes/pkg/util/runner.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/runner.go
rename to vendor/k8s.io/kubernetes/pkg/util/runner.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/runtime/runtime.go b/vendor/k8s.io/kubernetes/pkg/util/runtime/runtime.go
similarity index 94%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/runtime/runtime.go
rename to vendor/k8s.io/kubernetes/pkg/util/runtime/runtime.go
index 32b1c710abfdae46bc35e5680d1e19daba9df60e..f404d25d194c66abe80db5ae67c09085d956a95d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/runtime/runtime.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/runtime/runtime.go
@@ -67,6 +67,11 @@ var ErrorHandlers = []func(error){logError}
// is preferable to logging the error - the default behavior is to log but the
// errors may be sent to a remote server for analysis.
func HandleError(err error) {
+ // this is sometimes called with a nil error. We probably shouldn't fail and should do nothing instead
+ if err == nil {
+ return
+ }
+
for _, fn := range ErrorHandlers {
fn(err)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/byte.go b/vendor/k8s.io/kubernetes/pkg/util/sets/byte.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/byte.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/byte.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/doc.go b/vendor/k8s.io/kubernetes/pkg/util/sets/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/empty.go b/vendor/k8s.io/kubernetes/pkg/util/sets/empty.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/empty.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/empty.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/int.go b/vendor/k8s.io/kubernetes/pkg/util/sets/int.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/int.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/int.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/int64.go b/vendor/k8s.io/kubernetes/pkg/util/sets/int64.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/int64.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/int64.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/string.go b/vendor/k8s.io/kubernetes/pkg/util/sets/string.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/sets/string.go
rename to vendor/k8s.io/kubernetes/pkg/util/sets/string.go
diff --git a/vendor/k8s.io/kubernetes/pkg/util/slice/slice.go b/vendor/k8s.io/kubernetes/pkg/util/slice/slice.go
new file mode 100644
index 0000000000000000000000000000000000000000..f32dbabcf41fc243e9f6ff44bb4dacd820e81237
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/slice/slice.go
@@ -0,0 +1,61 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 slice provides utility methods for common operations on slices.
+package slice
+
+import (
+ "sort"
+
+ utilrand "k8s.io/kubernetes/pkg/util/rand"
+)
+
+// CopyStrings copies the contents of the specified string slice
+// into a new slice.
+func CopyStrings(s []string) []string {
+ c := make([]string, len(s))
+ copy(c, s)
+ return c
+}
+
+// SortStrings sorts the specified string slice in place. It returns the same
+// slice that was provided in order to facilitate method chaining.
+func SortStrings(s []string) []string {
+ sort.Strings(s)
+ return s
+}
+
+// ShuffleStrings copies strings from the specified slice into a copy in random
+// order. It returns a new slice.
+func ShuffleStrings(s []string) []string {
+ shuffled := make([]string, len(s))
+ perm := utilrand.Perm(len(s))
+ for i, j := range perm {
+ shuffled[j] = s[i]
+ }
+ return shuffled
+}
+
+// Int64Slice attaches the methods of Interface to []int64,
+// sorting in increasing order.
+type Int64Slice []int64
+
+func (p Int64Slice) Len() int { return len(p) }
+func (p Int64Slice) Less(i, j int) bool { return p[i] < p[j] }
+func (p Int64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+
+// Sorts []int64 in increasing order
+func SortInts64(a []int64) { sort.Sort(Int64Slice(a)) }
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go b/vendor/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go
similarity index 99%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go
rename to vendor/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go
index effb8f9ae60d3640af8375e46e6efe580eb4b4c1..676713bc86affefd1307263f9d8da2aad1151b1d 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/strategicpatch/patch.go
@@ -17,11 +17,11 @@ limitations under the License.
package strategicpatch
import (
- "encoding/json"
"fmt"
"reflect"
"sort"
+ "k8s.io/kubernetes/pkg/util/json"
forkedjson "k8s.io/kubernetes/third_party/forked/json"
"github.com/davecgh/go-spew/spew"
@@ -432,7 +432,7 @@ loopB:
if !ignoreChangesAndAdditions {
// Add any remaining items found only in modified
for ; modifiedIndex < len(modifiedSorted); modifiedIndex++ {
- patch = append(patch, modified[modifiedIndex])
+ patch = append(patch, modifiedSorted[modifiedIndex])
}
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/string_flag.go b/vendor/k8s.io/kubernetes/pkg/util/string_flag.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/string_flag.go
rename to vendor/k8s.io/kubernetes/pkg/util/string_flag.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/template.go b/vendor/k8s.io/kubernetes/pkg/util/template.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/template.go
rename to vendor/k8s.io/kubernetes/pkg/util/template.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/trace.go b/vendor/k8s.io/kubernetes/pkg/util/trace.go
similarity index 85%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/trace.go
rename to vendor/k8s.io/kubernetes/pkg/util/trace.go
index a6b922345969e55098d2e2404a2d2975369ea3e8..ed9da94b32846ba71174e03049c0c68048a7c3aa 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/trace.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/trace.go
@@ -32,15 +32,19 @@ type traceStep struct {
type Trace struct {
name string
startTime time.Time
- steps []*traceStep
+ steps []traceStep
}
func NewTrace(name string) *Trace {
- return &Trace{name, time.Now(), make([]*traceStep, 0)}
+ return &Trace{name, time.Now(), nil}
}
func (t *Trace) Step(msg string) {
- t.steps = append(t.steps, &traceStep{time.Now(), msg})
+ if t.steps == nil {
+ // traces almost always have less than 6 steps, do this to avoid more than a single allocation
+ t.steps = make([]traceStep, 0, 6)
+ }
+ t.steps = append(t.steps, traceStep{time.Now(), msg})
}
func (t *Trace) Log() {
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/umask.go b/vendor/k8s.io/kubernetes/pkg/util/umask.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/umask.go
rename to vendor/k8s.io/kubernetes/pkg/util/umask.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/umask_windows.go b/vendor/k8s.io/kubernetes/pkg/util/umask_windows.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/umask_windows.go
rename to vendor/k8s.io/kubernetes/pkg/util/umask_windows.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/util.go b/vendor/k8s.io/kubernetes/pkg/util/util.go
similarity index 92%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/util.go
rename to vendor/k8s.io/kubernetes/pkg/util/util.go
index 29284b2060dcf8839bf85e73848acc84e75753b5..4826a448b144ddc92c3a61bbc9cd21f1a4ff548b 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/util.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/util.go
@@ -122,6 +122,12 @@ func IntPtr(i int) *int {
return &o
}
+// Int32Ptr returns a pointer to an int32
+func Int32Ptr(i int32) *int32 {
+ o := i
+ return &o
+}
+
// IntPtrDerefOr dereference the int ptr and returns it i not nil,
// else returns def.
func IntPtrDerefOr(ptr *int, def int) int {
@@ -130,3 +136,12 @@ func IntPtrDerefOr(ptr *int, def int) int {
}
return def
}
+
+// Int32PtrDerefOr dereference the int32 ptr and returns it i not nil,
+// else returns def.
+func Int32PtrDerefOr(ptr *int32, def int32) int32 {
+ if ptr != nil {
+ return *ptr
+ }
+ return def
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/uuid.go b/vendor/k8s.io/kubernetes/pkg/util/uuid.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/uuid.go
rename to vendor/k8s.io/kubernetes/pkg/util/uuid.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/field/errors.go b/vendor/k8s.io/kubernetes/pkg/util/validation/field/errors.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/field/errors.go
rename to vendor/k8s.io/kubernetes/pkg/util/validation/field/errors.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/field/path.go b/vendor/k8s.io/kubernetes/pkg/util/validation/field/path.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/field/path.go
rename to vendor/k8s.io/kubernetes/pkg/util/validation/field/path.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/validation.go b/vendor/k8s.io/kubernetes/pkg/util/validation/validation.go
similarity index 55%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/validation.go
rename to vendor/k8s.io/kubernetes/pkg/util/validation/validation.go
index 9607293b7f03fdb61b29dffee2963f6339eed19a..9361a4bfacb9333bd9969a76d001ea968a99ecbe 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/validation/validation.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/validation/validation.go
@@ -17,6 +17,7 @@ limitations under the License.
package validation
import (
+ "fmt"
"math"
"net"
"regexp"
@@ -25,12 +26,17 @@ import (
const qnameCharFmt string = "[A-Za-z0-9]"
const qnameExtCharFmt string = "[-A-Za-z0-9_.]"
-const QualifiedNameFmt string = "(" + qnameCharFmt + qnameExtCharFmt + "*)?" + qnameCharFmt
-const QualifiedNameMaxLength int = 63
+const qualifiedNameFmt string = "(" + qnameCharFmt + qnameExtCharFmt + "*)?" + qnameCharFmt
+const qualifiedNameMaxLength int = 63
-var qualifiedNameRegexp = regexp.MustCompile("^" + QualifiedNameFmt + "$")
+var qualifiedNameRegexp = regexp.MustCompile("^" + qualifiedNameFmt + "$")
-func IsQualifiedName(value string) bool {
+// IsQualifiedName tests whether the value passed is what Kubernetes calls a
+// "qualified name". This is a format used in various places throughout the
+// system. If the value is not valid, a list of error strings is returned.
+// Otherwise an empty list (or nil) is returned.
+func IsQualifiedName(value string) []string {
+ var errs []string
parts := strings.Split(value, "/")
var name string
switch len(parts) {
@@ -39,23 +45,44 @@ func IsQualifiedName(value string) bool {
case 2:
var prefix string
prefix, name = parts[0], parts[1]
- if prefix == "" || !IsDNS1123Subdomain(prefix) {
- return false
+ if len(prefix) == 0 {
+ errs = append(errs, "prefix part "+EmptyError())
+ } else if msgs := IsDNS1123Subdomain(prefix); len(msgs) != 0 {
+ errs = append(errs, prefixEach(msgs, "prefix part ")...)
}
default:
- return false
+ return append(errs, RegexError(qualifiedNameFmt, "MyName", "my.name", "123-abc")+
+ " with an optional DNS subdomain prefix and '/' (e.g. 'example.com/MyName'")
}
- return name != "" && len(name) <= QualifiedNameMaxLength && qualifiedNameRegexp.MatchString(name)
+ if len(name) == 0 {
+ errs = append(errs, "name part "+EmptyError())
+ } else if len(name) > qualifiedNameMaxLength {
+ errs = append(errs, "name part "+MaxLenError(qualifiedNameMaxLength))
+ }
+ if !qualifiedNameRegexp.MatchString(name) {
+ errs = append(errs, "name part "+RegexError(qualifiedNameFmt, "MyName", "my.name", "123-abc"))
+ }
+ return errs
}
-const LabelValueFmt string = "(" + QualifiedNameFmt + ")?"
+const labelValueFmt string = "(" + qualifiedNameFmt + ")?"
const LabelValueMaxLength int = 63
-var labelValueRegexp = regexp.MustCompile("^" + LabelValueFmt + "$")
+var labelValueRegexp = regexp.MustCompile("^" + labelValueFmt + "$")
-func IsValidLabelValue(value string) bool {
- return (len(value) <= LabelValueMaxLength && labelValueRegexp.MatchString(value))
+// IsValidLabelValue tests whether the value passed is a valid label value. If
+// the value is not valid, a list of error strings is returned. Otherwise an
+// empty list (or nil) is returned.
+func IsValidLabelValue(value string) []string {
+ var errs []string
+ if len(value) > LabelValueMaxLength {
+ errs = append(errs, MaxLenError(LabelValueMaxLength))
+ }
+ if !labelValueRegexp.MatchString(value) {
+ errs = append(errs, RegexError(labelValueFmt, "MyValue", "my_value", "12345"))
+ }
+ return errs
}
const DNS1123LabelFmt string = "[a-z0-9]([-a-z0-9]*[a-z0-9])?"
@@ -65,8 +92,15 @@ var dns1123LabelRegexp = regexp.MustCompile("^" + DNS1123LabelFmt + "$")
// IsDNS1123Label tests for a string that conforms to the definition of a label in
// DNS (RFC 1123).
-func IsDNS1123Label(value string) bool {
- return len(value) <= DNS1123LabelMaxLength && dns1123LabelRegexp.MatchString(value)
+func IsDNS1123Label(value string) []string {
+ var errs []string
+ if len(value) > DNS1123LabelMaxLength {
+ errs = append(errs, MaxLenError(DNS1123LabelMaxLength))
+ }
+ if !dns1123LabelRegexp.MatchString(value) {
+ errs = append(errs, RegexError(DNS1123LabelFmt, "my-name", "123-abc"))
+ }
+ return errs
}
const DNS1123SubdomainFmt string = DNS1123LabelFmt + "(\\." + DNS1123LabelFmt + ")*"
@@ -76,8 +110,15 @@ var dns1123SubdomainRegexp = regexp.MustCompile("^" + DNS1123SubdomainFmt + "$")
// IsDNS1123Subdomain tests for a string that conforms to the definition of a
// subdomain in DNS (RFC 1123).
-func IsDNS1123Subdomain(value string) bool {
- return len(value) <= DNS1123SubdomainMaxLength && dns1123SubdomainRegexp.MatchString(value)
+func IsDNS1123Subdomain(value string) []string {
+ var errs []string
+ if len(value) > DNS1123SubdomainMaxLength {
+ errs = append(errs, MaxLenError(DNS1123SubdomainMaxLength))
+ }
+ if !dns1123SubdomainRegexp.MatchString(value) {
+ errs = append(errs, RegexError(DNS1123SubdomainFmt, "example.com"))
+ }
+ return errs
}
const DNS952LabelFmt string = "[a-z]([-a-z0-9]*[a-z0-9])?"
@@ -87,8 +128,15 @@ var dns952LabelRegexp = regexp.MustCompile("^" + DNS952LabelFmt + "$")
// IsDNS952Label tests for a string that conforms to the definition of a label in
// DNS (RFC 952).
-func IsDNS952Label(value string) bool {
- return len(value) <= DNS952LabelMaxLength && dns952LabelRegexp.MatchString(value)
+func IsDNS952Label(value string) []string {
+ var errs []string
+ if len(value) > DNS952LabelMaxLength {
+ errs = append(errs, MaxLenError(DNS952LabelMaxLength))
+ }
+ if !dns952LabelRegexp.MatchString(value) {
+ errs = append(errs, RegexError(DNS952LabelFmt, "my-name", "abc-123"))
+ }
+ return errs
}
const CIdentifierFmt string = "[A-Za-z_][A-Za-z0-9_]*"
@@ -155,9 +203,9 @@ func IsValidPortName(port string) bool {
return false
}
-// IsValidIPv4 tests that the argument is a valid IPv4 address.
-func IsValidIPv4(value string) bool {
- return net.ParseIP(value) != nil && net.ParseIP(value).To4() != nil
+// IsValidIP tests that the argument is a valid IP address.
+func IsValidIP(value string) bool {
+ return net.ParseIP(value) != nil
}
const percentFmt string = "[0-9]+%"
@@ -177,3 +225,38 @@ var httpHeaderNameRegexp = regexp.MustCompile("^" + HTTPHeaderNameFmt + "$")
func IsHTTPHeaderName(value string) bool {
return httpHeaderNameRegexp.MatchString(value)
}
+
+// MaxLenError returns a string explanation of a "string too long" validation
+// failure.
+func MaxLenError(length int) string {
+ return fmt.Sprintf("must be no more than %d characters", length)
+}
+
+// RegexError returns a string explanation of a regex validation failure.
+func RegexError(fmt string, examples ...string) string {
+ s := "must match the regex " + fmt
+ if len(examples) == 0 {
+ return s
+ }
+ s += " (e.g. "
+ for i := range examples {
+ if i > 0 {
+ s += " or "
+ }
+ s += "'" + examples[i] + "'"
+ }
+ return s + ")"
+}
+
+// EmptyError returns a string explanation of a "must not be empty" validation
+// failure.
+func EmptyError() string {
+ return "must be non-empty"
+}
+
+func prefixEach(msgs []string, prefix string) []string {
+ for i := range msgs {
+ msgs[i] = prefix + msgs[i]
+ }
+ return msgs
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/wait/doc.go b/vendor/k8s.io/kubernetes/pkg/util/wait/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/wait/doc.go
rename to vendor/k8s.io/kubernetes/pkg/util/wait/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/wait/wait.go b/vendor/k8s.io/kubernetes/pkg/util/wait/wait.go
similarity index 87%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/wait/wait.go
rename to vendor/k8s.io/kubernetes/pkg/util/wait/wait.go
index 31c81b6c27cb9f0bcf6147a2156018a53e882d8d..b56560e75c27d5bb0ccf472ec2c1528e3b3c91c2 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/wait/wait.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/wait/wait.go
@@ -42,9 +42,19 @@ func Forever(f func(), period time.Duration) {
}
// Until loops until stop channel is closed, running f every period.
-// Until is syntactic sugar on top of JitterUntil with zero jitter factor
+// Until is syntactic sugar on top of JitterUntil with zero jitter
+// factor, with sliding = true (which means the timer for period
+// starts after the f completes).
func Until(f func(), period time.Duration, stopCh <-chan struct{}) {
- JitterUntil(f, period, 0.0, stopCh)
+ JitterUntil(f, period, 0.0, true, stopCh)
+}
+
+// NonSlidingUntil loops until stop channel is closed, running f every
+// period. NonSlidingUntil is syntactic sugar on top of JitterUntil
+// with zero jitter factor, with sliding = false (meaning the timer for
+// period starts at the same time as the function starts).
+func NonSlidingUntil(f func(), period time.Duration, stopCh <-chan struct{}) {
+ JitterUntil(f, period, 0.0, false, stopCh)
}
// JitterUntil loops until stop channel is closed, running f every period.
@@ -53,7 +63,7 @@ func Until(f func(), period time.Duration, stopCh <-chan struct{}) {
// Catches any panics, and keeps going. f may not be invoked if
// stop channel is already closed. Pass NeverStop to Until if you
// don't want it stop.
-func JitterUntil(f func(), period time.Duration, jitterFactor float64, stopCh <-chan struct{}) {
+func JitterUntil(f func(), period time.Duration, jitterFactor float64, sliding bool, stopCh <-chan struct{}) {
select {
case <-stopCh:
return
@@ -61,20 +71,37 @@ func JitterUntil(f func(), period time.Duration, jitterFactor float64, stopCh <-
}
for {
+ jitteredPeriod := period
+ if jitterFactor > 0.0 {
+ jitteredPeriod = Jitter(period, jitterFactor)
+ }
+
+ var t *time.Timer
+ if !sliding {
+ t = time.NewTimer(jitteredPeriod)
+ }
+
func() {
defer runtime.HandleCrash()
f()
}()
- jitteredPeriod := period
- if jitterFactor > 0.0 {
- jitteredPeriod = Jitter(period, jitterFactor)
+ if sliding {
+ t = time.NewTimer(jitteredPeriod)
+ } else {
+ // The timer we created could already have fired, so be
+ // careful and check stopCh first.
+ select {
+ case <-stopCh:
+ return
+ default:
+ }
}
select {
case <-stopCh:
return
- case <-time.After(jitteredPeriod):
+ case <-t.C:
}
}
}
@@ -143,6 +170,8 @@ func pollInternal(wait WaitFunc, condition ConditionFunc) error {
return WaitFor(wait, condition, done)
}
+// PollImmediate is identical to Poll, except that it performs the first check
+// immediately, not waiting interval beforehand.
func PollImmediate(interval, timeout time.Duration, condition ConditionFunc) error {
return pollImmediateInternal(poller(interval, timeout), condition)
}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/wsstream/conn.go b/vendor/k8s.io/kubernetes/pkg/util/wsstream/conn.go
new file mode 100644
index 0000000000000000000000000000000000000000..84e619671687b95bfc9e0f245d685d1717133b21
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/wsstream/conn.go
@@ -0,0 +1,318 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 wsstream
+
+import (
+ "encoding/base64"
+ "fmt"
+ "io"
+ "net/http"
+ "regexp"
+ "strings"
+ "time"
+
+ "github.com/golang/glog"
+ "golang.org/x/net/websocket"
+ "k8s.io/kubernetes/pkg/util/runtime"
+)
+
+// The Websocket subprotocol "channel.k8s.io" prepends each binary message with a byte indicating
+// the channel number (zero indexed) the message was sent on. Messages in both directions should
+// prefix their messages with this channel byte. When used for remote execution, the channel numbers
+// are by convention defined to match the POSIX file-descriptors assigned to STDIN, STDOUT, and STDERR
+// (0, 1, and 2). No other conversion is performed on the raw subprotocol - writes are sent as they
+// are received by the server.
+//
+// Example client session:
+//
+// CONNECT http://server.com with subprotocol "channel.k8s.io"
+// WRITE []byte{0, 102, 111, 111, 10} # send "foo\n" on channel 0 (STDIN)
+// READ []byte{1, 10} # receive "\n" on channel 1 (STDOUT)
+// CLOSE
+//
+const channelWebSocketProtocol = "channel.k8s.io"
+
+// The Websocket subprotocol "base64.channel.k8s.io" base64 encodes each message with a character
+// indicating the channel number (zero indexed) the message was sent on. Messages in both directions
+// should prefix their messages with this channel char. When used for remote execution, the channel
+// numbers are by convention defined to match the POSIX file-descriptors assigned to STDIN, STDOUT,
+// and STDERR ('0', '1', and '2'). The data received on the server is base64 decoded (and must be
+// be valid) and data written by the server to the client is base64 encoded.
+//
+// Example client session:
+//
+// CONNECT http://server.com with subprotocol "base64.channel.k8s.io"
+// WRITE []byte{48, 90, 109, 57, 118, 67, 103, 111, 61} # send "foo\n" (base64: "Zm9vCgo=") on channel '0' (STDIN)
+// READ []byte{49, 67, 103, 61, 61} # receive "\n" (base64: "Cg==") on channel '1' (STDOUT)
+// CLOSE
+//
+const base64ChannelWebSocketProtocol = "base64.channel.k8s.io"
+
+type codecType int
+
+const (
+ rawCodec codecType = iota
+ base64Codec
+)
+
+type ChannelType int
+
+const (
+ IgnoreChannel ChannelType = iota
+ ReadChannel
+ WriteChannel
+ ReadWriteChannel
+)
+
+var (
+ // connectionUpgradeRegex matches any Connection header value that includes upgrade
+ connectionUpgradeRegex = regexp.MustCompile("(^|.*,\\s*)upgrade($|\\s*,)")
+)
+
+// IsWebSocketRequest returns true if the incoming request contains connection upgrade headers
+// for WebSockets.
+func IsWebSocketRequest(req *http.Request) bool {
+ return connectionUpgradeRegex.MatchString(strings.ToLower(req.Header.Get("Connection"))) && strings.ToLower(req.Header.Get("Upgrade")) == "websocket"
+}
+
+// IgnoreReceives reads from a WebSocket until it is closed, then returns. If timeout is set, the
+// read and write deadlines are pushed every time a new message is received.
+func IgnoreReceives(ws *websocket.Conn, timeout time.Duration) {
+ defer runtime.HandleCrash()
+ var data []byte
+ for {
+ resetTimeout(ws, timeout)
+ if err := websocket.Message.Receive(ws, &data); err != nil {
+ return
+ }
+ }
+}
+
+// handshake ensures the provided user protocol matches one of the allowed protocols. It returns
+// no error if no protocol is specified.
+func handshake(config *websocket.Config, req *http.Request, allowed []string) error {
+ protocols := config.Protocol
+ if len(protocols) == 0 {
+ return nil
+ }
+ for _, protocol := range protocols {
+ for _, allow := range allowed {
+ if allow == protocol {
+ config.Protocol = []string{protocol}
+ return nil
+ }
+ }
+ }
+ return fmt.Errorf("requested protocol(s) are not supported: %v; supports %v", config.Protocol, allowed)
+}
+
+// Conn supports sending multiple binary channels over a websocket connection.
+// Supports only the "channel.k8s.io" subprotocol.
+type Conn struct {
+ channels []*websocketChannel
+ codec codecType
+ ready chan struct{}
+ ws *websocket.Conn
+ timeout time.Duration
+}
+
+// NewConn creates a WebSocket connection that supports a set of channels. Channels begin each
+// web socket message with a single byte indicating the channel number (0-N). 255 is reserved for
+// future use. The channel types for each channel are passed as an array, supporting the different
+// duplex modes. Read and Write refer to whether the channel can be used as a Reader or Writer.
+func NewConn(channels ...ChannelType) *Conn {
+ conn := &Conn{
+ ready: make(chan struct{}),
+ channels: make([]*websocketChannel, len(channels)),
+ }
+ for i := range conn.channels {
+ switch channels[i] {
+ case ReadChannel:
+ conn.channels[i] = newWebsocketChannel(conn, byte(i), true, false)
+ case WriteChannel:
+ conn.channels[i] = newWebsocketChannel(conn, byte(i), false, true)
+ case ReadWriteChannel:
+ conn.channels[i] = newWebsocketChannel(conn, byte(i), true, true)
+ case IgnoreChannel:
+ conn.channels[i] = newWebsocketChannel(conn, byte(i), false, false)
+ }
+ }
+ return conn
+}
+
+// SetIdleTimeout sets the interval for both reads and writes before timeout. If not specified,
+// there is no timeout on the connection.
+func (conn *Conn) SetIdleTimeout(duration time.Duration) {
+ conn.timeout = duration
+}
+
+// Open the connection and create channels for reading and writing.
+func (conn *Conn) Open(w http.ResponseWriter, req *http.Request) ([]io.ReadWriteCloser, error) {
+ go func() {
+ defer runtime.HandleCrash()
+ defer conn.Close()
+ websocket.Server{Handshake: conn.handshake, Handler: conn.handle}.ServeHTTP(w, req)
+ }()
+ <-conn.ready
+ rwc := make([]io.ReadWriteCloser, len(conn.channels))
+ for i := range conn.channels {
+ rwc[i] = conn.channels[i]
+ }
+ return rwc, nil
+}
+
+func (conn *Conn) initialize(ws *websocket.Conn) {
+ protocols := ws.Config().Protocol
+ switch {
+ case len(protocols) == 0, protocols[0] == channelWebSocketProtocol:
+ conn.codec = rawCodec
+ case protocols[0] == base64ChannelWebSocketProtocol:
+ conn.codec = base64Codec
+ }
+ conn.ws = ws
+ close(conn.ready)
+}
+
+func (conn *Conn) handshake(config *websocket.Config, req *http.Request) error {
+ return handshake(config, req, []string{channelWebSocketProtocol, base64ChannelWebSocketProtocol})
+}
+
+func (conn *Conn) resetTimeout() {
+ if conn.timeout > 0 {
+ conn.ws.SetDeadline(time.Now().Add(conn.timeout))
+ }
+}
+
+// Close is only valid after Open has been called
+func (conn *Conn) Close() error {
+ <-conn.ready
+ for _, s := range conn.channels {
+ s.Close()
+ }
+ conn.ws.Close()
+ return nil
+}
+
+// handle implements a websocket handler.
+func (conn *Conn) handle(ws *websocket.Conn) {
+ defer conn.Close()
+ conn.initialize(ws)
+
+ for {
+ conn.resetTimeout()
+ var data []byte
+ if err := websocket.Message.Receive(ws, &data); err != nil {
+ if err != io.EOF {
+ glog.Errorf("Error on socket receive: %v", err)
+ }
+ break
+ }
+ if len(data) == 0 {
+ continue
+ }
+ channel := data[0]
+ if conn.codec == base64Codec {
+ channel = channel - '0'
+ }
+ data = data[1:]
+ if int(channel) >= len(conn.channels) {
+ glog.V(6).Infof("Frame is targeted for a reader %d that is not valid, possible protocol error", channel)
+ continue
+ }
+ if _, err := conn.channels[channel].DataFromSocket(data); err != nil {
+ glog.Errorf("Unable to write frame to %d: %v\n%s", channel, err, string(data))
+ continue
+ }
+ }
+}
+
+// write multiplexes the specified channel onto the websocket
+func (conn *Conn) write(num byte, data []byte) (int, error) {
+ conn.resetTimeout()
+ switch conn.codec {
+ case rawCodec:
+ frame := make([]byte, len(data)+1)
+ frame[0] = num
+ copy(frame[1:], data)
+ if err := websocket.Message.Send(conn.ws, frame); err != nil {
+ return 0, err
+ }
+ case base64Codec:
+ frame := string('0'+num) + base64.StdEncoding.EncodeToString(data)
+ if err := websocket.Message.Send(conn.ws, frame); err != nil {
+ return 0, err
+ }
+ }
+ return len(data), nil
+}
+
+// websocketChannel represents a channel in a connection
+type websocketChannel struct {
+ conn *Conn
+ num byte
+ r io.Reader
+ w io.WriteCloser
+
+ read, write bool
+}
+
+// newWebsocketChannel creates a pipe for writing to a websocket. Do not write to this pipe
+// prior to the connection being opened. It may be no, half, or full duplex depending on
+// read and write.
+func newWebsocketChannel(conn *Conn, num byte, read, write bool) *websocketChannel {
+ r, w := io.Pipe()
+ return &websocketChannel{conn, num, r, w, read, write}
+}
+
+func (p *websocketChannel) Write(data []byte) (int, error) {
+ if !p.write {
+ return len(data), nil
+ }
+ return p.conn.write(p.num, data)
+}
+
+// DataFromSocket is invoked by the connection receiver to move data from the connection
+// into a specific channel.
+func (p *websocketChannel) DataFromSocket(data []byte) (int, error) {
+ if !p.read {
+ return len(data), nil
+ }
+
+ switch p.conn.codec {
+ case rawCodec:
+ return p.w.Write(data)
+ case base64Codec:
+ dst := make([]byte, len(data))
+ n, err := base64.StdEncoding.Decode(dst, data)
+ if err != nil {
+ return 0, err
+ }
+ return p.w.Write(dst[:n])
+ }
+ return 0, nil
+}
+
+func (p *websocketChannel) Read(data []byte) (int, error) {
+ if !p.read {
+ return 0, io.EOF
+ }
+ return p.r.Read(data)
+}
+
+func (p *websocketChannel) Close() error {
+ return p.w.Close()
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.go b/vendor/k8s.io/kubernetes/pkg/util/wsstream/doc.go
similarity index 66%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.go
rename to vendor/k8s.io/kubernetes/pkg/util/wsstream/doc.go
index 1207116fc3d626f32c4a484bee8c58f76bbfbc1b..e94e8b271cd75c12ef147d10bafbbbfdcefa1c61 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/metrics/types.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/wsstream/doc.go
@@ -14,16 +14,8 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package metrics
-
-import "k8s.io/kubernetes/pkg/api/unversioned"
-
-// Placeholder top-level node resource metrics.
-type RawNode struct {
- unversioned.TypeMeta `json:",inline"`
-}
-
-// Placeholder top-level pod resource metrics.
-type RawPod struct {
- unversioned.TypeMeta `json:",inline"`
-}
+// Package wsstream contains utilities for streaming content over WebSockets.
+// The Conn type allows callers to multiplex multiple read/write channels over
+// a single websocket. The Reader type allows an io.Reader to be copied over
+// a websocket channel as binary content.
+package wsstream
diff --git a/vendor/k8s.io/kubernetes/pkg/util/wsstream/stream.go b/vendor/k8s.io/kubernetes/pkg/util/wsstream/stream.go
new file mode 100644
index 0000000000000000000000000000000000000000..034c1216e02d1536dbb5a695c43d45fae781969d
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/util/wsstream/stream.go
@@ -0,0 +1,124 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 wsstream
+
+import (
+ "encoding/base64"
+ "io"
+ "net/http"
+ "time"
+
+ "golang.org/x/net/websocket"
+ "k8s.io/kubernetes/pkg/util/runtime"
+)
+
+// The WebSocket subprotocol "binary.k8s.io" will only send messages to the
+// client and ignore messages sent to the server. The received messages are
+// the exact bytes written to the stream. Zero byte messages are possible.
+const binaryWebSocketProtocol = "binary.k8s.io"
+
+// The WebSocket subprotocol "base64.binary.k8s.io" will only send messages to the
+// client and ignore messages sent to the server. The received messages are
+// a base64 version of the bytes written to the stream. Zero byte messages are
+// possible.
+const base64BinaryWebSocketProtocol = "base64.binary.k8s.io"
+
+// Reader supports returning an arbitrary byte stream over a websocket channel.
+// Supports the "binary.k8s.io" and "base64.binary.k8s.io" subprotocols.
+type Reader struct {
+ err chan error
+ r io.Reader
+ ping bool
+ timeout time.Duration
+}
+
+// NewReader creates a WebSocket pipe that will copy the contents of r to a provided
+// WebSocket connection. If ping is true, a zero length message will be sent to the client
+// before the stream begins reading.
+func NewReader(r io.Reader, ping bool) *Reader {
+ return &Reader{
+ r: r,
+ err: make(chan error),
+ ping: ping,
+ }
+}
+
+// SetIdleTimeout sets the interval for both reads and writes before timeout. If not specified,
+// there is no timeout on the reader.
+func (r *Reader) SetIdleTimeout(duration time.Duration) {
+ r.timeout = duration
+}
+
+func (r *Reader) handshake(config *websocket.Config, req *http.Request) error {
+ return handshake(config, req, []string{binaryWebSocketProtocol, base64BinaryWebSocketProtocol})
+}
+
+// Copy the reader to the response. The created WebSocket is closed after this
+// method completes.
+func (r *Reader) Copy(w http.ResponseWriter, req *http.Request) error {
+ go func() {
+ defer runtime.HandleCrash()
+ websocket.Server{Handshake: r.handshake, Handler: r.handle}.ServeHTTP(w, req)
+ }()
+ return <-r.err
+}
+
+// handle implements a WebSocket handler.
+func (r *Reader) handle(ws *websocket.Conn) {
+ encode := len(ws.Config().Protocol) > 0 && ws.Config().Protocol[0] == base64BinaryWebSocketProtocol
+ defer close(r.err)
+ defer ws.Close()
+ go IgnoreReceives(ws, r.timeout)
+ r.err <- messageCopy(ws, r.r, encode, r.ping, r.timeout)
+}
+
+func resetTimeout(ws *websocket.Conn, timeout time.Duration) {
+ if timeout > 0 {
+ ws.SetDeadline(time.Now().Add(timeout))
+ }
+}
+
+func messageCopy(ws *websocket.Conn, r io.Reader, base64Encode, ping bool, timeout time.Duration) error {
+ buf := make([]byte, 2048)
+ if ping {
+ resetTimeout(ws, timeout)
+ if err := websocket.Message.Send(ws, []byte{}); err != nil {
+ return err
+ }
+ }
+ for {
+ resetTimeout(ws, timeout)
+ n, err := r.Read(buf)
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ if n > 0 {
+ if base64Encode {
+ if err := websocket.Message.Send(ws, base64.StdEncoding.EncodeToString(buf[:n])); err != nil {
+ return err
+ }
+ } else {
+ if err := websocket.Message.Send(ws, buf[:n]); err != nil {
+ return err
+ }
+ }
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/yaml/decoder.go b/vendor/k8s.io/kubernetes/pkg/util/yaml/decoder.go
similarity index 71%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/yaml/decoder.go
rename to vendor/k8s.io/kubernetes/pkg/util/yaml/decoder.go
index 5846fc20ff460acdd48b729f3c72319905b4f4f7..a48a6ce864d2d1ba713a86c84ad051c0e10999af 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/yaml/decoder.go
+++ b/vendor/k8s.io/kubernetes/pkg/util/yaml/decoder.go
@@ -20,7 +20,10 @@ import (
"bufio"
"bytes"
"encoding/json"
+ "fmt"
"io"
+ "io/ioutil"
+ "strings"
"unicode"
"github.com/ghodss/yaml"
@@ -75,6 +78,64 @@ func (d *YAMLToJSONDecoder) Decode(into interface{}) error {
return err
}
+// YAMLDecoder reads chunks of objects and returns ErrShortBuffer if
+// the data is not sufficient.
+type YAMLDecoder struct {
+ r io.ReadCloser
+ scanner *bufio.Scanner
+ remaining []byte
+}
+
+// NewDocumentDecoder decodes YAML documents from the provided
+// stream in chunks by converting each document (as defined by
+// the YAML spec) into its own chunk. io.ErrShortBuffer will be
+// returned if the entire buffer could not be read to assist
+// the caller in framing the chunk.
+func NewDocumentDecoder(r io.ReadCloser) io.ReadCloser {
+ scanner := bufio.NewScanner(r)
+ scanner.Split(splitYAMLDocument)
+ return &YAMLDecoder{
+ r: r,
+ scanner: scanner,
+ }
+}
+
+// Read reads the previous slice into the buffer, or attempts to read
+// the next chunk.
+// TODO: switch to readline approach.
+func (d *YAMLDecoder) Read(data []byte) (n int, err error) {
+ left := len(d.remaining)
+ if left == 0 {
+ // return the next chunk from the stream
+ if !d.scanner.Scan() {
+ err := d.scanner.Err()
+ if err == nil {
+ err = io.EOF
+ }
+ return 0, err
+ }
+ out := d.scanner.Bytes()
+ d.remaining = out
+ left = len(out)
+ }
+
+ // fits within data
+ if left <= len(data) {
+ copy(data, d.remaining)
+ d.remaining = nil
+ return len(d.remaining), nil
+ }
+
+ // caller will need to reread
+ copy(data, d.remaining[:left])
+ d.remaining = d.remaining[left:]
+ return len(data), io.ErrShortBuffer
+}
+
+func (d *YAMLDecoder) Close() error {
+ return d.r.Close()
+}
+
const yamlSeparator = "\n---"
// splitYAMLDocument is a bufio.SplitFunc for splitting YAML streams into individual documents.
@@ -145,7 +206,20 @@ func (d *YAMLOrJSONDecoder) Decode(into interface{}) error {
d.decoder = NewYAMLToJSONDecoder(buffer)
}
}
- return d.decoder.Decode(into)
+ err := d.decoder.Decode(into)
+ if jsonDecoder, ok := d.decoder.(*json.Decoder); ok {
+ if syntax, ok := err.(*json.SyntaxError); ok {
+ data, readErr := ioutil.ReadAll(jsonDecoder.Buffered())
+ if readErr != nil {
+ glog.V(4).Infof("reading stream failed: %v", readErr)
+ }
+ js := string(data)
+ start := strings.LastIndex(js[:syntax.Offset], "\n") + 1
+ line := strings.Count(js[:start], "\n")
+ return fmt.Errorf("json: line %d: %s", line, syntax.Error())
+ }
+ }
+ return err
}
// GuessJSONStream scans the provided reader up to size, looking
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/.gitattributes b/vendor/k8s.io/kubernetes/pkg/version/.gitattributes
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/.gitattributes
rename to vendor/k8s.io/kubernetes/pkg/version/.gitattributes
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/base.go b/vendor/k8s.io/kubernetes/pkg/version/base.go
similarity index 91%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/base.go
rename to vendor/k8s.io/kubernetes/pkg/version/base.go
index fb21180681141b98c86e092f7f0b862861e59046..95fe9e94fa585e2342338a7d9134a0c56f1af02e 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/base.go
+++ b/vendor/k8s.io/kubernetes/pkg/version/base.go
@@ -40,7 +40,7 @@ var (
// scripts consuming the kubectl version output - but most of
// these should be looking at gitVersion already anyways.)
gitMajor string = "1" // major version, always numeric
- gitMinor string = "2" // minor version, numeric possibly followed by "+"
+ gitMinor string = "3" // minor version, numeric possibly followed by "+"
// semantic version, dervied by build scripts (see
// https://github.com/kubernetes/kubernetes/blob/master/docs/design/versioning.md
@@ -51,7 +51,9 @@ var (
// semantic version is a git hash, but the version itself is no
// longer the direct output of "git describe", but a slight
// translation to be semver compliant.
- gitVersion string = "v1.2.4+$Format:%h$"
+ gitVersion string = "v1.3.0+$Format:%h$"
gitCommit string = "$Format:%H$" // sha1 from git, output of $(git rev-parse HEAD)
gitTreeState string = "not a git tree" // state of git tree, either "clean" or "dirty"
+
+ buildDate string = "1970-01-01T00:00:00Z" // build date in ISO8601 format, output of $(date -u +'%Y-%m-%dT%H:%M:%SZ')
)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/doc.go b/vendor/k8s.io/kubernetes/pkg/version/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/doc.go
rename to vendor/k8s.io/kubernetes/pkg/version/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/semver.go b/vendor/k8s.io/kubernetes/pkg/version/semver.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/semver.go
rename to vendor/k8s.io/kubernetes/pkg/version/semver.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/version.go b/vendor/k8s.io/kubernetes/pkg/version/version.go
similarity index 72%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/version.go
rename to vendor/k8s.io/kubernetes/pkg/version/version.go
index e337abe4baacc12b3ba9bfe047076c41aae34fe9..b8ac0d6c35f32a85649a77f295651b3317f3b761 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/version/version.go
+++ b/vendor/k8s.io/kubernetes/pkg/version/version.go
@@ -16,7 +16,12 @@ limitations under the License.
package version
-import "github.com/prometheus/client_golang/prometheus"
+import (
+ "fmt"
+ "runtime"
+
+ "github.com/prometheus/client_golang/prometheus"
+)
// Info contains versioning information.
// TODO: Add []string of api versions supported? It's still unclear
@@ -27,6 +32,10 @@ type Info struct {
GitVersion string `json:"gitVersion"`
GitCommit string `json:"gitCommit"`
GitTreeState string `json:"gitTreeState"`
+ BuildDate string `json:"buildDate"`
+ GoVersion string `json:"goVersion"`
+ Compiler string `json:"compiler"`
+ Platform string `json:"platform"`
}
// Get returns the overall codebase version. It's for detecting
@@ -40,6 +49,10 @@ func Get() Info {
GitVersion: gitVersion,
GitCommit: gitCommit,
GitTreeState: gitTreeState,
+ BuildDate: buildDate,
+ GoVersion: runtime.Version(),
+ Compiler: runtime.Compiler,
+ Platform: fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH),
}
}
@@ -52,12 +65,12 @@ func init() {
buildInfo := prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "kubernetes_build_info",
- Help: "A metric with a constant '1' value labeled by major, minor, git version, git commit and git tree state from which Kubernetes was built.",
+ Help: "A metric with a constant '1' value labeled by major, minor, git version, git commit, git tree state, build date, Go version, and compiler from which Kubernetes was built, and platform on which it is running.",
},
- []string{"major", "minor", "gitVersion", "gitCommit", "gitTreeState"},
+ []string{"major", "minor", "gitVersion", "gitCommit", "gitTreeState", "buildDate", "goVersion", "compiler", "platform"},
)
info := Get()
- buildInfo.WithLabelValues(info.Major, info.Minor, info.GitVersion, info.GitCommit, info.GitTreeState).Set(1)
+ buildInfo.WithLabelValues(info.Major, info.Minor, info.GitVersion, info.GitCommit, info.GitTreeState, info.BuildDate, info.GoVersion, info.Compiler, info.Platform).Set(1)
prometheus.MustRegister(buildInfo)
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/doc.go b/vendor/k8s.io/kubernetes/pkg/watch/doc.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/doc.go
rename to vendor/k8s.io/kubernetes/pkg/watch/doc.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/filter.go b/vendor/k8s.io/kubernetes/pkg/watch/filter.go
similarity index 71%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/filter.go
rename to vendor/k8s.io/kubernetes/pkg/watch/filter.go
index 0acbaaf71a6628ffa904f035bdd772c74c0472fa..1eff5b94964bc590dce97dbf80b149f86c95d0ad 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/filter.go
+++ b/vendor/k8s.io/kubernetes/pkg/watch/filter.go
@@ -16,6 +16,10 @@ limitations under the License.
package watch
+import (
+ "sync"
+)
+
// FilterFunc should take an event, possibly modify it in some way, and return
// the modified event. If the event should be ignored, then return keep=false.
type FilterFunc func(in Event) (out Event, keep bool)
@@ -69,3 +73,37 @@ func (fw *filteredWatch) loop() {
}
}
}
+
+// Recorder records all events that are sent from the watch until it is closed.
+type Recorder struct {
+ Interface
+
+ lock sync.Mutex
+ events []Event
+}
+
+var _ Interface = &Recorder{}
+
+// NewRecorder wraps an Interface and records any changes sent across it.
+func NewRecorder(w Interface) *Recorder {
+ r := &Recorder{}
+ r.Interface = Filter(w, r.record)
+ return r
+}
+
+// record is a FilterFunc and tracks each received event.
+func (r *Recorder) record(in Event) (Event, bool) {
+ r.lock.Lock()
+ defer r.lock.Unlock()
+ r.events = append(r.events, in)
+ return in, true
+}
+
+// Events returns a copy of the events sent across this recorder.
+func (r *Recorder) Events() []Event {
+ r.lock.Lock()
+ defer r.lock.Unlock()
+ copied := make([]Event, len(r.events))
+ copy(copied, r.events)
+ return copied
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/mux.go b/vendor/k8s.io/kubernetes/pkg/watch/mux.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/mux.go
rename to vendor/k8s.io/kubernetes/pkg/watch/mux.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/iowatcher.go b/vendor/k8s.io/kubernetes/pkg/watch/streamwatcher.go
similarity index 98%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/iowatcher.go
rename to vendor/k8s.io/kubernetes/pkg/watch/streamwatcher.go
index 505e6bfcabf87dacbcc45e78fd337b821b44bd5f..2802a9e01f4f003051f0b3e991c9d590dbde62b8 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/iowatcher.go
+++ b/vendor/k8s.io/kubernetes/pkg/watch/streamwatcher.go
@@ -42,9 +42,9 @@ type Decoder interface {
// StreamWatcher turns any stream for which you can write a Decoder interface
// into a watch.Interface.
type StreamWatcher struct {
- source Decoder
- result chan Event
sync.Mutex
+ source Decoder
+ result chan Event
stopped bool
}
diff --git a/vendor/k8s.io/kubernetes/pkg/watch/until.go b/vendor/k8s.io/kubernetes/pkg/watch/until.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f34f9d001b22c619e259f4bd5a95e7e678ecd17
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/watch/until.go
@@ -0,0 +1,82 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 watch
+
+import (
+ "time"
+
+ "k8s.io/kubernetes/pkg/util/wait"
+)
+
+// ConditionFunc returns true if the condition has been reached, false if it has not been reached yet,
+// or an error if the condition cannot be checked and should terminate. In general, it is better to define
+// level driven conditions over edge driven conditions (pod has ready=true, vs pod modified and ready changed
+// from false to true).
+type ConditionFunc func(event Event) (bool, error)
+
+// Until reads items from the watch until each provided condition succeeds, and then returns the last watch
+// encountered. The first condition that returns an error terminates the watch (and the event is also returned).
+// If no event has been received, the returned event will be nil.
+// Conditions are satisfied sequentially so as to provide a useful primitive for higher level composition.
+func Until(timeout time.Duration, watcher Interface, conditions ...ConditionFunc) (*Event, error) {
+ ch := watcher.ResultChan()
+ defer watcher.Stop()
+ var after <-chan time.Time
+ if timeout > 0 {
+ after = time.After(timeout)
+ } else {
+ ch := make(chan time.Time)
+ close(ch)
+ after = ch
+ }
+ var lastEvent *Event
+ for _, condition := range conditions {
+ // check the next condition against the previous event and short circuit waiting for the next watch
+ if lastEvent != nil {
+ done, err := condition(*lastEvent)
+ if err != nil {
+ return lastEvent, err
+ }
+ if done {
+ break
+ }
+ }
+ ConditionSucceeded:
+ for {
+ select {
+ case event, ok := <-ch:
+ if !ok {
+ return lastEvent, wait.ErrWaitTimeout
+ }
+ lastEvent = &event
+
+ // TODO: check for watch expired error and retry watch from latest point?
+ done, err := condition(event)
+ if err != nil {
+ return lastEvent, err
+ }
+ if done {
+ break ConditionSucceeded
+ }
+
+ case <-after:
+ return lastEvent, wait.ErrWaitTimeout
+ }
+ }
+ }
+ return lastEvent, nil
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/decoder.go b/vendor/k8s.io/kubernetes/pkg/watch/versioned/decoder.go
similarity index 58%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/decoder.go
rename to vendor/k8s.io/kubernetes/pkg/watch/versioned/decoder.go
index d1632336f672611406b8dade2a77c68885c5f821..2d13ca809ff190e8faf89bfaa7b5cbfb556ade0c 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/decoder.go
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/decoder.go
@@ -14,56 +14,58 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package json
+package versioned
import (
- "encoding/json"
"fmt"
- "io"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer/streaming"
"k8s.io/kubernetes/pkg/watch"
)
// Decoder implements the watch.Decoder interface for io.ReadClosers that
-// have contents which consist of a series of watchEvent objects encoded via JSON.
-// It will decode any object registered in the supplied codec.
+// have contents which consist of a series of watchEvent objects encoded
+// with the given streaming decoder. The internal objects will be then
+// decoded by the embedded decoder.
type Decoder struct {
- r io.ReadCloser
- decoder *json.Decoder
- codec runtime.Codec
+ decoder streaming.Decoder
+ embeddedDecoder runtime.Decoder
}
// NewDecoder creates an Decoder for the given writer and codec.
-func NewDecoder(r io.ReadCloser, codec runtime.Codec) *Decoder {
+func NewDecoder(decoder streaming.Decoder, embeddedDecoder runtime.Decoder) *Decoder {
return &Decoder{
- r: r,
- decoder: json.NewDecoder(r),
- codec: codec,
+ decoder: decoder,
+ embeddedDecoder: embeddedDecoder,
}
}
-// Decode blocks until it can return the next object in the writer. Returns an error
-// if the writer is closed or an object can't be decoded.
+// Decode blocks until it can return the next object in the reader. Returns an error
+// if the reader is closed or an object can't be decoded.
func (d *Decoder) Decode() (watch.EventType, runtime.Object, error) {
- var got WatchEvent
- if err := d.decoder.Decode(&got); err != nil {
+ var got Event
+ res, _, err := d.decoder.Decode(nil, &got)
+ if err != nil {
return "", nil, err
}
+ if res != &got {
+ return "", nil, fmt.Errorf("unable to decode to versioned.Event")
+ }
switch got.Type {
- case watch.Added, watch.Modified, watch.Deleted, watch.Error:
+ case string(watch.Added), string(watch.Modified), string(watch.Deleted), string(watch.Error):
default:
return "", nil, fmt.Errorf("got invalid watch event type: %v", got.Type)
}
- obj, err := runtime.Decode(d.codec, got.Object.RawJSON)
+ obj, err := runtime.Decode(d.embeddedDecoder, got.Object.Raw)
if err != nil {
return "", nil, fmt.Errorf("unable to decode watch event: %v", err)
}
- return got.Type, obj, nil
+ return watch.EventType(got.Type), obj, nil
}
// Close closes the underlying r.
func (d *Decoder) Close() {
- d.r.Close()
+ d.decoder.Close()
}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/encoder.go b/vendor/k8s.io/kubernetes/pkg/watch/versioned/encoder.go
similarity index 58%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/encoder.go
rename to vendor/k8s.io/kubernetes/pkg/watch/versioned/encoder.go
index 1eaf6a8a09cb1e8749aab882fe589ccf3d46227c..8438ee984f3842eb8e9a2d84c1d9364afbfebaca 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/json/encoder.go
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/encoder.go
@@ -14,40 +14,38 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-package json
+package versioned
import (
"encoding/json"
- "io"
"k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/runtime/serializer/streaming"
"k8s.io/kubernetes/pkg/watch"
)
-// Encoder implements the json.Encoder interface for io.Writers that
-// should serialize WatchEvent objects into JSON. It will encode any object
-// registered in the supplied codec and return an error otherwies.
+// Encoder serializes watch.Events into io.Writer. The internal objects
+// are encoded using embedded encoder, and the outer Event is serialized
+// using encoder.
type Encoder struct {
- w io.Writer
- encoder *json.Encoder
- codec runtime.Encoder
+ encoder streaming.Encoder
+ embeddedEncoder runtime.Encoder
}
-// NewEncoder creates an Encoder for the given writer and codec
-func NewEncoder(w io.Writer, codec runtime.Encoder) *Encoder {
+func NewEncoder(encoder streaming.Encoder, embeddedEncoder runtime.Encoder) *Encoder {
return &Encoder{
- w: w,
- encoder: json.NewEncoder(w),
- codec: codec,
+ encoder: encoder,
+ embeddedEncoder: embeddedEncoder,
}
}
// Encode writes an event to the writer. Returns an error
// if the writer is closed or an object can't be encoded.
func (e *Encoder) Encode(event *watch.Event) error {
- obj, err := Object(e.codec, event)
+ data, err := runtime.Encode(e.embeddedEncoder, event.Object)
if err != nil {
return err
}
- return e.encoder.Encode(obj)
+ // FIXME: get rid of json.RawMessage.
+ return e.encoder.Encode(&Event{string(event.Type), runtime.RawExtension{Raw: json.RawMessage(data)}})
}
diff --git a/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.pb.go b/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1cbbd8ba569caf8ba3d942c898340af17b1d1bc
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.pb.go
@@ -0,0 +1,342 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by protoc-gen-gogo.
+// source: k8s.io/kubernetes/pkg/watch/versioned/generated.proto
+// DO NOT EDIT!
+
+/*
+ Package versioned is a generated protocol buffer package.
+
+ It is generated from these files:
+ k8s.io/kubernetes/pkg/watch/versioned/generated.proto
+
+ It has these top-level messages:
+ Event
+*/
+package versioned
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+func (m *Event) Reset() { *m = Event{} }
+func (m *Event) String() string { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage() {}
+
+func init() {
+ proto.RegisterType((*Event)(nil), "k8s.io.kubernetes.pkg.watch.versioned.Event")
+}
+func (m *Event) Marshal() (data []byte, err error) {
+ size := m.Size()
+ data = make([]byte, size)
+ n, err := m.MarshalTo(data)
+ if err != nil {
+ return nil, err
+ }
+ return data[:n], nil
+}
+
+func (m *Event) MarshalTo(data []byte) (int, error) {
+ var i int
+ _ = i
+ var l int
+ _ = l
+ data[i] = 0xa
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
+ i += copy(data[i:], m.Type)
+ data[i] = 0x12
+ i++
+ i = encodeVarintGenerated(data, i, uint64(m.Object.Size()))
+ n1, err := m.Object.MarshalTo(data[i:])
+ if err != nil {
+ return 0, err
+ }
+ i += n1
+ return i, nil
+}
+
+func encodeFixed64Generated(data []byte, offset int, v uint64) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ data[offset+4] = uint8(v >> 32)
+ data[offset+5] = uint8(v >> 40)
+ data[offset+6] = uint8(v >> 48)
+ data[offset+7] = uint8(v >> 56)
+ return offset + 8
+}
+func encodeFixed32Generated(data []byte, offset int, v uint32) int {
+ data[offset] = uint8(v)
+ data[offset+1] = uint8(v >> 8)
+ data[offset+2] = uint8(v >> 16)
+ data[offset+3] = uint8(v >> 24)
+ return offset + 4
+}
+func encodeVarintGenerated(data []byte, offset int, v uint64) int {
+ for v >= 1<<7 {
+ data[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ data[offset] = uint8(v)
+ return offset + 1
+}
+func (m *Event) Size() (n int) {
+ var l int
+ _ = l
+ l = len(m.Type)
+ n += 1 + l + sovGenerated(uint64(l))
+ l = m.Object.Size()
+ n += 1 + l + sovGenerated(uint64(l))
+ return n
+}
+
+func sovGenerated(x uint64) (n int) {
+ for {
+ n++
+ x >>= 7
+ if x == 0 {
+ break
+ }
+ }
+ return n
+}
+func sozGenerated(x uint64) (n int) {
+ return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Event) Unmarshal(data []byte) error {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Event: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Type = string(data[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ msglen |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + msglen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Object.Unmarshal(data[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenerated(data[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if skippy < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenerated(data []byte) (n int, err error) {
+ l := len(data)
+ iNdEx := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if data[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ return iNdEx, nil
+ case 1:
+ iNdEx += 8
+ return iNdEx, nil
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ iNdEx += length
+ if length < 0 {
+ return 0, ErrInvalidLengthGenerated
+ }
+ return iNdEx, nil
+ case 3:
+ for {
+ var innerWire uint64
+ var start int = iNdEx
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ innerWire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ innerWireType := int(innerWire & 0x7)
+ if innerWireType == 4 {
+ break
+ }
+ next, err := skipGenerated(data[start:])
+ if err != nil {
+ return 0, err
+ }
+ iNdEx = start + next
+ }
+ return iNdEx, nil
+ case 4:
+ return iNdEx, nil
+ case 5:
+ iNdEx += 4
+ return iNdEx, nil
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ }
+ panic("unreachable")
+}
+
+var (
+ ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
+)
diff --git a/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.proto b/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5bb702210e2f7368bf7989894ef2c412a868dc22
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/generated.proto
@@ -0,0 +1,43 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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.
+*/
+
+
+// This file was autogenerated by go-to-protobuf. Do not edit it manually!
+
+syntax = 'proto2';
+
+package k8s.io.kubernetes.pkg.watch.versioned;
+
+import "k8s.io/kubernetes/pkg/runtime/generated.proto";
+import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
+
+// Package-wide variables from generator "generated".
+option go_package = "versioned";
+
+// Event represents a single event to a watched resource.
+//
+// +protobuf=true
+message Event {
+ optional string type = 1;
+
+ // 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: *api.Status is recommended; other types may make sense
+ // depending on context.
+ optional k8s.io.kubernetes.pkg.runtime.RawExtension object = 2;
+}
+
diff --git a/vendor/k8s.io/kubernetes/pkg/watch/versioned/register.go b/vendor/k8s.io/kubernetes/pkg/watch/versioned/register.go
new file mode 100644
index 0000000000000000000000000000000000000000..feaea3b6b799e5009bd064cf3dfb72b58dad87e3
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/register.go
@@ -0,0 +1,84 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 versioned
+
+import (
+ "k8s.io/kubernetes/pkg/api/unversioned"
+ "k8s.io/kubernetes/pkg/conversion"
+ "k8s.io/kubernetes/pkg/runtime"
+ "k8s.io/kubernetes/pkg/watch"
+)
+
+// WatchEventKind is name reserved for serializing watch events.
+const WatchEventKind = "WatchEvent"
+
+// AddToGroupVersion registers the watch external and internal kinds with the scheme, and ensures the proper
+// conversions are in place.
+func AddToGroupVersion(scheme *runtime.Scheme, groupVersion unversioned.GroupVersion) {
+ scheme.AddKnownTypeWithName(groupVersion.WithKind(WatchEventKind), &Event{})
+ scheme.AddKnownTypeWithName(
+ unversioned.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}.WithKind(WatchEventKind),
+ &InternalEvent{},
+ )
+ scheme.AddConversionFuncs(
+ Convert_versioned_Event_to_watch_Event,
+ Convert_versioned_InternalEvent_to_versioned_Event,
+ Convert_watch_Event_to_versioned_Event,
+ Convert_versioned_Event_to_versioned_InternalEvent,
+ )
+}
+
+func Convert_watch_Event_to_versioned_Event(in *watch.Event, out *Event, s conversion.Scope) error {
+ out.Type = string(in.Type)
+ switch t := in.Object.(type) {
+ case *runtime.Unknown:
+ // TODO: handle other fields on Unknown and detect type
+ out.Object.Raw = t.Raw
+ case nil:
+ default:
+ out.Object.Object = in.Object
+ }
+ return nil
+}
+
+func Convert_versioned_InternalEvent_to_versioned_Event(in *InternalEvent, out *Event, s conversion.Scope) error {
+ return Convert_watch_Event_to_versioned_Event((*watch.Event)(in), out, s)
+}
+
+func Convert_versioned_Event_to_watch_Event(in *Event, out *watch.Event, s conversion.Scope) error {
+ out.Type = watch.EventType(in.Type)
+ if in.Object.Object != nil {
+ out.Object = in.Object.Object
+ } else if in.Object.Raw != nil {
+ // TODO: handle other fields on Unknown and detect type
+ out.Object = &runtime.Unknown{
+ Raw: in.Object.Raw,
+ ContentType: runtime.ContentTypeJSON,
+ }
+ }
+ return nil
+}
+
+func Convert_versioned_Event_to_versioned_InternalEvent(in *Event, out *InternalEvent, s conversion.Scope) error {
+ return Convert_versioned_Event_to_watch_Event(in, (*watch.Event)(out), s)
+}
+
+// InternalEvent makes watch.Event versioned
+type InternalEvent watch.Event
+
+func (e *InternalEvent) GetObjectKind() unversioned.ObjectKind { return unversioned.EmptyObjectKind }
+func (e *Event) GetObjectKind() unversioned.ObjectKind { return unversioned.EmptyObjectKind }
diff --git a/vendor/k8s.io/kubernetes/pkg/watch/versioned/types.go b/vendor/k8s.io/kubernetes/pkg/watch/versioned/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..ba608aeab0294a1af2fb6cb7cf36b6921137145e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/pkg/watch/versioned/types.go
@@ -0,0 +1,37 @@
+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+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 versioned contains the versioned types for watch. This is the first
+// serialization version unless otherwise noted.
+package versioned
+
+import (
+ "k8s.io/kubernetes/pkg/runtime"
+)
+
+// Event represents a single event to a watched resource.
+//
+// +protobuf=true
+type Event struct {
+ Type string `json:"type" protobuf:"bytes,1,opt,name=type"`
+
+ // 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: *api.Status is recommended; other types may make sense
+ // depending on context.
+ Object runtime.RawExtension `json:"object" protobuf:"bytes,2,opt,name=object"`
+}
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/watch.go b/vendor/k8s.io/kubernetes/pkg/watch/watch.go
similarity index 95%
rename from Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/watch.go
rename to vendor/k8s.io/kubernetes/pkg/watch/watch.go
index 93c34d936b5d6fcca6f121e36e6c782ce00ea62b..e8fca0a62497915c073111e73d7f7f8998c70f28 100644
--- a/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/watch.go
+++ b/vendor/k8s.io/kubernetes/pkg/watch/watch.go
@@ -99,6 +99,14 @@ func (f *FakeWatcher) Stop() {
}
}
+// Reset prepares the watcher to be reused.
+func (f *FakeWatcher) Reset() {
+ f.Lock()
+ defer f.Unlock()
+ f.Stopped = false
+ f.result = make(chan Event)
+}
+
func (f *FakeWatcher) ResultChan() <-chan Event {
return f.result
}
diff --git a/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/gcp/gcp.go b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/gcp/gcp.go
new file mode 100644
index 0000000000000000000000000000000000000000..1efbb20f11a6f3fc3cf1ca75c936ce3954817b8e
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/gcp/gcp.go
@@ -0,0 +1,106 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 gcp
+
+import (
+ "net/http"
+ "time"
+
+ "github.com/golang/glog"
+ "golang.org/x/net/context"
+ "golang.org/x/oauth2"
+ "golang.org/x/oauth2/google"
+
+ "k8s.io/kubernetes/pkg/client/restclient"
+)
+
+func init() {
+ if err := restclient.RegisterAuthProviderPlugin("gcp", newGCPAuthProvider); err != nil {
+ glog.Fatalf("Failed to register gcp auth plugin: %v", err)
+ }
+}
+
+type gcpAuthProvider struct {
+ tokenSource oauth2.TokenSource
+ persister restclient.AuthProviderConfigPersister
+}
+
+func newGCPAuthProvider(_ string, gcpConfig map[string]string, persister restclient.AuthProviderConfigPersister) (restclient.AuthProvider, error) {
+ ts, err := newCachedTokenSource(gcpConfig["access-token"], gcpConfig["expiry"], persister)
+ if err != nil {
+ return nil, err
+ }
+ return &gcpAuthProvider{ts, persister}, nil
+}
+
+func (g *gcpAuthProvider) WrapTransport(rt http.RoundTripper) http.RoundTripper {
+ return &oauth2.Transport{
+ Source: g.tokenSource,
+ Base: rt,
+ }
+}
+
+func (g *gcpAuthProvider) Login() error { return nil }
+
+type cachedTokenSource struct {
+ source oauth2.TokenSource
+ accessToken string
+ expiry time.Time
+ persister restclient.AuthProviderConfigPersister
+}
+
+func newCachedTokenSource(accessToken, expiry string, persister restclient.AuthProviderConfigPersister) (*cachedTokenSource, error) {
+ var expiryTime time.Time
+ if parsedTime, err := time.Parse(time.RFC3339Nano, expiry); err == nil {
+ expiryTime = parsedTime
+ }
+ ts, err := google.DefaultTokenSource(context.Background(), "https://www.googleapis.com/auth/cloud-platform")
+ if err != nil {
+ return nil, err
+ }
+ return &cachedTokenSource{
+ source: ts,
+ accessToken: accessToken,
+ expiry: expiryTime,
+ persister: persister,
+ }, nil
+}
+
+func (t *cachedTokenSource) Token() (*oauth2.Token, error) {
+ tok := &oauth2.Token{
+ AccessToken: t.accessToken,
+ TokenType: "Bearer",
+ Expiry: t.expiry,
+ }
+ if tok.Valid() && !tok.Expiry.IsZero() {
+ return tok, nil
+ }
+ tok, err := t.source.Token()
+ if err != nil {
+ return nil, err
+ }
+ if t.persister != nil {
+ cached := map[string]string{
+ "access-token": tok.AccessToken,
+ "expiry": tok.Expiry.Format(time.RFC3339Nano),
+ }
+ if err := t.persister.Persist(cached); err != nil {
+ glog.V(4).Infof("Failed to persist token: %v", err)
+ }
+ }
+ return tok, nil
+}
diff --git a/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/OWNERS b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/OWNERS
new file mode 100644
index 0000000000000000000000000000000000000000..ecf334993493009e75a3bb5615aef8044e8d39dd
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/OWNERS
@@ -0,0 +1,2 @@
+assignees:
+ - bobbyrullo
diff --git a/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/oidc.go b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/oidc.go
new file mode 100644
index 0000000000000000000000000000000000000000..3ad279c106e99c0b8d2f5abf89d39ffd4bebc00f
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/oidc/oidc.go
@@ -0,0 +1,270 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 oidc
+
+import (
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "net/http"
+ "strings"
+ "time"
+
+ "github.com/coreos/go-oidc/jose"
+ "github.com/coreos/go-oidc/oauth2"
+ "github.com/coreos/go-oidc/oidc"
+ "github.com/golang/glog"
+
+ "k8s.io/kubernetes/pkg/client/restclient"
+ "k8s.io/kubernetes/pkg/util/wait"
+)
+
+const (
+ cfgIssuerUrl = "idp-issuer-url"
+ cfgClientID = "client-id"
+ cfgClientSecret = "client-secret"
+ cfgCertificateAuthority = "idp-certificate-authority"
+ cfgCertificateAuthorityData = "idp-certificate-authority-data"
+ cfgExtraScopes = "extra-scopes"
+ cfgIDToken = "id-token"
+ cfgRefreshToken = "refresh-token"
+)
+
+var (
+ backoff = wait.Backoff{
+ Duration: 1 * time.Second,
+ Factor: 2,
+ Jitter: .1,
+ Steps: 5,
+ }
+)
+
+func init() {
+ if err := restclient.RegisterAuthProviderPlugin("oidc", newOIDCAuthProvider); err != nil {
+ glog.Fatalf("Failed to register oidc auth plugin: %v", err)
+ }
+}
+
+func newOIDCAuthProvider(_ string, cfg map[string]string, persister restclient.AuthProviderConfigPersister) (restclient.AuthProvider, error) {
+ issuer := cfg[cfgIssuerUrl]
+ if issuer == "" {
+ return nil, fmt.Errorf("Must provide %s", cfgIssuerUrl)
+ }
+
+ clientID := cfg[cfgClientID]
+ if clientID == "" {
+ return nil, fmt.Errorf("Must provide %s", cfgClientID)
+ }
+
+ clientSecret := cfg[cfgClientSecret]
+ if clientSecret == "" {
+ return nil, fmt.Errorf("Must provide %s", cfgClientSecret)
+ }
+
+ var certAuthData []byte
+ var err error
+ if cfg[cfgCertificateAuthorityData] != "" {
+ certAuthData, err = base64.StdEncoding.DecodeString(cfg[cfgCertificateAuthorityData])
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ clientConfig := restclient.Config{
+ TLSClientConfig: restclient.TLSClientConfig{
+ CAFile: cfg[cfgCertificateAuthority],
+ CAData: certAuthData,
+ },
+ }
+
+ trans, err := restclient.TransportFor(&clientConfig)
+ if err != nil {
+ return nil, err
+ }
+ hc := &http.Client{Transport: trans}
+
+ providerCfg, err := oidc.FetchProviderConfig(hc, strings.TrimSuffix(issuer, "/"))
+ if err != nil {
+ return nil, fmt.Errorf("error fetching provider config: %v", err)
+ }
+
+ scopes := strings.Split(cfg[cfgExtraScopes], ",")
+ oidcCfg := oidc.ClientConfig{
+ HTTPClient: hc,
+ Credentials: oidc.ClientCredentials{
+ ID: clientID,
+ Secret: clientSecret,
+ },
+ ProviderConfig: providerCfg,
+ Scope: append(scopes, oidc.DefaultScope...),
+ }
+
+ client, err := oidc.NewClient(oidcCfg)
+ if err != nil {
+ return nil, fmt.Errorf("error creating OIDC Client: %v", err)
+ }
+
+ oClient := &oidcClient{client}
+
+ var initialIDToken jose.JWT
+ if cfg[cfgIDToken] != "" {
+ initialIDToken, err = jose.ParseJWT(cfg[cfgIDToken])
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return &oidcAuthProvider{
+ initialIDToken: initialIDToken,
+ refresher: &idTokenRefresher{
+ client: oClient,
+ cfg: cfg,
+ persister: persister,
+ },
+ }, nil
+}
+
+type oidcAuthProvider struct {
+ refresher *idTokenRefresher
+ initialIDToken jose.JWT
+}
+
+func (g *oidcAuthProvider) WrapTransport(rt http.RoundTripper) http.RoundTripper {
+ at := &oidc.AuthenticatedTransport{
+ TokenRefresher: g.refresher,
+ RoundTripper: rt,
+ }
+ at.SetJWT(g.initialIDToken)
+ return &roundTripper{
+ wrapped: at,
+ refresher: g.refresher,
+ }
+}
+
+func (g *oidcAuthProvider) Login() error {
+ return errors.New("not yet implemented")
+}
+
+type OIDCClient interface {
+ refreshToken(rt string) (oauth2.TokenResponse, error)
+ verifyJWT(jwt jose.JWT) error
+}
+
+type roundTripper struct {
+ refresher *idTokenRefresher
+ wrapped *oidc.AuthenticatedTransport
+}
+
+func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+ var res *http.Response
+ var err error
+ firstTime := true
+ wait.ExponentialBackoff(backoff, func() (bool, error) {
+ if !firstTime {
+ var jwt jose.JWT
+ jwt, err = r.refresher.Refresh()
+ if err != nil {
+ return true, nil
+ }
+ r.wrapped.SetJWT(jwt)
+ } else {
+ firstTime = false
+ }
+
+ res, err = r.wrapped.RoundTrip(req)
+ if err != nil {
+ return true, nil
+ }
+ if res.StatusCode == http.StatusUnauthorized {
+ return false, nil
+ }
+ return true, nil
+ })
+ return res, err
+}
+
+type idTokenRefresher struct {
+ cfg map[string]string
+ client OIDCClient
+ persister restclient.AuthProviderConfigPersister
+ intialIDToken jose.JWT
+}
+
+func (r *idTokenRefresher) Verify(jwt jose.JWT) error {
+ claims, err := jwt.Claims()
+ if err != nil {
+ return err
+ }
+
+ now := time.Now()
+ exp, ok, err := claims.TimeClaim("exp")
+ switch {
+ case err != nil:
+ return fmt.Errorf("failed to parse 'exp' claim: %v", err)
+ case !ok:
+ return errors.New("missing required 'exp' claim")
+ case exp.Before(now):
+ return fmt.Errorf("token already expired at: %v", exp)
+ }
+
+ return nil
+}
+
+func (r *idTokenRefresher) Refresh() (jose.JWT, error) {
+ rt, ok := r.cfg[cfgRefreshToken]
+ if !ok {
+ return jose.JWT{}, errors.New("No valid id-token, and cannot refresh without refresh-token")
+ }
+
+ tokens, err := r.client.refreshToken(rt)
+ if err != nil {
+ return jose.JWT{}, fmt.Errorf("could not refresh token: %v", err)
+ }
+ jwt, err := jose.ParseJWT(tokens.IDToken)
+ if err != nil {
+ return jose.JWT{}, err
+ }
+
+ if tokens.RefreshToken != "" && tokens.RefreshToken != rt {
+ r.cfg[cfgRefreshToken] = tokens.RefreshToken
+ }
+ r.cfg[cfgIDToken] = jwt.Encode()
+
+ err = r.persister.Persist(r.cfg)
+ if err != nil {
+ return jose.JWT{}, fmt.Errorf("could not perist new tokens: %v", err)
+ }
+
+ return jwt, r.client.verifyJWT(jwt)
+}
+
+type oidcClient struct {
+ client *oidc.Client
+}
+
+func (o *oidcClient) refreshToken(rt string) (oauth2.TokenResponse, error) {
+ oac, err := o.client.OAuthClient()
+ if err != nil {
+ return oauth2.TokenResponse{}, err
+ }
+
+ return oac.RequestToken(oauth2.GrantTypeRefreshToken, rt)
+}
+
+func (o *oidcClient) verifyJWT(jwt jose.JWT) error {
+ return o.client.VerifyJWT(jwt)
+}
diff --git a/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/plugins.go b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/plugins.go
new file mode 100644
index 0000000000000000000000000000000000000000..2b422ddda02363d9dab766abd2b0c2feb2bec99b
--- /dev/null
+++ b/vendor/k8s.io/kubernetes/plugin/pkg/client/auth/plugins.go
@@ -0,0 +1,23 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 plugins
+
+import (
+ // Initialize all known client auth plugins.
+ _ "k8s.io/kubernetes/plugin/pkg/client/auth/gcp"
+ _ "k8s.io/kubernetes/plugin/pkg/client/auth/oidc"
+)
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/json/LICENSE b/vendor/k8s.io/kubernetes/third_party/forked/json/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/json/LICENSE
rename to vendor/k8s.io/kubernetes/third_party/forked/json/LICENSE
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/json/fields.go b/vendor/k8s.io/kubernetes/third_party/forked/json/fields.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/json/fields.go
rename to vendor/k8s.io/kubernetes/third_party/forked/json/fields.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/reflect/LICENSE b/vendor/k8s.io/kubernetes/third_party/forked/reflect/LICENSE
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/reflect/LICENSE
rename to vendor/k8s.io/kubernetes/third_party/forked/reflect/LICENSE
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/reflect/deep_equal.go b/vendor/k8s.io/kubernetes/third_party/forked/reflect/deep_equal.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/forked/reflect/deep_equal.go
rename to vendor/k8s.io/kubernetes/third_party/forked/reflect/deep_equal.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/netutil/addr.go b/vendor/k8s.io/kubernetes/third_party/golang/netutil/addr.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/netutil/addr.go
rename to vendor/k8s.io/kubernetes/third_party/golang/netutil/addr.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/template/exec.go b/vendor/k8s.io/kubernetes/third_party/golang/template/exec.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/template/exec.go
rename to vendor/k8s.io/kubernetes/third_party/golang/template/exec.go
diff --git a/Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/template/funcs.go b/vendor/k8s.io/kubernetes/third_party/golang/template/funcs.go
similarity index 100%
rename from Godeps/_workspace/src/k8s.io/kubernetes/third_party/golang/template/funcs.go
rename to vendor/k8s.io/kubernetes/third_party/golang/template/funcs.go